CORE_Map.h

Go to the documentation of this file.

#ifndef CORE_Map_H
#define CORE_Map_H

#include "CORE_Object.h"
#include <vector>
#include "CORE_Vector.h"
#include "CORE_Array.h"

using namespace std;
template <class Key,class Value>

  class CORE_Map :public CORE_Object {
    
    
 private:
    
    map<Key,Value> mMap;  
    typename map<Key,Value>::iterator mIterator;

    
   
 public:
    
    // CONSTRUCTORS
    
    
    CORE_Map();

    CORE_Map(const CORE_Map<Key,Value>& m);
   
    
    // DESTRUCTORS
    virtual ~CORE_Map(); 

   

 public:  
    
    // OPERATORS
public:
    void getSharedPointer(boost::shared_ptr<CORE_Map<Key,Value> >& p){
        SP::CORE_Object r;
        CORE_Object::getSharedPointer(r);
        p=boost::dynamic_pointer_cast<CORE_Map<Key,Value> >(r); 
    };
    void getSharedPointer( boost::shared_ptr<const CORE_Map<Key,Value> >& p) const{             
        SPC::CORE_Object r;
        CORE_Object::getSharedPointer(r);               
        p=boost::dynamic_pointer_cast<const CORE_Map<Key,Value> >(r);                           
    }; 
private:
    inline boost::shared_ptr<CORE_Map<Key,Value> > getThis() {
        boost::shared_ptr<CORE_Map<Key,Value> > p;
        getSharedPointer(p);
        return p;                               
    }; 
    inline  boost::shared_ptr<const CORE_Map<Key,Value> > getThis() const {                                     
        boost::shared_ptr<const CORE_Map<Key,Value> > p;
        getSharedPointer(p);
        return p;       
    };

public:
    static inline boost::shared_ptr<CORE_Map<Key,Value> > New() {
        boost::shared_ptr<CORE_Map<Key,Value> > p(new CORE_Map<Key,Value>(),
                                                  CORE_Object::Delete());
        p->setThis(p);
        return p;
    };  
    
public:
    inline const Value& operator[](const Key& k)  const {
      ASSERT_IN(exists(k));
      return mMap.find(k)->second;
    }; 
 
    inline Value& operator[](const Key& k)   { 
      ASSERT_IN(exists(k));
      return mMap.find(k)->second;
    };

    // get METHODS

    tBoolean exists(const Key& k) const;

    const Value* get(const Key& k) const;

    Value* get(const Key& k);
    
    inline int size() const{return (int) mMap.size();}; 
    
    inline int getSize() const{return (int) mMap.size();};
    inline void values(CORE_Vector<Value>& vals) const {
      getValues(vals);
    };

    void getValues(CORE_Vector<Value>& vals) const; 
    void getValues(CORE_Array<Value>& vals) const;
    void getValues(vector<Value>& vals) const;

    inline void keys(CORE_Vector<Key>& ks) const {
      getKeys(ks);
    };

    void getKeys(vector<Key>& ks) const; 

    void getKeys(CORE_Vector<Key>& ks) const;
    void getKeys(CORE_Array<Key>& ks) const;

    // set METHODS 

    template<class K2,class V2>
      void copy(const CORE_Map<K2,V2>& mapCpy);

    inline void put(const Key& k,const Value& v) {
      mMap[k]=v;
    };
    inline void add(const Value& v) {
      mMap[(Key)v]=v;
    };



    tBoolean remove(const Key& k); 

    tBoolean removeValue(const Value& k); 

   

    inline void clear() {
      mMap.clear();
    };

   
   
    inline void begin()  {
     mIterator=mMap.begin();
    }
   
    inline tBoolean hasNext()  const{
       return (mIterator!=mMap.end());
    }; 
   
    inline void next(Key& k,Value*& v)  { 
      v=&(mIterator->second);
      k=mIterator->first;
      mIterator++;
    }; 
   
    
    
   

   
    void merge(const CORE_Map<Key,Value>& m);
    
   

    // other METHODS
  
    
  };

#include "CORE_Map.hpp"

typedef CORE_Map<tString,tReal> CORE_StringRealMap;
typedef CORE_Map<tString,int> CORE_StringIntMap;
TYPEDEF_SPTR(CORE_StringRealMap);
TYPEDEF_SPTR(CORE_StringIntMap);


#endif