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_Object(), CORE_List() { 

    mVector.resize(0); 
}

template<class T>
CORE_Vector<T>::CORE_Vector(const tUIndex& n):CORE_List() { 
    mVector.resize(n); 
}
template<class T>
CORE_Vector<T>::CORE_Vector(const CORE_Vector<T>& v):CORE_List() { 
    copy(v);
}



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


template<class T>
CORE_Vector<T>& CORE_Vector<T>::initValues(const tUIndex& from,const tString& v) {
    tUIndex l=v.length();
    if (l==0) {
        clear();
    }
    if ((v[0]!='[') && (v[0]!='(')) return *this;
    SP::CORE_String str=CORE_String::New(v.substr(1,v.length()-2));
    str->tokenize(",");
    str->begin();
    tUIndex n=str->getTokensCount();
  
    // set the size
    setSize(n+from);

    T value;
    typename vector<T>::iterator iter=mVector.begin()+from;
    while (str->hasNextToken()) {
        //parse the value
        CORE_String::parse(str->nextToken(),value);
        //set it
        *iter=value;
        //next iter
        iter++;
    }

    return *this;
}



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

template<class T>
void CORE_Vector<T>::permute(const tUIndex& i,const tUIndex& j) {
    std::swap(mVector[i],mVector[j]);
}


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

template<class T>
tUIndex  CORE_Vector<T>::insertInIncreasingOrder(const T& obj,const tBoolean& evenIfEqual){
    tUIndex si=0;
    tUIndex sf=getSize();
    if (sf==0) {
        add(obj);
        return 0;
    }
    sf--;
    
    if (obj<mVector[0]) {
        insertAtIndex(0,obj);
        return 0;
    } else if (obj==mVector[0]) {
        if (evenIfEqual)  {
            insertAtIndex(0,obj);
        }
        return 0;
    }
    if (obj>mVector[sf]) {
        add(obj);
        return sf+1;
    } else if (obj==mVector[sf]) {
        if (evenIfEqual) {
            insertAtIndex(sf,obj);
        }
        return sf;
    };
    tUIndex i=0;
    while (sf-si>1) {
        i=(si+sf)/2;
        if (obj>mVector[i]) si=i;
        else if (obj==mVector[i]) {
            if (evenIfEqual) {
                insertAtIndex(i,obj);
            }
            return i;
        }
        else sf=i;
    }
    if (obj==mVector[sf]) {
        if (evenIfEqual) insertAtIndex(sf,obj);
        return sf;
    }
    if (obj==mVector[si]) {
        if (evenIfEqual) insertAtIndex(si,obj);
        return si;
    }
    
    insertAtIndex(sf,obj);
    return sf;
}


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

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

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

template<class T>
void CORE_Vector<T>::append(const CORE_Vector<T>& array) {
    tUIndex oldSize=getSize();
    tUIndex n=array.getSize();
    setSize(oldSize+n);
    typename vector<T>::iterator it=mVector.begin()+oldSize;
    typename vector<T>::iterator ia=array.begin();
    while (it!=mVector.end()) {
        *it=*ia;
        it++;
        ia++;
    }
}

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 tUIndex& index,const T& v) {
    tUIndex i,dim=mVector.size()+1;
    setSize(dim);
    typename vector<T>::iterator it=mVector.end();
    it--;
    for (i=dim-1;i>index+1;i--) {
        *it=*(it-1);
        it--;
    }
    //i=index+1
    if (mVector.size()>index+1)  *it=v;
}

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

    CORE_Vector<tUIndex> &indices=*p_indices.get();
  
    tUIndex nIndices=indices.getSize();
    tUIndex i,nValues=values.getSize();
    tUIndex nValuesToAdd=0;

    //compute the number of values to add
    for (i=0;i<nValues;i++)
        nValuesToAdd+=values[i]->getSize();
    if (nValuesToAdd==0) return;
                             
    // resize the new dimension
    tUIndex dim=mVector.size()+nValuesToAdd;
    vector<T> newValues(dim);
    
    // set the current cursors
    tIndex cur_newValues=dim-1;
    tIndex cur_indices=nIndices-1;
    tIndex cur_mVector=mVector.size()-1;

    tUIndex insertIndex=getMaxUIndex();
    while (cur_indices>=0) {
        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 (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);
        tUIndex nVals=vals.getSize();
        i=nVals;
        while (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";
    i=cur_mVector+1;
    while (i>0) {
        i--;
        newValues[cur_newValues]=mVector[i];
        //cout << "newValues["<<cur_newValues<<"]="<<mVector[i]<<"\n";
        cur_newValues--;
    }
    
    // set the new dimension
    copy(newValues);
  
}

template<class T>
void CORE_Vector<T>::sort(vector<T>& items,
                          const tFlag& order) {
  
    tUIndex h=1;
    tUIndex i,j;
    tUIndex 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