CORE_Vector.hpp

Go to the documentation of this file.

#ifndef CORE_Vector_CPP
#define CORE_Vector_CPP

#include "CORE_Vector.h"
#include <algorithm>

using namespace std;


template<class T>
CORE_Vector<T>::CORE_Vector():CORE_List() { 

  mVector.resize(0); 
}

template<class T>
CORE_Vector<T>::CORE_Vector(const int& n):CORE_List() { 

  mVector.resize(n); 
}
template<class T>
CORE_Vector<T>::CORE_Vector(const CORE_Vector<T>& v):CORE_List() { 
 
  int n=v.getSize();
  mVector.resize(n);
  for (int i=0;i<n;i++) {
    mVector[i]=v[i];
  }
}



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


template<class T>
tBoolean CORE_Vector<T>::remove(const T& obj) {
  if (obj==null) return false;
  typename vector<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_Vector<T>::removeAtIndex(const int& index) {
  if (index>=size()) return false;
  if (index<0) return false;
  typename vector<T >::iterator p=mVector.begin()+index;
  mVector.erase(p);
  return true;
}

template<class T>
void CORE_Vector<T>::permute(const int& i,const int& j) {
  T temp=mVector[i];
  mVector[i]=mVector[j];
  mVector[j]=temp;
}


template<class T>
tBoolean  CORE_Vector<T>::insert(int index,const T& obj) {
  if (((int)mVector.size())==index) add(obj);
  else {
    int i=(int) index;
    if (index<0) return false;
    typename vector<T >::iterator p=mVector.begin()+i;
    if (i>size()) return false;
    mVector.insert(p,obj);
  }
  return true;
}
template<class T>
int  CORE_Vector<T>::insertInOrder(const T& obj,const tBoolean& evenIfEqual){
  int si=0;
  int sf=getSize()-1;
  if (sf<0) {
    add(obj);
    return 0;
  }
  if (obj<mVector[0]) {
    insert(0,obj);
    return 0;
  } else if (obj==mVector[0]) {
    if (evenIfEqual) return insert(0,evenIfEqual);
    else return 0;
  }
  if (obj>mVector[sf]) {
    add(obj);
    return sf+1;
  } else if (obj==mVector[sf]) {
    if (evenIfEqual) return insert(sf,evenIfEqual);
    return sf;
  };
  int i=0;
  while (sf-si>1) {
    i=(si+sf)/2;
    if (obj>mVector[i]) si=i;
    else if (obj==mVector[i]) {
      if (evenIfEqual) return insert(i,evenIfEqual);
      return i;
    }
    else sf=i;
  }
  if (obj==mVector[sf]) {
    if (evenIfEqual) return insert(sf,evenIfEqual);
    return sf;
  }
  if (obj==mVector[si]) {
    if (evenIfEqual) return insert(si,evenIfEqual);
    return si;
  }
  return insert(sf,obj);
}


template<class T>
int  CORE_Vector<T>::search(const vector<T>& values,
                            const T& obj,
                            const tString& order){
    
  int si=0;
  int sf=values.size()-1;
  if (sf<0) {
    return -1;
  }
  // min
  if (compare(obj,values[0],order))  {
      return -1;
  }

  // max
  if (compare(values[sf],obj,order)) {
      return -1;
  }
 
  //eq
  if (compare(values[0],obj,"="))  {
      return 0;
  }
  if (compare(values[sf],obj,"=")) {
      return sf;
  }
  
 
  
  int i=0;
  while (sf-si>1) {
    i=(si+sf)/2;
    if (compare(values[i],obj,"=")) {
        return i;
    } else if (compare(values[i],obj,order)) {
        si=i;
    }
    else sf=i;
  }
  if (compare(obj,values[sf],"=")) {
    return sf;
  }
  if (compare(obj,values[si],"=")) {
      return si;
  }
  return -1;
}

template<class T>
tBoolean CORE_Vector<T>::set(int index,const 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_Vector<T>::reverse() {
  int k=getSize()-1;
  int n=mVector.size();
  for (int i=0;i<n/2;i++) {
    T &temp=mVector[i];
    mVector[i]=mVector[k];
    mVector[k]=temp;
    k--;
  }
}

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

template<class T>
tBoolean CORE_Vector<T>::exists(const T& obj) const {
   typename vector<T>::const_iterator p=find(mVector.begin(),mVector.end(),obj);
  return (p!=mVector.end());
};


template<class T>
void CORE_Vector<T>::addAfterIndex(const int& index,const T& v) {
  int dim=mVector.size()+1;
  setSize(dim);
  for (int i=dim-1;i>index+1;i--) {
    mVector[i]=mVector[i-1];
  }
  if (((int)mVector.size())>index+1) 
    mVector[index+1]=v;
}

template<class T>
void CORE_Vector<T>::addAfterIndices(boost::shared_ptr<CORE_Vector<int> >& p_indices,
                                     const CORE_SharedPointersList<CORE_Vector<T> >& values) {
  if (p_indices.get()==null) return;

  CORE_Vector<int> &indices=*p_indices.get();
  
  int nIndices=indices.getSize();
  int nValues=values.getSize();
  int nValuesToAdd=0;
  for (int i=0;i<nValues;i++)
    nValuesToAdd+=values[i]->getSize();
  
  // resize the new dimension
  int dim=mVector.size()+nValuesToAdd;
  vector<T> newValues(dim);
  // set the current cursors
  int cur_newValues=dim-1;
  int cur_indices=nIndices-1;
  int cur_mVector=mVector.size()-1;

  int insertIndex=-1;
  while (cur_indices>-1) {
    insertIndex=indices[cur_indices];
    //cout << "insert index:"<< insertIndex<<"\n";
    // copy the values of mVector in newValues
    //cout << "copy the values from "<<cur_mVector<<" to "<<(insertIndex+1)<<"\n";
    for (int i=cur_mVector;i>insertIndex;i--) {
      newValues[cur_newValues]=mVector[i];
      //cout << "newValues["<<cur_newValues<<"]="<<mVector[i]<<"\n";
      cur_newValues--;
    }
    cur_mVector=insertIndex;

    // insert the new values
    //cout << "insert the new values \n";
    const CORE_Vector<T> &vals=*values.get(cur_indices);
    int nVals=vals.getSize();
    for (int i=nVals-1;i>=0;i--) {
      newValues[cur_newValues]=vals[i];
      //cout << "newValues["<<cur_newValues<<"]="<<vals[i]<<"\n";
      cur_newValues--;
    }

    // insert at new index
    cur_indices--;
  }
  
  // copy the last values
  //cout << "copy the last values from "<<cur_mVector<<" to 0 \n";
  for (int i=cur_mVector;i>=0;i--) {
    newValues[cur_newValues]=mVector[i];
    //cout << "newValues["<<cur_newValues<<"]="<<mVector[i]<<"\n";
    cur_newValues--;
  }

  // set the new dimension
  mVector.resize(dim);
  for (int i=0;i<dim;i++) mVector[i]=newValues[i];
  
}

template<class T>
void CORE_Vector<T>::sort(vector<T>& items,
                          const tString& order) {
  
  int h=1;
  int i,j;
  int N=items.size();
  T v;
  do h=3*h+1; 
  while (h<=N);
  do {
    h/=3;
    for (i=h;i<N;++i) {
      if (compare(items[i],
                  items[i-h],
                  order)) {
        v=items[i];
        j=i;
        do {
          items[j]=items[j-h];
          j=j-h;
        } 
        while ((j>=h) && (!compare(items[j-h],
                                   v,
                                   order)));
        items[j]=v;
      }
    }
  } 
  while (h>1);
  
}
#endif