|| || || || || || || ||

---

SimpleMap.h

Go to the documentation of this file.

#ifndef Impala_Util_SimpleMap_h
#define Impala_Util_SimpleMap_h

#include <iostream>
#include <map>
#include <vector>
#include "Basis/ILog.h"
#include "Util/Traits.h"

namespace Impala
{
namespace Util
{

template<class IdxT, class ElemT, class DelT>
class SimpleMapBase
{
public:

    SimpleMapBase()
    {
    }

    int
    Size()
    {
        return mMap.size();
    }

    void
    Add(IdxT idx, ElemT elem)
    {
        mMap[idx] = elem;
    }

    bool
    Get(IdxT idx, ElemT& elem) const
    {
        ConstIter it = mMap.find(idx);
        if (it == mMap.end())
            return false;
        elem = it->second;
        return true;
    }

    std::vector<ElemT>
    GetAll() const
    {
        std::vector<ElemT> res;
        for (ConstIter it=mMap.begin() ; it!=mMap.end() ; it++)
            res.push_back(it->second);
        return res;
    }

    bool
    GetIdx(ElemT elem, IdxT& idx) const
    {
        for (ConstIter it=mMap.begin() ; it!=mMap.end() ; it++)
        {
            if (it->second == elem)
            {
                idx = it->first;
                return true;
            }
        }
        return false;
    }

    std::vector<IdxT>
    GetAllIdx() const
    {
        std::vector<IdxT> res;
        for (ConstIter it=mMap.begin() ; it!=mMap.end() ; it++)
            res.push_back(it->first);
        return res;
    }

    bool
    Remove(IdxT idx)
    {
        Iter it = mMap.find(idx);
        if (it == mMap.end())
            return false;
        mDelete(it->second);
        mMap.erase(it);
        return true;
    }

    void
    Dump(std::string name) const
    {
        ILOG_VAR(Util.SimpleMapBase);
        ILOG_INFO(name << "Dump start");
        for (ConstIter i=mMap.begin() ; i!=mMap.end() ; i++)
            ILOG_INFO(i->first << " = " << i->second);
        ILOG_INFO("Dump end");
    }

    void
    Clear()
    {
        for(Iter it=mMap.begin() ; it!=mMap.end() ; ++it)
        {
            mDelete(it->second);
        }
        mMap.clear();
    }
    
private:

    SimpleMapBase(const SimpleMapBase&)
    {
    }

    SimpleMapBase&
    operator=(const SimpleMapBase&)
    {
    }

    typedef typename std::map<IdxT,ElemT>::const_iterator ConstIter;
    typedef typename std::map<IdxT,ElemT>::iterator Iter;

    std::map<IdxT,ElemT> mMap;
    DelT                 mDelete;

};

//too bad template typedefs don't exist yet
template<class IdxT, class ElemT>
class SimpleMapDelete : public SimpleMapBase<IdxT, ElemT, Deletor<ElemT> >
{
};

template<class IdxT, class ElemT>    
class SimpleMap : public SimpleMapBase<IdxT, ElemT, Nop<ElemT> >
{
public:
    SimpleMap()
    {
    }
    
    /*
    SimpleMap(bool dummyParam)
    {
        ILOG_VAR(Impala.Util.SimpleMap);
        if(dummyParam == true)
            ILOG_ERROR("wrong value: you should use SimpleMapDelete");
    }
    */
};
    
} // namespace Util
} // namespace Impala

#endif

---