CORE_Map.hpp

Go to the documentation of this file.

#ifndef CORE_Map_CPP
#define CORE_Map_CPP

#include "CORE_Map.h"
#include "CORE_String.h"



template<class Key,class Value>
CORE_Map<Key,Value>::CORE_Map():CORE_Object() {
}



template<class Key,class Value>
CORE_Map<Key,Value>::CORE_Map(const CORE_Map<Key,Value>& m):CORE_Object() {
    this();
   
    typename map<Key,Value>::const_iterator iter;
    typename map<Key,Value>::const_iterator em=m.end();
    for (iter=m.begin();iter!=em;iter++) {
        mMap[iter->first]=iter->second;
    }
}



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

template<class Key,class Value>
template<class K2, class V2>
void CORE_Map<Key,Value>::copy(const CORE_Map<K2,V2>& copyMap) {
    if (this==&copyMap) return;
    typename map<K2,V2>::const_iterator iter;
    typename map<K2,V2>::const_iterator em=copyMap.end();
    for (iter=copyMap.begin();iter!=em;iter++) {
        mMap[(Key)iter->first]=(Value)iter->second;
    }
}
template<class Key,class Value>
tBoolean CORE_Map<Key,Value>::exists(const Key& k) const {
    typename map<Key,Value>::const_iterator iter=mMap.find(k);
    if (iter==mMap.end()) return false;
    return true;
}

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

template<class Key,class Value>
void CORE_Map<Key,Value>::getValues(CORE_Vector<Value>& vals) const {
    tUIndex i=0,n=mMap.size();
    vals.clear();
    vals.setSize(n);
    typename map<Key,Value>::const_iterator iter=mMap.begin();
    typename map<Key,Value>::const_iterator end=mMap.end();
    while (iter!=end) {
        vals.set(i++,iter->second);
        iter++;
    }
}
template<class Key,class Value>
void CORE_Map<Key,Value>::getValues(CORE_Array<Value>& vals) const {
    tUIndex i=0,n=mMap.size();
    vals.clear();
    vals.setSize(n);
    typename map<Key,Value>::const_iterator iter=mMap.begin();
    typename map<Key,Value>::const_iterator end=mMap.end();
    while (iter!=end) {
        vals.set(i++,iter->second);
        iter++;
    }
}
template<class Key,class Value>
void CORE_Map<Key,Value>::getValues(vector<Value>& vals) const {
    tUIndex i=0,n=mMap.size();
    vals.clear();
    vals.resize(n);
    typename map<Key,Value>::const_iterator iter=mMap.begin();
    typename map<Key,Value>::const_iterator end=mMap.end();
    while (iter!=end) {
        vals[i++]=iter->second;
        iter++;
    }
}



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

template<class Key,class Value>
void CORE_Map<Key,Value>::getKeys(CORE_Vector<Key>& keys) const {
    keys.clear();
    typename map<Key,Value>::const_iterator iter=mMap.begin();
    typename map<Key,Value>::const_iterator end=mMap.end();
    while (iter!=end) {
        keys.add(iter->first);
        iter++;
    }
}
template<class Key,class Value>
void CORE_Map<Key,Value>::getKeys(CORE_Array<Key>& keys) const {
    keys.clear();
    typename map<Key,Value>::const_iterator iter=mMap.begin();
    typename map<Key,Value>::const_iterator end=mMap.end();
    while (iter!=end) {
        keys.add(iter->first);
        iter++;
    }
}
template<class Key,class Value>
void CORE_Map<Key,Value>::merge(const CORE_Map<Key,Value>& m) {
    typename map<Key,Value>::const_iterator iter=m.begin();
    typename map<Key,Value>::const_iterator end=m.end();
    while (iter!=end) {
        mMap[iter->first]=iter->second;
        iter++;
    }
}

template<class Key,class Value>
tBoolean CORE_Map<Key,Value>::remove(const Key& k) {
    typename map<Key,Value>::iterator iter=mMap.find(k);
    if (iter!=mMap.end()) {
        mMap.erase(iter);
        return true;
    };  
    return false;
};

template<class Key,class Value>
tBoolean CORE_Map<Key,Value>::removeValue(const Value& v) {
    tBoolean succeeds=false;
    typename map<Key,Value>::iterator iter=mMap.begin();
    while (iter!=mMap.end()) {
        if (iter->second==v) {
            succeeds=true;
            mMap.erase(iter);
            iter=mMap.begin();
        } else {
            iter++;
        }
    }
    return succeeds;
};

#endif