LevItemSetMap.h

/**************************************************************************
 * Copyright (c) 2007 Clifford Conley Owens III                           *
 *                                                                        *
 * This file is part of Biorithm.                                         *
 *                                                                        *
 * Biorithm is free software: you can redistribute it and/or modify       *
 * it under the terms of the GNU General Public License as published by   *
 * the Free Software Foundation, either version 3 of the License, or      *
 * (at your option) any later version.                                    *
 *                                                                        *
 * Biorithm is distributed in the hope that it will be useful,            *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 * GNU General Public License for more details.                           *
 *                                                                        *
 * You should have received a copy of the GNU General Public License      *
 * along with Biorithm.  If not, see <http://www.gnu.org/licenses/>.      *
 *                                                                        *
 **************************************************************************/

#ifndef LEVITEMSETMAP_H
#define LEVITEMSETMAP_H

// ---------------------------- External Headers ---------------------------- //

#include <vector>
#include <map>

// ---------------------------- Internal Headers ---------------------------- //

#include "ItemSet.h"
#include <iostream>
template <typename t> class LevItemSetMap
{
    // ----------------------------- Definitions ---------------------------- //
    typedef map<ItemSet, t> i_map;
    typedef typename i_map::iterator m_iter;
    typedef typename i_map::const_iterator m_citer;

    private:
        // This is the map of the sets
        i_map msets;

        // This is a vector of iterators denoting the starting points
        // of each level
        vector<m_iter> starts;
        vector<m_citer> cstarts;

        // The size of each level
        vector<unsigned int> sizes;

    public:
        LevItemSetMap()
        {

        }

        LevItemSetMap(const LevItemSetMap& src)
        {
            *this = src;
        }

        ~LevItemSetMap()
        {

        }

        LevItemSetMap& operator =(const LevItemSetMap& rhs)
        {
            msets = rhs.msets;
            starts = starts;
            return *this;
        }

        ItemSet*& back()
        {
            // TODO figure out what we are returning
            return *(msets.end()--);
        }

        void clear()
        {
            msets.clear();
            starts.clear();
            sizes.clear();
        }

        bool empty(unsigned int level) const
        {
            //cout << sizes.size() << endl;
            //cout << level << endl;
            //cout << sizes[level] << endl;
            return level >= sizes.size() || !sizes[level];
        }

        bool contains(const ItemSet& is) const
        {
            return msets.find(is) != msets.end();
        }

        void insert(const ItemSet& is, const t& value)
        {
            msets[is] = value;
            if (is.size() >= starts.size())
            {
                starts.resize(is.size() + 1);
                cstarts.resize(is.size() + 1);
                sizes.resize(is.size() + 1, 0);
            }
            if (!sizes[is.size()])
            {
                starts[is.size()] = msets.end();
                starts[is.size()]--;
                cstarts[is.size()] = starts[is.size()];
            }
            sizes[is.size()]++;
        }

        unsigned int size(unsigned int level) const
        {
            if (level >= sizes.size())
            {
                return 0;
            }
            return sizes[level];
        }

        const ItemSet& getItemSet(const ItemSet& is)
        {
            return (*msets.find(is)).first;
        }

        const t& getValue() const
        {
            m_citer last = msets.end();
            last--;
            return (*last).second;
        }

        const t& getValue(const ItemSet& is) const 
        {
            return (*msets.find(is)).second;
        }

        void setValue(const ItemSet& is, const t& value)
        {
            (*msets.find(is)).second = value;
        }

        void setValue(const t& value)
        {
            m_iter last = msets.end();
            last--;
            (*last).second = value;
        }

        void pop()
        {
            m_iter last = msets.end();
            last--;
            sizes[(*last).first.size()]--;
            //cout << "level: " << (*last).first.size() << endl;
            msets.erase(last);
        }

        m_iter begin(unsigned int level)
        {
            //cout << starts.size() << endl;
            if (level < starts.size())
            {
                return starts[level];
            }
            return msets.end();
        }

        m_iter end(unsigned int level)
        {
            return begin(level + 1);
        }

        m_citer begin(unsigned int level) const
        {
            //cout << cstarts.size() << endl;
            if (level < cstarts.size())
            {
                return cstarts[level];
            }
            return msets.end();

        }

        m_citer end(unsigned int level) const
        {
            return begin(level + 1);
        }
};

#endif