CORE_SharedPointersListVMap.hpp

Go to the documentation of this file.

#ifndef CORE_SharedPointersListVMap_CPP
#define CORE_SharedPointersListVMap_CPP

#include "CORE_SharedPointersListVMap.h"

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

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


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

template<class Key,class Value>
template<class K,class V>
void CORE_SharedPointersListVMap<Key,Value>::copy(const CORE_SharedPointersListVMap<K,V>& m) {
  clear();
  vector<K> keys;
  m.getKeys(keys);
  int n=keys.size();
  for (int i=0;i<n;i++) {
    boost::shared_ptr<CORE_SharedPointersList<Value> > &listAtK=m[keys[i]];
    boost::shared_ptr<CORE_SharedPointersList<Value> > copyList=CORE_SharedPointersList<Value>::New();
    copyList.copy(listAtK);
    put((Key)keys[i],copyList);
  }
}


template<class Key,class Value>
tString CORE_SharedPointersListVMap<Key,Value>::toString() const {
  vector<Key> ks;
  getKeys(ks);
  int n=ks.size();
  tString ret=CORE_Object::toString()+"\n";
  tString strK;
  for (int i=0;i<n;i++) {
    const CORE_SharedPointersList<Value>& listAtK=*get(ks[i]);
    int p=listAtK.getSize();
    strK=CORE_String::toString(ks[i]);
    for (int j=0;j<p;j++) {
      ret+="\t"+strK+"["+CORE_Integer::toString(j)+"]="+listAtK[j]->toString()+"\n";
    }
  }
  return ret;
}


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

template<class Key,class Value>
void CORE_SharedPointersListVMap<Key,Value>::clear(const Key& k) {
 
  typename map<Key,boost::shared_ptr<CORE_SharedPointersList<Value> > >::iterator iter=mMap.find(k);
  if (iter!=mMap.end()) {
    boost::shared_ptr<CORE_SharedPointersList<Value> > &listAtK=iter->second;
    listAtK->clear();
  }
};  
template<class Key,class Value>
tBoolean CORE_SharedPointersListVMap<Key,Value>::put(const Key& k,boost::shared_ptr<Value> v,const tBoolean& ifNotExists) {
  typename map<Key,boost::shared_ptr<CORE_SharedPointersList<Value> > >::iterator iter=mMap.find(k);
  if (iter==mMap.end()) {
    boost::shared_ptr<CORE_SharedPointersList<Value> > listAtK=CORE_SharedPointersList<Value>::New();
    mMap[k]=listAtK;
    listAtK->add(v);
  } else {
    boost::shared_ptr<CORE_SharedPointersList<Value> > &listAtK=iter->second;
    if (ifNotExists) {
      if (!listAtK->exists(v)) listAtK->add(v);
    } else listAtK->add(v);
  }
  return true;
};  

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

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




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

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

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

template<class Key,class Value>
tBoolean CORE_SharedPointersListVMap<Key,Value>::removeValue(const Value& v) {
  tBoolean ret=false;
  vector<Key> ks;
  getKeys(ks);
  int n=ks.size();
  for (int i=0;i<n;i++) {
    if ((*this)[ks[i]]->exists(v)) ret=remove(ks[i]);
  }
  return ret;
};

template<class Key,class Value>
tBoolean CORE_SharedPointersListVMap<Key,Value>::removeValue(const Value* v) {
  tBoolean ret=false;
  vector<Key> ks;
  getKeys(ks);
  int n=ks.size();
  for (int i=0;i<n;i++) { 
    if ((*this)[ks[i]]->exists(v)) ret=remove(ks[i]);
  }
  return ret;
};


#endif