CORE_SharedPointersKVMap.hpp

Go to the documentation of this file.

#ifndef CORE_SharedPointersKVMap_CPP
#define CORE_SharedPointersKVMap_CPP

#include "CORE_SharedPointersKVMap.h"

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

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


template<class Key,class Value>
template<class K,class V>
void CORE_SharedPointersKVMap<Key,Value>::copy(const CORE_SharedPointersKVMap<K,V>& m) {
  clear();
  vector<boost::shared_ptr<K> > keys;
  m.getKeys(keys);
  typename vector<boost::shared_ptr<K> >::iterator iKeys=keys.begin();
  while (iKeys!=keys.end()) { 
      put(boost::dynamic_pointer_cast<Key>(*iKeys),boost::dynamic_pointer_cast<Value> (m[*iKeys]));
      iKeys++;
  }
}



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




template<class Key,class Value>
tBoolean CORE_SharedPointersKVMap<Key,Value>::exists(const boost::shared_ptr<Key>& k) const {
  typename map<boost::shared_ptr<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_SharedPointersKVMap<Key,Value>::get(const boost::shared_ptr<Key>& k) const {
  typename map<boost::shared_ptr<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_SharedPointersKVMap<Key,Value>::get(const boost::shared_ptr<Key>& k) {
  typename map<boost::shared_ptr<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_SharedPointersKVMap<Key,Value>::getValues(CORE_SharedPointersList<Value>& vals) const {
  tUIndex n=mMap.size();
  vals.clear();
  vals.setSize(n);
  typename map<boost::shared_ptr<Key>,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
  typename map<boost::shared_ptr<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_SharedPointersKVMap<Key,Value>::getValues(CORE_Vector<Value*>& vals) const {
  tUIndex n=mMap.size();
  vals.clear();
  vals.setSize(n);
  typename map<boost::shared_ptr<Key>,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
  typename map<boost::shared_ptr<Key>,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
  tUIndex i=0;
  while (iter!=end) {
    vals[i++]=iter->second.get();
    iter++;
  }
}
template<class Key,class Value>
void CORE_SharedPointersKVMap<Key,Value>::getValues(vector<Value*>& vals) const {
  tUIndex n=mMap.size();
  vals.clear();
  vals.resize(n);
  typename map<boost::shared_ptr<Key>,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
  typename map<boost::shared_ptr<Key>,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
  tUIndex i=0;
  while (iter!=end) {
    vals[i++]=iter->second.get();
    iter++;
  }
}



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

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


template<class Key,class Value>
void CORE_SharedPointersKVMap<Key,Value>::getKeys(CORE_SharedPointersList<Key>& keys) const {
  keys.clear();
  typename map<boost::shared_ptr<Key>,boost::shared_ptr<Value> >::const_iterator iter=mMap.begin();
  typename map<boost::shared_ptr<Key>,boost::shared_ptr<Value> >::const_iterator end=mMap.end();
  tUIndex i=0;
  while (iter!=end) {
      keys.add(iter->first);
      iter++;
      i++;
  }
}

template<class Key,class Value>
template<class K,class V>
void CORE_SharedPointersKVMap<Key,Value>::merge(const CORE_SharedPointersKVMap<K,V>& m) {
  CORE_SharedPointersList<K> ks;
  m.getKeys(ks);
  tUIndex i,nbKeys=ks.size();
  for (i=0;i<nbKeys;i++) {
    put(boost::dynamic_pointer_cast<Key>(ks[i]),boost::dynamic_pointer_cast<Value>(m[ks[i]]));
  }
}

template<class Key,class Value>
tBoolean CORE_SharedPointersKVMap<Key,Value>::remove(const boost::shared_ptr<Key>& k) {
  typename map<boost::shared_ptr<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_SharedPointersKVMap<Key,Value>::removeValue(boost::shared_ptr<Value>& v) {
  tBoolean ret=false;
  CORE_SharedPointersList<Key> ks;
  getKeys(ks);
  tUIndex n=ks.size();
  for (tUIndex i=0;i<n;i++) {
      if ((*this)[ks[i]]==v) ret=remove(ks[i]);
  }
  return ret;
};

template<class Key,class Value>
tBoolean CORE_SharedPointersKVMap<Key,Value>::removeValue(const Value& v) {
  tBoolean ret=false;
  CORE_SharedPointersList<Key> ks;
  getKeys(ks);
  tUIndex n=ks.size();
  for (tUIndex i=0;i<n;i++) {
    if (get(ks[i])==v) ret=remove(ks[i]);
  }
  return ret;
};
template<class Key,class Value>
tBoolean CORE_SharedPointersKVMap<Key,Value>::removeValue(const Value* v) {
    tBoolean ret=false;
    CORE_SharedPointersList<Key> ks;
    getKeys(ks);
    tUIndex i,n=ks.size();
    for (i=0;i<n;i++) {
        if (get(ks[i])==v) ret=remove(ks[i]);
    }
    return ret;
};

#endif