CORE_WeakPointersList.hpp

Go to the documentation of this file.

#ifndef CORE_WeakPointersList_CPP
#define CORE_WeakPointersList_CPP

#include "CORE_WeakPointersList.h"

template<class T>
CORE_WeakPointersList<T>::CORE_WeakPointersList(): CORE_Object(){ 

  mVector.resize(0); 
}

template<class T> 
template<class Q>
CORE_WeakPointersList<T>::CORE_WeakPointersList(const CORE_WeakPointersList<Q>& cpy) : CORE_Object(){ 

  copy(cpy);
}
template<class T>
CORE_WeakPointersList<T>::~CORE_WeakPointersList() { 
  clear();
}


template<class T>
template<class Q>
void CORE_WeakPointersList<T>::copy(const CORE_WeakPointersList<Q>& cpy) {
    typename vector<boost::weak_ptr<T> >::iterator iVector=mVector.begin();
    typename vector<boost::weak_ptr<Q> >::const_iterator iCpy=cpy.begin();
    typename vector<boost::weak_ptr<Q> >::const_iterator eCpy=cpy.end();
    while (iCpy!=eCpy) {
        *iVector==boost::dynamic_pointer_cast<T>(*iCpy);
        iCpy++;
        iVector++;
    }
}

template<class T>
template<class Q>
void CORE_WeakPointersList<T>::copy(const CORE_SharedPointersList<Q>& cpy) {
    typename vector<boost::weak_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==boost::dynamic_pointer_cast<T>(*iCpy);
        iCpy++;
        iVector++;
    }
}

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



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

}

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

template<class T>
void CORE_WeakPointersList<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_WeakPointersList<T>::insert(const tUIndex& index,const boost::shared_ptr<T>& obj) {
    if (mVector.size()==index) add(obj);
    else {
        typename vector<boost::weak_ptr<T> >::iterator p=mVector.begin()+index;
        if (index>size()) return false;
        boost::weak_ptr<T> wobj=obj;
        mVector.insert(p,wobj);
        
        return true;
    }
}


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

template<class T>
void CORE_WeakPointersList<T>::reverse() {
    typename vector<boost::weak_ptr<T> >::iterator ei=mVector.end();
    typename vector<boost::weak_ptr<T> >::iterator bi=mVector.begin();
    while (bi<ei) {
        ei--;
        std::swap(*ei,*bi);
        bi++;
    }
}

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

  
#endif