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) {
  int n=cpy.getSize();
  mVector.resize(n);
  for (int i=0;i<n;i++) mVector[i]=boost::dynamic_pointer_cast<T>(cpy[i]);
}

template<class T>
tBoolean CORE_SharedPointersList<T>::exists(const boost::shared_ptr<T>& obj) const {
  int n=getSize();
  for (int i=0;i<n;i++) {
    if ((*this)[i]==obj) return true;
  }
  return false;
};
template<class T>
tBoolean CORE_SharedPointersList<T>::exists(const T& obj) const {
  for (unsigned int i=0;i<mVector.size();i++)
    if (mVector[i].get()==&obj) return true;
  return false;
};
template<class T>
tBoolean CORE_SharedPointersList<T>::exists(const T* obj) const {
  for (unsigned int i=0;i<mVector.size();i++)
    if (mVector[i].get()==obj) return true;
  return false;
};


template<class T>
tBoolean CORE_SharedPointersList<T>::remove(const boost::shared_ptr<T>& obj) {
  typename vector<boost::shared_ptr<T> >::iterator p;
  tBoolean found=false;
  tBoolean exists=false;
  do {
    p=find(mVector.begin(),mVector.end(),obj);
    found=(p!=mVector.end());
    if (found) {
      exists=true;
      mVector.erase(p);
    }
  } while(found);
  return exists;
}

template<class T>
tBoolean CORE_SharedPointersList<T>::remove(const T& obj) {
  int n=(int) mVector.size();
  tBoolean exists=false;
  for (int i=n-1;i>=0;i--) {
    if (mVector[i].get()==&obj) {
      removeAtIndex(i);
      exists=true;
    }
  }
  return exists;
}
template<class T>
tBoolean CORE_SharedPointersList<T>::remove(const T* obj) {
  int n=mVector.size();
  tBoolean exists=false;
  for (int i=n-1;i>=0;i--) {
    if (mVector[i].get()==obj) {
      removeAtIndex(i);
      exists=true;
    }
  }
  return exists;
}


template<class T>
tBoolean CORE_SharedPointersList<T>::removeAtIndex(const int& 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 int& i,const int& j) {
  boost::shared_ptr<T> temp=mVector[i];
  mVector[i]=mVector[j];
  mVector[j]=temp;
}


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

template<class T>
tBoolean CORE_SharedPointersList<T>::set(const int & index,const boost::shared_ptr<T>& obj) { 
  int i=(int) index;
  int p=size();
  if (i>=p) {
    mVector.resize(i+1);
  }
  mVector[i]=obj;
  return true;
}
template<class T>
void CORE_SharedPointersList<T>::reverse() {
  int k=getSize()-1;
  int n=mVector.size();
  for (int i=0;i<n/2;i++) {
    boost::shared_ptr<T> &temp=mVector[i];
    mVector[i]=mVector[k];
    mVector[k]=temp;
    k--;
  }
}

template<class T>
template<class Q>
void CORE_SharedPointersList<T>::merge(const CORE_SharedPointersList<Q>& array) {
  int oldSize=getSize();
  int n=array.size();
  setSize(oldSize+n);
  int newSize=getSize();
  int k=0;
  for (int i=oldSize;i<newSize;i++) set(i,boost::dynamic_pointer_cast<T>(array[k++]));
}

template<class T>
void CORE_SharedPointersList<T>::getValues(vector<T*>& vs) {
  int n=getSize();
  vs.resize(n);
  for (int i=0;i<n;i++) vs[i]=get(i);
};
template<class T>
void CORE_SharedPointersList<T>::getValues(vector<const T*>& vs) const {
  int n=getSize();
  vs.resize(n);
  for (int i=0;i<n;i++) vs[i]=get(i);
};
  
#endif