CORE_SharedPointersList.hpp

Go to the documentation of this file.

#ifndef CORE_SharedPointersList_CPP
#define CORE_SharedPointersList_CPP

#include "CORE_SharedPointersList.h"

template<class T>
CORE_SharedPointersList<T>::CORE_SharedPointersList():CORE_Object() { 
  mVector.resize(0); 
}

template<class T>
template<class Q>
CORE_SharedPointersList<T>::CORE_SharedPointersList(const CORE_SharedPointersList<Q>& cpy):CORE_Object() {
    mVector.resize(0); 
    copy(cpy);
}

template<class T>
CORE_SharedPointersList<T>::~CORE_SharedPointersList() { 
  clear();
}


template<class T>
template<class Q>
void CORE_SharedPointersList<T>::copy(const CORE_SharedPointersList<Q>& cpy) {
    tVectorIndex n=cpy.getSize();
    mVector.resize(n);
    typename vector<boost::shared_ptr<T> >::iterator iVector=mVector.begin();
    typename vector<boost::shared_ptr<Q> >::const_iterator iCpy=cpy.getIterator();
    typename vector<boost::shared_ptr<Q> >::const_iterator eCpy=cpy.getEndIterator(); 
    while (iCpy!=eCpy) {
        *iVector=*iCpy;
        iCpy++;
        iVector++;
   }
}


template<class T>
tBoolean CORE_SharedPointersList<T>::exists(const T& obj) const {
    typename vector<boost::shared_ptr<T> >::const_iterator iVector=mVector.begin();
    while (iVector!=mVector.end()) {
        if ((*iVector).get()==&obj) return true;
        iVector++;
    }
    return false;
};

template<class T>
tBoolean CORE_SharedPointersList<T>::remove(const T& obj) {
    tBoolean exists=false;
    typename vector<boost::shared_ptr<T> >::iterator iVector=mVector.begin();
    while (iVector!=mVector.end()){
        if ((*iVector).get()==&obj) {
            iVector=mVector.erase(iVector);
            exists=true;
        } else {
            iVector++;
        }
    }
    return exists;
}

template<class T>
tBoolean CORE_SharedPointersList<T>::removeAtIndex(const tVectorIndex& index) {
  if (index>=size()) return false;
  if (index<0) return false;
  typename vector<boost::shared_ptr<T> >::iterator p=mVector.begin()+index;
  mVector.erase(p);
  return true;
}

template<class T>
void CORE_SharedPointersList<T>::permute(const tVectorIndex& i,const tVectorIndex& j) {
    typename vector<boost::shared_ptr<T> >::iterator pi=mVector.begin()+i;
    typename vector<boost::shared_ptr<T> >::iterator pj=mVector.begin()+j;

    boost::shared_ptr<T> temp=*pi;
    *pi=*pj;
    *pj=temp;
}


template<class T>
tBoolean  CORE_SharedPointersList<T>::insert(const tVectorIndex& index,boost::shared_ptr<T> obj) {
    if (mVector.size()==index) add(obj);
    else {
        typename vector<boost::shared_ptr<T> >::iterator p=mVector.begin()+index;
        if (index>size()) return false;
        mVector.insert(p,obj);
    }
    return true;
}

template<class T>
tBoolean CORE_SharedPointersList<T>::set(const tVectorIndex & index,boost::shared_ptr<T> obj) { 
    if (index>=size()) {
        mVector.resize(index+1);
    }
    mVector[index]=obj;
    return true;
}


template<class T>
void CORE_SharedPointersList<T>::reverse() {
    typename vector<boost::shared_ptr<T> >::iterator pE=mVector.end();
    typename vector<boost::shared_ptr<T> >::iterator pB=mVector.begin();
    tVectorIndex i,n=getSize();
    for (i=0;i<n/2;i++) {
        pE--;
        boost::shared_ptr<T> &temp=*pB;
        *pB=*pE;
        *pE=temp;
        pB++;
    }
}

template<class T>
template<class Q>
void CORE_SharedPointersList<T>::merge(const CORE_SharedPointersList<Q>& array) {
  tVectorIndex oldSize=getSize();
  tVectorIndex n=array.size();
  setSize(oldSize+n);
  typename vector<boost::shared_ptr<T> >::iterator p=mVector.begin()+oldSize;
  typename vector<boost::shared_ptr<Q> >::const_iterator q=array.getIterator();
  typename vector<boost::shared_ptr<Q> >::const_iterator eq=array.getEndIterator();
  while (q!=eq) {
      *p=*q;
      p++;
      q++;
  }
}

template<class T>
void CORE_SharedPointersList<T>::getValues(vector<T*>& vs) {
    
    tVectorIndex n=getSize();
    vs.resize(n);
    typename vector<T*>::iterator ivs=vs.begin();
    typename vector<boost::shared_ptr<T> >::iterator p=mVector.begin();
    while (p!=mVector.end()) {
        *ivs=(*p).get();
        ivs++;
        p++;
    }
}


template<class T>
void CORE_SharedPointersList<T>::getValues(vector<const T*>& vs) const {
    tVectorIndex n=getSize();
    vs.resize(n);
    typename vector<const T*>::iterator ivs=vs.begin();
    typename vector<boost::shared_ptr<T> >::const_iterator p=mVector.begin();
    while (p!=mVector.end()) {
        *ivs=(*p).get();
        ivs++;
        p++;
    }
}

  
#endif