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) {
    tUIndex 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.begin();
    typename vector<boost::shared_ptr<Q> >::const_iterator eCpy=cpy.end(); 
    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 tUIndex& index) {
  if (index>=size()) 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 tUIndex& i,const tUIndex& j) {
    typename vector<boost::shared_ptr<T> >::iterator pi=mVector.begin()+i;
    typename vector<boost::shared_ptr<T> >::iterator pj=mVector.begin()+j;
    std::swap(*pi,*pj);
}


template<class T>
tBoolean  CORE_SharedPointersList<T>::insert(const tUIndex& 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 tUIndex & 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 ei=mVector.end();
    typename vector<boost::shared_ptr<T> >::iterator bi=mVector.begin();
    while (bi<ei) {
        ei--;
        std::swap(*ei,*bi);
        bi++;
    }
    
}

template<class T>
template<class Q>
void CORE_SharedPointersList<T>::merge(const CORE_SharedPointersList<Q>& array) {
  tUIndex oldSize=getSize();
  tUIndex 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.begin();
  typename vector<boost::shared_ptr<Q> >::const_iterator eq=array.end();
  while (q!=eq) {
      *p=*q;
      p++;
      q++;
  }
}

template<class T>
void CORE_SharedPointersList<T>::getValues(vector<T*>& vs) {
    
    tUIndex 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 {
    tUIndex 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