ItemsetLevel.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 ITEMSETLEVEL_H
#define ITEMSETLEVEL_H

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

#include "ItemsetCompare.h"

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

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

#include <iostream>

template <typename t> class ItemsetLevel
{
    private:
    // ----------------------------- Definitions ---------------------------- //
    typedef __gnu_cxx::hash_map<Itemset*, unsigned int, hash<const Itemset*>,
        eqis> h_map;
    typedef h_map::iterator h_iter;
    typedef h_map::const_iterator h_citer;
    typedef map<Itemset*, unsigned int, ltis<const Itemset*> > o_map;
    typedef o_map::iterator o_iter;
    typedef o_map::const_iterator o_citer;

        // This is the vector of itemsets
        vector<Itemset*> vsets;

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

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

        // This is the ordered map of itemsets
        map<Itemset*, unsigned int> msets;

        // This is the level
        unsigned int level;

        // Whether or not we should order them
        bool order;

    public:
        typedef map<Itemset*, unsigned int, ltis<const Itemset*> >::iterator
            iterator;
        typedef map<Itemset*, unsigned int,
            ltis<const Itemset*> >::const_iterator const_iterator;

        // The constructor                                                    //
        ItemsetLevel(unsigned int level = 0, bool order = false)
        {
            this->level = level;
            this->order = order;
        }

        // The copy constructor                                               //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // const ItemsetLevel& src                                            //
        //     The source itemset level                                       //
        ItemsetLevel(const ItemsetLevel& src)
        {
            *this = src;
        }

        // The destructor                                                     //
        ~ItemsetLevel()
        {

        }

        // The = operator                                                     //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // const ItemsetLevel& rhs                                            //
        //     The right hand side                                            //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // *this                                                              //
        ItemsetLevel& operator =(const ItemsetLevel& rhs)
        {
            vsets = rhs.vsets;
            vvals = rhs.vvals;
            hsets = rhs.hsets;
            level = rhs.level;
            order = rhs.order;
            return *this;
        }

        // If we are adding by order, we can use the [] operator to access    //
        // itemsets                                                           //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // unsigned int index                                                 //
        //     The index                                                      //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // A pointer to the itemset at that index                             //
        Itemset* operator [](unsigned int index)
        {
            return vsets[index];
        }

        // If we are adding by order, we can use the [] operator to access    //
        // the last itemset                                                   //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // A pointer to the last itemset                                      //
        Itemset* back()
        {
            return vsets.back();
        }

        // Clears the structure                                               //
        void clear()
        {
            vsets.clear();
            vvals.clear();
            hsets.clear();
            msets.clear();
        }

        // Destroys all the itemsets                                          //
        void destroy()
        {
            // See if we need to delete the itemsets from the map
            if (order)
            {
                for (o_iter i = msets.begin(); i != msets.end(); i++)
                {
                    delete i->first;
                }
            }

            // If we reach this else, we need to delete the itemsets from
            // the vector
            else
            {
                for (unsigned int i = 0; i < vsets.size(); i++)
                {
                    /*cout << "i: " << i << " / " << vsets.size() << endl;
                    for (unsigned int j = 0; j < vsets[i]->getSize(); j++)
                    {
                        if (j)
                        {
                            cout << ", ";
                        }
                        cout << vsets[i]->getItem(j);
                    }
                    cout << endl;*/
                    delete vsets[i];
                }
            }

            // Delete the values
            for (unsigned int i = 0; i < vvals.size(); i++)
            {
                delete vvals[i];
            }
        }

        // Tests to see if we have no itemsets                                //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // true: we have no itemsets                                          //
        // false: we have itemsets                                            //
        bool isEmpty() const
        {
            return vvals.empty();
        }

        // Inserts an itemset into the structure                              //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // Itemset* is                                                        //
        //     The itemset                                                    //
        // const t& value                                                     //
        //     the value that we want to add                                  //
        void insert(Itemset* is, const t& value)
        {
            insert(is, new t(value));
        }

        // Inserts an itemset into the structure                              //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // Itemset* is                                                        //
        //     The itemset                                                    //
        // const t* value                                                     //
        //     the value that we want to add                                  //
        void insert(Itemset* is, t* value = new t)
        {
            // Insert the itemset into the hashmap
            hsets[is] = vvals.size();

            // See if we need to add it to the map
            if (order)
            {
                msets[is] = vvals.size();
            }

            // At this point, we know we need to add it to the vector
            else
            {
                vsets.push_back(is);
            }

            // Insert the value into the vector
            vvals.push_back(value);
        }

        // gets the size of the structure                                     //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // the size                                                           //
        unsigned int getSize() const
        {
            return vvals.size();
        }

        // Sets the level                                                     //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // unsigned int level                                                 //
        //     the level                                                      //
        void setLevel(unsigned int level)
        {
            this->level = level;
        }

        // Gets the level                                                     //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // The level                                                          //
        unsigned int getLevel() const
        {
            return level;
        }

        // Gets the value                                                     //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // unsigned int index                                                 //
        //     the index                                                      //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // A pointer to the value                                             //
        t* getValue(unsigned int index)
        {
            return vvals[index];
        }

        // Gets the value                                                     //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // unsigned int index                                                 //
        //     the index                                                      //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // A pointer to the value                                             //
        const t* getValue(unsigned int index) const
        {
            return vvals[index];
        }

        // Gets the value                                                     //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // const Itemset* is                                                  //
        //     the itemset                                                    //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // A pointer to the value                                             //
        t* getValue(/*const*/ Itemset* is)
        {
           h_iter iter = hsets.find(is);
           if (iter == hsets.end())
           {
               return NULL;
           }
           return vvals[(*iter).second];
        }

        // Gets the value                                                     //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // const Itemset& is                                                  //
        //     the itemset                                                    //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // A pointer to the value                                             //
        /*const t* getValue(const Itemset& is) const
        {
            // Ugly ugly hack
            // should be: return getValue(&is)
            Itemset* dummy = new Itemset(is.getSize());
            for (unsigned int i = 0; i < is.getSize(); i++) 
            {
                dummy->setItem(i, is[i]);
            }
            t* ret = getValue(dummy);
            delete dummy;
            return ret;
        }*/

        // Gets the value                                                     //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // const Itemset& is                                                  //
        //     the itemset                                                    //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // A pointer to the value                                             //
        t* getValue(const Itemset& is)
        {
            // Ugly ugly hack
            // should be: return getValue(&is)
            Itemset* dummy = new Itemset(is.getSize());
            for (unsigned int i = 0; i < is.getSize(); i++) 
            {
                dummy->setItem(i, is[i]);
            }
            t* ret = getValue(dummy);
            delete dummy;
            return ret;
        }

        // Gets an itemset                                                    //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // unsigned int index                                                 //
        //     the index                                                      //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // A pointer to the itemset                                           //
        const Itemset* getItemset(unsigned int index) const
        {
            return vsets[index];
        }

        // Sees if an itemset exists at this level                            //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // Itemset* is                                                        //
        //     the itemset                                                    //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // true:                                                              //
        //     The itemset does exist                                         //
        // false:                                                             //
        //     The itemset does not exist                                     //
        bool contains(Itemset* is)
        {
            return hsets.find(is) != hsets.end();
        }

        // Sees if an itemset exists at this level                            //
        //                                                                    //
        // --------------------------- Parameters --------------------------- //
        // Itemset& is                                                        //
        //     the itemset                                                    //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // true:                                                              //
        //     The itemset does exist                                         //
        // false:                                                             //
        //     The itemset does not exist                                     //
        bool contains(Itemset& is)
        {
            return contains(&is);
        }

        // Gets an iterator to the beginning of the level                     //
        //                                                                    //
        // -------------------------- Preconditions ------------------------- //
        // order                                                              //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // An iterator to the beginning of the map                            //
        iterator begin()
        {
            return msets.begin();
        }

        // Gets an iterator to the end of the level                           //
        //                                                                    //
        // -------------------------- Preconditions ------------------------- //
        // order                                                              //
        //                                                                    //
        // ----------------------------- Return ----------------------------- //
        // An iterator to the end of the map                                  //
        iterator end()
        {
            return msets.end();
        }
};

#endif