CORE_SharedPointersKVMap.h

Go to the documentation of this file.

#ifndef CORE_SharedPointersKVMap_H
#define CORE_SharedPointersKVMap_H

#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"
#include "CORE_Object.h"
#include "CORE_Pointers.h"
#include "CORE_SharedPointersList.h"
#include "CORE_Map.h"
template <class Key,class Value>
  class CORE_SharedPointersKVMap : public CORE_Object {
  //ATTRIBUTES
    map<boost::shared_ptr<Key>,boost::shared_ptr<Value> > mMap; 
    typename map<boost::shared_ptr<Key>,boost::shared_ptr<Value> >::iterator mIterator;
    //ASSOCIATION

 public:
  
  //CONSTRUCTORS
  CORE_SharedPointersKVMap(); 

  template <class K,class Q>
    CORE_SharedPointersKVMap(const CORE_SharedPointersKVMap<K,Q>& m);

  // DESTRUCTORS
  virtual ~CORE_SharedPointersKVMap(); 
  
  //OPERATORS
  inline const boost::shared_ptr<Value>& operator[](const boost::shared_ptr<Key>& k)  const {
    ASSERT_IN(exists(k));
    return mMap.find(k)->second;
  }; 
  inline  boost::shared_ptr<Value>& operator[](const boost::shared_ptr<Key>& k)   {
    ASSERT_IN(exists(k));
    return mMap.find(k)->second;
  }; 
  
 
  
  // get METHODS
  
  tBoolean exists(const boost::shared_ptr<Key>& k) const;
  
  const Value* get(const boost::shared_ptr<Key>& k) const;

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

  inline void values(CORE_Vector<Value*>& vals) const {
    getValues(vals);
  };
  
  void getValues(CORE_Vector<Value*>& vals) const; 
  void getValues(vector<Value*>& vals) const;  

  void getValues(CORE_SharedPointersList<Value>& vals) const; 


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

  void getKeys(CORE_SharedPointersList<Key>& ks) const;
  
  void getKeys(vector<Key*>& ks) const; 
  
  void getKeys(CORE_Vector<Key*>& ks) const;
 
  inline void begin()  {
    mIterator=mMap.begin();
  } 
  inline tBoolean hasNext()  const {
    return (mIterator!=mMap.end());
  }; 
 
  inline void next(Key*& k,Value*& v)  { 
    v=mIterator->second.get();
    k=mIterator->first.get();
    mIterator++;
  }; 
  
  
    // set METHODS 

  template<class K,class V>
    void copy(const CORE_SharedPointersKVMap<K,V>& mapCpy);
  
  inline void put(const boost::shared_ptr<const Key>& k,
                  const boost::shared_ptr<const Value>& v) {
    mMap[k]=v;
  }; 
  inline void put(const boost::shared_ptr<Key>& k,const boost::shared_ptr<Value>& v) {
    mMap[k]=v;
  };
  
  
  
  
  tBoolean remove(const boost::shared_ptr<Key>& k); 
  
  tBoolean removeValue(const Value* k);  

  tBoolean removeValue(const Value& k); 

  tBoolean removeValue(boost::shared_ptr<Value>& k); 

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

   
    
   

  
  template <class K,class V>
    void merge(const CORE_SharedPointersKVMap<K,V>& m);
  
   
  
 public:
  virtual tString toString() const;
};
#include "CORE_SharedPointersKVMap.hpp"
#endif