CORE_SharedPointersVMap.h

Go to the documentation of this file.

#ifndef CORE_SharedPointersVMap_H
#define CORE_SharedPointersVMap_H

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

 public:
  
  //CONSTRUCTORS
  CORE_SharedPointersVMap(); 

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

  // DESTRUCTORS
  virtual ~CORE_SharedPointersVMap(); 
  
  //OPERATORS
  inline const boost::shared_ptr<Value> operator[](const Key& k)  const {
      const boost::shared_ptr<Value> ret;
      typename map<Key,boost::shared_ptr<Value> >::const_iterator iter=mMap.find(k);
      typename map<Key,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
      if (iter!=end) return iter->second;
      return ret;
  }; 
  inline  boost::shared_ptr<Value> operator[](const Key& k)   {
      boost::shared_ptr<Value> ret;
      typename map<Key,boost::shared_ptr<Value> >::iterator iter=mMap.find(k);
      if (iter!=mMap.end()) return iter->second;
      return ret;
      
  };
    inline const Value& operator()(const Key& k)  const {
        return *(*this)[k].get();
    }; 
    inline  Value& operator()(const Key& k)   {
        return *(*this)[k].get();
    }; 
    
 
  
  // 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();};
  
  
  void getValues(CORE_Vector<Value*>& vals) const; 

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

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

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

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

  inline const Key& currentKey() const {
    return mIterator->first;
  }; 

  inline const boost::shared_ptr<Value> currentValue() const {
    return mIterator->second;
  };
  inline  boost::shared_ptr<Value> currentValue() {
    return mIterator->second;
  }; 
  
  
  // set METHODS 
  
  template<class K,class V>
    void copy(const CORE_SharedPointersVMap<K,V>& mapCpy);
  
 
  inline tBoolean put(const Key& k,const boost::shared_ptr<Value>& v) {
    mMap[k]=v;
    return true;
  }; 
  inline tBoolean put(const Key& k,Value& v) {
    boost::shared_ptr<Value> p_v;
    v.getSharedPointer(p_v);
    mMap[k]=p_v;
    return true;
  };  
  inline tBoolean put(const Key& k,Value* v) {
    boost::shared_ptr<Value> p_v;
    if (v!=null) {
      v->getSharedPointer(p_v);
      mMap[k]=p_v;
      return true;
    }
    return false;
  }; 
  
  
  
  
  
  tBoolean remove(const 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_SharedPointersVMap<K,V>& m);
  
   
  
 public:
  virtual tString toString() const;
};
#include "CORE_SharedPointersVMap.hpp"
#endif