CORE_Array.hpp

Go to the documentation of this file.

#ifndef CORE_Array_CPP
#define CORE_Array_CPP

#include <CORE_Array.h>
#include <vector>
#include "CORE_Integer.h"
#include "CORE_String.h"
#include "CORE_Vector.h"
#include "CORE_Exception.h"

using namespace std;



template<class T>
CORE_Array<T>::CORE_Array(const tArrayIndex& n):CORE_List() {  
  mStartIndex=0;
  mSize=n;
  mCapacity=n;
  mCapacityFactor=1;
  mVector=new T[mCapacity]; 
  mCVector=mVector;
  if (mVector==null)
      throw CORE_Exception("common/core",
                           "impossible to allocate memory of size "+CORE_Integer::toString(mCapacity),
                           "CORE_Array.hpp",21,"constructor(...)");
  mHasToBeDeleted=true;
 
  //cout << "create an empty array to "<<getIdentityString()<<"\n";
}
template<class T>
CORE_Array<T>::CORE_Array():CORE_List() {  
  mSize=0; 
  mStartIndex=0;
  mCapacity=10;
  mCapacityFactor=1;
  mVector=new T[mCapacity]; 
  mCVector=mVector;
  mHasToBeDeleted=true;
  if (mVector==null)
      throw CORE_Exception("common/core",
                           "impossible to allocate memory of size "+CORE_Integer::toString(mCapacity),
                           "CORE_Array.hpp",34,"constructor(...)");
 
  //cout << "create an empty array to "<<getIdentityString()<<"\n";
}
template<class T >
template<class Q>
CORE_Array<T>::CORE_Array(const std::vector<Q>&  values):CORE_List() { 
  mSize=values.size(); 
  mStartIndex=0;
  mCapacity=mSize;
  mCapacityFactor=1;
  mVector=new T[mCapacity]; 
  mCVector=mVector;
  mHasToBeDeleted=true;
  if (mVector==null) throw CORE_Exception("common/core",
                                          "impossible to allocate memory of size "+CORE_Integer::toString(mCapacity),
                                          "CORE_Array.hpp",48,"constructor(...)");
  for (tArrayIndex i=0;i<mSize;i++) mVector[i]=(T) values[i];
  //cout << "create an empty array to "<<getIdentityString()<<"\n";
}

template<class T>
CORE_Array<T>::~CORE_Array() {
  clear();
   if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector;
  
}

template<class T>
void CORE_Array<T>::copy(const CORE_Array<T>& v) {
  tArrayIndex  cap=v.getCapacity();
  tArrayIndex s=0;
  setValues(cap,v.getCompleteValues(s),0);
  mSize=v.getSize();
  mStartIndex=v.getStartIndex();
  mCapacityFactor=v.getCapacityFactor(); 
  mCVector=&mVector[mStartIndex];
}


template<class T>
void CORE_Array<T>::setCapacity(const tArrayIndex & dim) {
    if (dim>=tArrayIndexMax)
        throw CORE_Exception("common/core","CORE_Array::setCapacity","capacity too big !"+CORE_Integer::toString(dim));
    
    //capacity is ok
    if (dim==mCapacity) return;

    // create a new array
    T *newVector=new T[dim];
    if (newVector==null)
        throw CORE_Exception("common/core","impossible to allocate memory of size "+CORE_Integer::toString(dim),"CORE_Array.hpp",81,"setCapacity(cont& int&)");
    
    // copy the old value
    // last index of the usefull value
    tArrayIndex p=mSize+mStartIndex;
    tArrayIndex i,n=(p<dim)?p:dim;
    // copy all the values [0,p]
    for (i=0;i<n;i++) newVector[i]=mVector[i];

    // free memory
     if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector;

    // affect the new allocated vector
    mVector=newVector;
    mCVector=&mVector[mStartIndex];

    // set the memeory allocation of the new vector
    mCapacity=dim;
}

template<class T>
void CORE_Array<T>::resize() {
    if ((mSize==mCapacity) && (mStartIndex==0)) return;
    if (mSize>=tArrayIndexMax)throw CORE_Exception("common/core","CORE_Array::resize","capacity too big !"+CORE_Integer::toString(mSize));
    T *newVector=new T[mSize];
    if (newVector==null) throw CORE_Exception("common/core","impossible to allocate memory of size "+CORE_Integer::toString(mSize),"CORE_Array.hpp",107,"resize()");
    for (tArrayIndex i=0;i<mSize;i++) 
        newVector[i]=mCVector[i];
    if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector;
    mVector=newVector;
    mCVector=mVector;
    mCapacity=mSize;
    mStartIndex=0;
}

template<class T>
void CORE_Array<T>::resize(const tArrayIndex& n) {
  if ((n==mCapacity) && (mStartIndex==0)) {
    mSize=n;
    return;
  }
  if ((n>=tArrayIndexMax)|| (n<0)) throw CORE_Exception("common/core","CORE_Array::resize","capacity too big !"+CORE_Integer::toString(n));
  T *newVector=new T[n];
  if (newVector==null) throw CORE_Exception("common/core","impossible to allocate memory of size "+CORE_Integer::toString(n),"CORE_Array.hpp",124,"resize(const int&)");
  for (tArrayIndex i=0;i<n;i++) 
    newVector[i]=mCVector[i];
  if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector;
  mVector=newVector;
  mCVector=mVector;
  mSize=n;
  mCapacity=n;
  mStartIndex=0; 
 
}
template<class T>
void CORE_Array<T>::setSize(const tArrayIndex& n) {
    // the size is ok
    if (mSize==n) return;
    // compute the capacacity needed by the array (the size value is from the start index)
    tArrayIndex dim=mStartIndex+n;
    // set the size
    if (dim<=mCapacity) mSize=n;
    else {
        // update the capacity
        setCapacity(dim);
        // set the size
        mSize=n;
    }
}

template<class T>
void CORE_Array<T>::add(const T& obj) {
    tArrayIndex i,dim=mSize+mStartIndex;
  if (mCapacity<=dim) {
    mCapacity=mStartIndex+(mSize+1)*mCapacityFactor;
    if (mCapacity>=tArrayIndexMax)
        throw CORE_Exception("common/core",
                             "CORE_Array::resize","capacity too big !"+CORE_Integer::toString(mCapacity));
    T *newVector=new T[mCapacity];
    if (newVector==null)
        throw CORE_Exception("common/core",
                             "impossible to allocate memory of size "+CORE_Integer::toString(mCapacity),
                             "CORE_Array.hpp",157,"add(const T&)");
    
    for (i=0;i<dim;i++) newVector[i]=mVector[i];
    if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector;
    mVector=newVector;
    mCVector=&mVector[mStartIndex];
  }
  mVector[dim]=obj;
  mSize++;
}

template<class T>
void CORE_Array<T>::setValues(const tString& v,const tArrayIndex& fromIndex) {

  if ((v[0]!='[') && (v[0]!='(')) return;
  SP::CORE_String str=CORE_String::New(v.substr(1,v.length()-2));
  str->tokenize(",");
  str->begin();
  unsigned int n=str->getTokensCount();
  unsigned int newDim=n+fromIndex; 
  // verify the capacity is sufficent
  if (newDim>mCapacity) setCapacity(newDim); 

  // set the start index
  setStartIndex(fromIndex);
  
  // set the size
  setSize(n);

  T value;
  unsigned int k=0;
  while (str->hasNextToken()) {
    CORE_String::parse(str->nextToken(),value);
    mCVector[k]=value;
    k++;
  }
}
template<class T>
void CORE_Array<T>::setValues(const CORE_Array<T>& array,
                              const tArrayIndex& fromIndex) {

    // size of the array to copy
    tArrayIndex i,narray=array.getSize();
    
    // new dimension of the array
    tArrayIndex newDim=narray+fromIndex;
  
    // verify if the capacity is sufficent
    if (newDim>mCapacity) setCapacity(newDim);

    // set the start index
    setStartIndex(fromIndex);
    
    // set the size
    setSize(narray);
    
    // copy the array
    for (i=0;i<narray;i++) mCVector[i]=array[i];
}

template<class T>
void CORE_Array<T>::setValues(const tArrayIndex& n,const T* values,const tArrayIndex& fromIndex) {
    tArrayIndex i,narray=n;
    tArrayIndex newDim=narray+fromIndex;
  
  // verify the capacity is sufficent
  if (newDim>mCapacity) setCapacity(newDim);

  // set the start index
  setStartIndex(fromIndex);

  // set the size
  setSize(narray);
  
  // copy the array
  for (i=0;i<narray;i++) mCVector[i]=values[i];
}
template<class T>
void CORE_Array<T>::setValues(const vector<T>& values,const tArrayIndex& fromIndex) {
    tArrayIndex  i,narray=values.size();
    tArrayIndex newDim=narray+fromIndex;
    
    // verify the capacity is sufficent
    if (newDim>mCapacity) setCapacity(newDim);
    
    // set the start index
    setStartIndex(fromIndex);
    
    // set the size
    setSize(narray);
    
    // copy the array
    for (i=0;i<narray;i++) mCVector[i]=values[i];
}


template<class T>
tBoolean CORE_Array<T>::remove(const T& obj) {
  
  tBoolean hasExisted=false;
  tArrayIndex k=0;
  T val;
  for (tArrayIndex i=0;i<mSize;i++) {
    val=mCVector[i];
    if (val!=obj) {
      mCVector[k]=val;
      k++;
    } 
  }
  hasExisted=(mSize!=k);
  mSize=k;
  return hasExisted;
}

template<class T>
tBoolean CORE_Array<T>::removeAtIndex(const tArrayIndex& index) {
  if (index>=size()) return false;
  if (index<0) return false;
  tArrayIndex i,n=mSize;
  if (n==0) return false;
  
  for (i=index-1;i<n;i++)
    mCVector[i]=mCVector[i+1];
 
  mSize--;
  return true;
}
template<class T>
void CORE_Array<T>::contractToLastElements(const tArrayIndex& n) {
    if (n>=mSize) return;
    mCapacity=n+mStartIndex;
    if (mCapacity>=tArrayIndexMax) throw CORE_Exception("common/core","CORE_Array::contractToLastElement(const int& n)","capacity too big !"+CORE_Integer::toString(mCapacity));
    T *newVector=new T[mCapacity];
    if (newVector==null) throw CORE_Exception("common/core","impossible to allocate memory of size "+CORE_Integer::toString(mCapacity),"CORE_Array.hpp",287,"contractToLastElement(const int&)");
    
    tArrayIndex i,k=mSize-1+mStartIndex;
    for (i=mCapacity;i>0;) {
        i--;
        newVector[i]=mVector[k];
        k--;
    }
    mSize=n;
    if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector; 
    mVector=newVector;
    mCVector=&mVector[mStartIndex];
}

template<class T>
tArrayIndex CORE_Array<T>::insert(const tArrayIndex& index,const T& obj) {
    tArrayIndex i,dim=mSize+mStartIndex;
    if (dim<mCapacity) {
        for (i=mSize;i>index;i--) 
            mCVector[i]=mCVector[i-1];
        mCVector[index]=obj;
        
    } else {
        tArrayIndex i,n=index+mStartIndex;
        mCapacity+=mCapacityFactor*mSize;
        if (mCapacity>=tArrayIndexMax) throw CORE_Exception("common/core","CORE_Array::insert(const int& index,const T& obj)","capacity too big !"+CORE_Integer::toString(mCapacity));
        T *newVector=new T[mCapacity];
        if (newVector==null) throw CORE_Exception("common/core","impossible to allocate memory of size "+CORE_Integer::toString(mCapacity),"CORE_Array.hpp",312,"insert(const int&,const T&)");
        
        // copy the vector from [0,index+mStartIndex[
        for (i=0;i<n;i++) newVector[i]=mVector[i];
        // insert the obj at index
        newVector[n]=obj;
        // copy the vector from [index+mStartIndex,dim]
        for (i=n+1;i<=dim;i++)
            newVector[i]=mVector[i-1];
        if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector;
        mVector=newVector;
        mCVector=&mVector[mStartIndex];
    }
    mSize++;
    return index;
}
template<class T>
tArrayIndex CORE_Array<T>::insertInOrder(const T& obj,
                                         const tBoolean& evenIfEqual) {
    tArrayIndex si=0;
    tArrayIndex sf=mSize;
    if (sf==0) {
        add(obj);
        return 0;
    }
    
    sf--;
    
    if (obj<mCVector[0]) {
        insert(0,obj);
        return 0;
    } else if (obj==mCVector[0]) {
        if (evenIfEqual) return insert(0,obj);
        else return 0;
    }
    
    if (obj>mCVector[sf]) {
        add(obj);
        return mSize;
    } else if (obj==mCVector[sf]) {
        if (evenIfEqual) return insert(mSize-1,obj);
        return mSize-1;
    };
    
  tArrayIndex  i=0;
  while (sf-si>1) {
      i=(si+sf)/2;
      if (obj>mCVector[i]) si=i;
      else if (obj==mCVector[i]) {
          if (evenIfEqual) return insert(i,obj);
          return i;
      }
      else sf=i;
  }
  
  if (obj==mCVector[sf]) {
      if (evenIfEqual) return insert(sf,obj);
      return sf;
  }
  if (obj==mCVector[si]) {
      if (evenIfEqual) return insert(si,obj);
      return si;
  }
  return insert(sf,obj);
}


template<class T>
tBoolean CORE_Array<T>::getIndex(const T& obj,tArrayIndex& index) const {
    index=0;
    tArrayIndex si=0;
    tArrayIndex sf=mSize;
    if (sf==0) {
        return false;
    }
    sf--;
    
    if (obj<mCVector[si]) {
        return false;
    }
    if (obj>mCVector[sf]) {
        return false;
    }
    tArrayIndex i=0;
    while (sf-si>1) {
        i=(si+sf)/2;
        if (obj>mCVector[i]) si=i;
        else if (obj==mCVector[i]) {
            index=i;
            return true;
        }
        else sf=i;
    }
    if (mCVector[sf]==obj) {
        index=sf;
        return true;
    }
    if (mCVector[si]==obj) {
        index=si;
        return true;
    }
    return false;
}

template<class T>
tBoolean CORE_Array<T>::getInfIndex(const T& obj,tArrayIndex& index) const {
    index=0;
    tArrayIndex  si=0;
    tArrayIndex  sf=mSize;
    if (sf==0) {
        return false;
    }
    sf--;
    
    if (obj<mCVector[si]) {
        return false;
    } 
    if (obj==mCVector[si]) {
        return true;
    }
    if (obj>=mCVector[sf]) {
        index=sf;
        return true;
    }
    tArrayIndex k,i=0;
    while (sf-si>1) {
        i=(si+sf)/2;
        if (obj>mCVector[i]) si=i;
        else if (obj==mCVector[i]) { 
            // possibility of egality
            for (k=i;k>0;) {
                k--;
                if (obj!=mCVector[k]) {
                    index=k+1;
                    return true;
                }
            }
            index=sf;
            return true;
        }
        else sf=i;
    }
    if (mCVector[sf]==obj) {
        for (k=sf;k>0;) {
            k--;
            if (obj!=mCVector[k]) {
                index=k+1;
                return true;
            }
        }
        index=sf;
        return true;
    }
    if (mCVector[si]==obj) {
        for (k=si;k>0;) {
            k--;
            if (obj!=mCVector[k]) {
                index=k+1;
                return true;
            }
        }
        index=si;
        return true;
    }
    
    for (k=si;k>0;) {
        k--;
        if (obj!=mCVector[k]) {
            index=k+1;
            return true;
        }
    }
    index=si;
    return true;
}

template<class T>
tBoolean  CORE_Array<T>::getSupIndex(const T& obj,tArrayIndex& index) const {
    tArrayIndex k,n=mSize;
    tArrayIndex si=0;
    tArrayIndex sf=n;
    index=0;
    if (sf==0) {
        return false;
    }
    sf--;
    
    if (obj<mCVector[0]) {
        return false;
    } 
    if (obj==mCVector[0]) { 
        for (k=1;k<n;k++) {
            if (obj!=mCVector[k]) {
                index=k-1;
                return true;
            }
        }
        return true;
    }
    
    if (obj>=mCVector[sf]) {
        index=sf;
        return true;
    }
    tArrayIndex i=0;
    while (sf-si>1) {
        i=(si+sf)/2;
        if (obj>mCVector[i]) si=i;
        else if (obj==mCVector[i]) { 
            // possibility of egality 
            for (k=i+1;k<n;k++) {
                if (obj!=mCVector[k]) {
                    index=k-1;
                    return true;
                }
            }
            index=sf;
            return true;
        }
        else sf=i;
    }
    
    if (mCVector[sf]==obj) { 
        for (k=sf+1;k<n;k++) {
            if (obj!=mCVector[k]) {
                index=k-1;
                return true;
            }
        }
        index=sf;
        return true; 
    }
    if (mCVector[si]==obj) {
        for (k=si+1;k<n;k++) {
            if (obj!=mCVector[k]) {
                index=k-1;
                return true;
            }
        }
        index=si;
        return true;
    } 
    for (k=sf+1;k<n;k++) {
        if (obj!=mCVector[k]) {
            index=k-1;
            return true;
        }
    }
    index=sf;
    return true;
}

template<class T>
void CORE_Array<T>::reverse() {
  T old;
  if (mSize==0) return;
  
  tArrayIndex i,mid=mSize/2; 
  tArrayIndex j=mSize-1;
  for (i=0;i<mid;i++) {
      old=mCVector[i];
      mCVector[i]=mCVector[j];
      mCVector[j]=old;
      j--;
  }
}

template<class T>
void CORE_Array<T>::merge(const CORE_Array<T>& array) {
  // size of array to merge
  tArrayIndex n=array.getSize();

  // size of this array after merging
  tArrayIndex i,k,newSize=mSize+n;
  tArrayIndex newDim=mStartIndex+newSize;
  
  if (newDim<mCapacity) {
      tArrayIndex k=0;
      for (i=mSize;i<newSize;i++) {
          mCVector[i]=array[k];
          k++;
      }
  } else {
      // increase capacity
      mCapacity=mStartIndex+newSize*mCapacityFactor;
      if (mCapacity>=tArrayIndexMax)
          throw CORE_Exception("common/core",
                               "CORE_Array::merge(const CORE_Array<T>& obj)",
                               "capacity too big !"+CORE_Integer::toString(mCapacity));
      T *newVector=new T[mCapacity];
      if (newVector==null)
          throw CORE_Exception("common/core",
                               "impossible to allocate memory of size "+CORE_Integer::toString(mCapacity),
                               "CORE_Array.hpp",517,"merge(const CORE_Array<T>&)");
      
      // copy the this vector
      for (i=mStartIndex+mSize;i>0;) {
          i--;
          newVector[i]=mVector[i];
      }
      // add the array
      k=0;
      for (i=mStartIndex+mSize;i<newDim;i++) {
          newVector[i]=array[k];
          k++;
      }

      if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector;
      mVector=newVector;
      mCVector=&mVector[mStartIndex];
  }
  mSize=newSize;
}

template<class T>
tString CORE_Array<T>::toString() const {
  tString str("");
  tArrayIndex i,dim=mSize;
  str+="size:"+CORE_Integer::toString(mSize)+"\n";
  for (i=0;i<dim;i++) {
    str+=CORE_Integer::toString(i)+":";
    str+=CORE_String::toString(mCVector[i]);
    str+="\t";
    
      
  }
  return str;
}
template<class T>
void CORE_Array<T>::addAfterIndex(const tArrayIndex& index,const T& v) {
    tArrayIndex i,dim=mSize+1;
    setSize(dim);
    for (i=dim-1;i>index+1;i--) {
        mCVector[i]=mCVector[i-1];
    }
    mCVector[index+1]=v;
}

template<class T>
void CORE_Array<T>::addAfterIndices(const CORE_Array<tArrayIndex>& indices,
                                    CORE_SharedPointersList<CORE_Array<T> >& values) {
    
    tArrayIndex nIndices=indices.getSize();
    tArrayIndex i,nValues=values.getSize();
    tArrayIndex nValuesToAdd=0;
    for (i=0;i<nValues;i++)
        nValuesToAdd+=values[i]->getSize();
    
    // resize the new dimension
    tArrayIndex dim=mStartIndex+mSize+nValuesToAdd;
    if (dim>=tArrayIndexMax)
        throw CORE_Exception("common/core",
                             "CORE_Array::addAfterIndices(...)",
                             "capacity too big !"+CORE_Integer::toString(dim));
    T* newValues=new T[dim];
    if (newValues==null)
        throw CORE_Exception("common/core",
                             "impossible to allocate memory of size "+CORE_Integer::toString(dim),
                             "CORE_Array.hpp",571,"addAfterIndices(...)");
    // set the current cursors
    long long int cur_newValues=dim-1;
    long long int cur_indices=nIndices-1;
    long long int cur_mVector=mStartIndex+mSize-1;
    long long int j;
    long long int insertIndex=-1;
    while (cur_indices>-1) {
        insertIndex=indices[cur_indices]+mStartIndex;
        //cout << "insert index:"<< insertIndex<<"\n";
        // copy the values of mVector in newValues
        //cout << "copy the values from "<<cur_mVector<<" to "<<(insertIndex+1)<<"\n";
        for (j=cur_mVector;j>insertIndex;j--) {
            newValues[cur_newValues]=mVector[j];
            //cout << "newValues["<<cur_newValues<<"]="<<mVector[i]<<"\n";
            cur_newValues--;
        }
        cur_mVector=insertIndex;
        
        // insert the new values
        //cout << "insert the new values \n";
        CORE_Array<T> &vals=*values[cur_indices].get();
        tArrayIndex nVals=vals.getSize();
        for (j=nVals-1;j>=0;j--) {
            newValues[cur_newValues]=vals[j];
            //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 (j=cur_mVector;j>=(long long int)mStartIndex;j--) {
        newValues[cur_newValues]=mVector[j];
        //cout << "newValues["<<cur_newValues<<"]="<<mVector[i]<<"\n";
        cur_newValues--;
    }
    
    // set the new dimension
    mCapacity=dim;
    mSize=dim-mStartIndex;
    
    // free memories
    if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector;
    mVector=newValues;
    mCVector=&mVector[mStartIndex];
    
}

template<class T>
void CORE_Array<T>::sort(T*& items,const tArrayIndex& N,
                         const tString& order) {
  
  tArrayIndex h=1;
  tArrayIndex i,j;
  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); 
}

template<class T>
tBoolean CORE_Array<T>::search(const T* values,const tArrayIndex& n,
                               const T& obj,
                               const tString& order,
                               tArrayIndex& index){
    
  int si=0;
  int sf=n;
  index=0;
  if (sf==0) {
    return false;
  }
  sf--;
  
  // min
  if (compare(obj,values[0],order))  {
      return false;
  }

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

#endif

---

Generated on Mon Sep 24 2018 11:48:54 for C++ main module for mmsd Package by   1.8.8