BSetMap.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 ITEMSETMAP_H
#define ITEMSETMAP_H

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

#include <vector>
#include <ext/hash_map>

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

#include "ItemSetCompare.h"

template <typename t> class ItemSetMap
{
    // ----------------------------- Definitions ---------------------------- //
    typedef __gnu_cxx::hash_map<ItemSet*, unsigned int, hash<const ItemSet*>,
        eqis> h_map;
    typedef h_map::iterator h_iter;

    private:
        // This is the ordered vector of the sets
        vector<ItemSet*> vsets;

        // This is the ordered vector of values
        vector<t*> vvals;

        // This is the hash table of the sets
        h_map hsets;

    public:
        ItemSetMap()
        {

        }

        ItemSetMap(unsigned int size)
        {
            vsets.resize(size);
        }

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

        ~ItemSetMap()
        {

        }

        ItemSetMap& operator =(const ItemSetMap& rhs)
        {
            vsets = rhs.vsets;
            vvals = rhs.vvals;
            hsets = rhs.hsets;
            return *this;
        }

        ItemSet*& operator [](unsigned int index)
        {
            return vsets[index];
        }

        ItemSet*& back()
        {
            return vsets.back();
        }

        void clear()
        {
            vsets.clear();
            vvals.clear();
            hsets.clear();
        }

        void destroy()
        {
            for (unsigned int i = 0; i < vsets.size(); i++)
            {
                delete vsets[i];
                delete vvals[i];
            }
        }

        bool empty() const
        {
            return vsets.empty();
        }

        bool contains(ItemSet& is) const
        {
            return contains(&is);
        }

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

        void insert(ItemSet* is, const t& value)
        {
            insert(is, new t(value));
        }

        void insert(ItemSet* is, t* value = new t)
        {
            hsets[is] = vsets.size();
            vsets.push_back(is);
            vvals.push_back(value);
        }

        unsigned int size() const
        {
            return vsets.size();
        }

        ItemSet* getItemSet(ItemSet* is)
        {
            return (*hsets.find(is)).first;
        }

        ItemSet* getItemSet(ItemSet& is)
        {
            return getValue(&is);
        }

        ItemSet* getItemSet (unsigned int index)
        {
            return vsets[index];
        }

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

        t& getValue(ItemSet& is)
        {
            return getValue(&is);
        }

        t& getValue(unsigned int index)
        {
            return *vvals[index];
        }
};

#endif