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 int& 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 (int 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) {
  int cap=v.getCapacity();
  int 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 int& dim) {
    if ((dim>=INT_MAX)||(dim<0))
        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
    int p=mSize+mStartIndex;
    int n=(p<dim)?p:dim;
    // copy all the values [0,p]
    for (int 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>=INT_MAX) || (mSize<0))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 (int 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 int& n) {
  if ((n==mCapacity) && (mStartIndex==0)) {
    mSize=n;
    return;
  }
  if ((n>=INT_MAX)|| (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 (int 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 int& n) {
    // the size is ok
    if (mSize==n) return;
    // compute the capacacity needed by the array (the size value is from the start index)
    int 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) {
  int dim=mSize+mStartIndex;
  if (mCapacity<=dim) {
    mCapacity=mStartIndex+(mSize+1)*mCapacityFactor;
    if ((mCapacity>=INT_MAX)|| (mCapacity<0)) 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 (int 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 int& fromIndex) {

  if ((v[0]!='[') && (v[0]!='(')) return;
  SP::CORE_String str=CORE_String::New(v.substr(1,v.length()-2));
  str->tokenize(",");
  str->begin();
  int n=str->getTokensCount();
  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;
  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 int& fromIndex) {

    // size of the array to copy
    int narray=array.getSize();
    
    // new dimension of the array
    int 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 (int i=0;i<narray;i++) mCVector[i]=array[i];
}

template<class T>
void CORE_Array<T>::setValues(const int& n,const T* values,const int& fromIndex) {
  int narray=n;
  int 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 (int i=0;i<narray;i++) mCVector[i]=values[i];
}
template<class T>
void CORE_Array<T>::setValues(const vector<T>& values,const int& fromIndex) {
  int narray=values.size();
  int 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 (int i=0;i<narray;i++) mCVector[i]=values[i];
}


template<class T>
tBoolean CORE_Array<T>::remove(const T& obj) {
  
  tBoolean hasExisted=false;
  int k=0;
  T val;
  for (int 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 int& index) {
  if (index>=size()) return false;
  if (index<0) return false;
  int n=mSize-1;
  for (int i=index;i<n;i++)
    mCVector[i]=mCVector[i+1];
 
  mSize--;
  return true;
}
template<class T>
void CORE_Array<T>::contractToLastElements(const int& n) {
  if (n>=mSize) return;
  mCapacity=n+mStartIndex;
  if ((mCapacity>=INT_MAX) || (mCapacity<0)) 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&)");
 
  int k=mSize-1+mStartIndex;
  for (int i=mCapacity-1;i>=0;i--) {
    newVector[i]=mVector[k];
    k--;
  }
   mSize=n;
    if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector; 
   mVector=newVector;
   mCVector=&mVector[mStartIndex];
}

template<class T>
int CORE_Array<T>::insert(const int& index,const T& obj) {
  int dim=mSize+mStartIndex;
  if (dim<mCapacity) {
    for (int i=mSize;i>index;i--) 
      mCVector[i]=mCVector[i-1];
    mCVector[index]=obj;

  } else {
    int n=index+mStartIndex;
    mCapacity+=mCapacityFactor*mSize;
    if ((mCapacity>=INT_MAX)|| (mCapacity<0)) 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 (int 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 (int 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>
int CORE_Array<T>::insertInOrder(const T& obj,
                                 const tBoolean& evenIfEqual) {
  int si=0;
  int sf=mSize-1;
  if (sf<0) {
    add(obj);
    return 0;
  }
  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;
  };
  int 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>
int CORE_Array<T>::getIndex(const T& obj) const {
  int si=0;
  int sf=mSize-1;
  if (sf<0) {
    return -1;
  }
  if (obj<mCVector[si]) {
    return -1;
  }
  if (obj>mCVector[sf]) {
    return -1;
  }
  int i=0;
  while (sf-si>1) {
    i=(si+sf)/2;
    if (obj>mCVector[i]) si=i;
    else if (obj==mCVector[i]) return i;
    else sf=i;
  }
  if (mCVector[sf]==obj) return sf;
  if (mCVector[si]==obj) return si;
  return -1;
}
template<class T>
int CORE_Array<T>::getInfIndex(const T& obj) const {
  int si=0;
  int sf=mSize-1;
  if (sf<0) {
    return -1;
  }
  if (obj<mCVector[si]) {
    return -1;
  } 
  if (obj==mCVector[si]) {
    return 0;
  }
  if (obj>=mCVector[sf]) {
    return sf;
  }
  int 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 (int k=i-1;k>=0;k--)
        if (obj!=mCVector[k]) return k+1;
      return sf;
    }
    else sf=i;
  }
  if (mCVector[sf]==obj) {
    for (int k=sf-1;k>=0;k--)
       if (obj!=mCVector[k]) return k+1;
    return sf; 
  }
  if (mCVector[si]==obj) {
    for (int k=si-1;k>=0;k--)
       if (obj!=mCVector[k]) return k+1;
    return si;
  }
  for (int k=si-1;k>=0;k--)
    if (obj!=mCVector[k]) return k+1;
  return si;
}

template<class T>
int CORE_Array<T>::getSupIndex(const T& obj) const {
  int n=mSize;
  int si=0;
  int sf=n-1;
  if (sf<0) {
    return -1;
  }
  if (obj<mCVector[0]) {
    return -1;
  } 
  if (obj==mCVector[0]) { 
    for (int k=1;k<n;k++)
        if (obj!=mCVector[k]) return k-1;
    return 0;
  }
  if (obj>=mCVector[sf]) {
    return sf;
  }
  int 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 (int k=i+1;k<n;k++)
        if (obj!=mCVector[k]) return k-1;
      
      return sf;
    }
    else sf=i;
  }
  if (mCVector[sf]==obj) { 
    for (int k=sf+1;k<n;k++)
        if (obj!=mCVector[k]) return k-1;
    return sf; 
  }
  if (mCVector[si]==obj) {
    for (int k=si+1;k<n;k++)
      if (obj!=mCVector[k]) return k-1;
    return si;
  } 
  for (int k=sf+1;k<n;k++)
        if (obj!=mCVector[k]) return k-1;
  return sf;
}

template<class T>
void CORE_Array<T>::reverse() {
  T old;
  int mid=mSize/2; 
  int j=mSize-1;
  for (int 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
  int n=array.getSize();

  // size of this array after merging
  int newSize=mSize+n;
  int newDim=mStartIndex+newSize;
  
  if (newDim<mCapacity) {
    int k=0;
    for (int i=mSize;i<newSize;i++) {
      mCVector[i]=array[k];
      k++;
    }
  } else {
    // increase capacity
    mCapacity=mStartIndex+newSize*mCapacityFactor;
    if ((mCapacity>=INT_MAX)|| (mCapacity<0)) 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 (int i=mStartIndex+mSize-1;i>=0;i--) newVector[i]=mVector[i];
    // add the array
    int k=0;
    for (int 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("");
  int dim=mSize;
  str+="size:"+CORE_Integer::toString(mSize)+"\n";
  for (int 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 int& index,const T& v) {
  int dim=mSize+1;
  setSize(dim);
  for (int 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<int>& indices,
                                    CORE_SharedPointersList<CORE_Array<T> >& values) {

  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=mStartIndex+mSize+nValuesToAdd;
  if ((dim>=INT_MAX)|| (dim<0)) 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
  int cur_newValues=dim-1;
  int cur_indices=nIndices-1;
  int cur_mVector=mStartIndex+mSize-1;

  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 (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";
    CORE_Array<T> &vals=*values[cur_indices].get();
    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>=mStartIndex;i--) {
    newValues[cur_newValues]=mVector[i];
    //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 int& N,
                         const tString& order) {
  
  int h=1;
  int 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>
int  CORE_Array<T>::search(const T* values,const int& n,
                           const T& obj,
                           const tString& order){
    
  int si=0;
  int sf=n-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;
}
#endif

---

Generated on Thu May 24 2018 16:20:00 for C++ main module for gpm Package by   1.8.8