CORE_SharedPointersVMap.hpp

Go to the documentation of this file.

#ifndef CORE_SharedPointersVMap_CPP
#define CORE_SharedPointersVMap_CPP

#include "CORE_SharedPointersVMap.h"

template<class K,class V>
CORE_SharedPointersVMap<K,V>::CORE_SharedPointersVMap():CORE_Object() { 
  
}

template<class Key,class Value>
template<class K,class V>
CORE_SharedPointersVMap<Key,Value>::CORE_SharedPointersVMap(const CORE_SharedPointersVMap<K,V>& m):CORE_Object() {
  copy(m);
}


template<class Key,class Value>
CORE_SharedPointersVMap<Key,Value>::~CORE_SharedPointersVMap() {
  clear();
}

template<class Key,class Value>
template<class K,class V>
void CORE_SharedPointersVMap<Key,Value>::copy(const CORE_SharedPointersVMap<K,V>& m) {
  clear();
  vector<K> keys;
  m.getKeys(keys);
  tUIndex i,n=keys.size();
  for (i=0;i<n;i++) 
    put((Key)keys[i],boost::dynamic_pointer_cast<Value>(m[keys[i]]));
}


template<class K,class V>
tString CORE_SharedPointersVMap<K,V>::toString() const {
  vector<K> ks;
  getKeys(ks);
  tUIndex i,n=ks.size();
  tString ret=CORE_Object::toString()+"\n";
  for (i=0;i<n;i++) {
    ret+="\t"+CORE_String::toString(ks[i])+"-->"+get(ks[i])->toString()+"\n";
  }
  return ret;
}


template<class Key,class Value>
tBoolean CORE_SharedPointersVMap<Key,Value>::exists(const Key& k) const {
  typename map<Key,boost::shared_ptr<Value> >::const_iterator iter=mMap.find(k);
   if (iter==mMap.end()) return false;
   return true;
}

template<class Key,class Value>
const Value* CORE_SharedPointersVMap<Key,Value>::get(const Key& k) const {
  typename map<Key,boost::shared_ptr<Value> >::const_iterator iter=mMap.find(k);
  if (iter==mMap.end()) return null;
  return iter->second.get();
}

template<class Key,class Value>
Value* CORE_SharedPointersVMap<Key,Value>::get(const Key& k) {
  typename map<Key,boost::shared_ptr<Value> >::iterator iter=mMap.find(k);
  if (iter==mMap.end()) return null;
  return iter->second.get();
}

template<class Key,class Value>
void CORE_SharedPointersVMap<Key,Value>::getValues(CORE_SharedPointersList<const Value>& vals) const {
  tUIndex n=mMap.size();
  vals.clear();
  vals.setSize(n);
  typename map<Key,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
  typename map<Key,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
  tUIndex i=0;
  while (iter!=end) {
    vals.set(i++,iter->second);
    iter++;
  }
}
template<class Key,class Value>
void CORE_SharedPointersVMap<Key,Value>::getValues(CORE_SharedPointersList<Value>& vals)  {
  tUIndex n=mMap.size();
  vals.clear();
  vals.setSize(n);
  typename map<Key,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
  typename map<Key,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
  tUIndex  i=0;
  while (iter!=end) {
    vals.set(i++,iter->second);
    iter++;
  }
}

template<class Key,class Value>
void CORE_SharedPointersVMap<Key,Value>::getValues(CORE_Vector<Value*>& vals) const {
  tUIndex n=mMap.size();
  vals.clear();
  vals.setSize(n);
  typename map<Key,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
  typename map<Key,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
  typename vector<Value*>::iterator iVals=vals.begin();
  while (iter!=end) {
    *iVals=iter->second.get();
    iter++;
    iVals++;
  }
}
template<class Key,class Value>
void CORE_SharedPointersVMap<Key,Value>::getValues(vector<Value*>& vals) const {
  tUIndex n=mMap.size();
  vals.clear();
  vals.resize(n);
  typename map<Key,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
  typename map<Key,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
  typename vector<Value>::iterator iVals=vals.begin();
  while (iter!=end) {
      *iVals=iter->second.get();
      iter++;
      iVals++;
  }
}



template<class Key,class Value>
void CORE_SharedPointersVMap<Key,Value>::getKeys(vector<Key>& keys) const {
    tUIndex nbKeys=mMap.size();
    keys.resize(nbKeys);
    typename map<Key,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
    typename map<Key,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
    typename vector<Key>::iterator iKeys=keys.begin();
    while (iter!=end) {
        *iKeys=iter->first;
        iter++;
        iKeys++;
    }
}


template<class Key,class Value>
void CORE_SharedPointersVMap<Key,Value>::getKeys(CORE_Vector<Key>& keys) const {
    tUIndex nbKeys=mMap.size();
    keys.setSize(nbKeys);
    typename map<Key,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
    typename map<Key,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
    typename vector<Key>::iterator iKeys=keys.begin();
    while (iter!=end) {
        *iKeys=iter->first;
        iter++;
        iKeys++;
    }
}


template<class Key,class Value>
template<class K,class V>
void CORE_SharedPointersVMap<Key,Value>::merge(const CORE_SharedPointersVMap<K,V>& m) {
    vector<K> ks;
    m.getKeys(ks);
    typename vector<K>::iterator iks=ks.begin();
    while (iks!=ks.end()) {
        put((Key)*iks,boost::dynamic_pointer_cast<Value>(m[*iks]));
        iks++;
    }
}

template<class Key,class Value>
tBoolean CORE_SharedPointersVMap<Key,Value>::remove(const Key& k) {
    typename map<Key,boost::shared_ptr<Value> >::const_iterator exists=mMap.find(k);
    if (exists!=mMap.end()) {
        mMap.erase(k);
        return true;
    };  
    return false;
};

template<class Key,class Value>
tBoolean CORE_SharedPointersVMap<Key,Value>::removeValue(const Value& v) {
  tBoolean ret=false;
  vector<Key> ks;
  getKeys(ks);
  typename vector<Key>::iterator iks=ks.begin();
  while (iks!=ks.end()) {
      if (get(*iks)==v) ret=remove(*iks);
      iks++;
  }
  return ret;
};


#endif