CORE_Array2D.hpp

Go to the documentation of this file.

#ifndef CORE_Array2D_HPP
#define CORE_Array2D_HPP

#include "CORE_Array2D.h"
#include "CORE_Integer.h"
#include "CORE_String.h"

template<class T>
CORE_Array2D<T>::CORE_Array2D():CORE_List() { 
    mRowsNumber=0;
    mRowsCapacity=2;
    mCapacity=1;
    mCapacityFactor=1;

    mVector=new T[mCapacity];
    mRowIndices=new int[mRowsCapacity];
    mRowIndices[0]=0;
    mRowIndices[1]=0;
    mVector[0]=0;

    mHasToBeDeleted=true;
 
  
  
}

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

template<class T>
void CORE_Array2D<T>::setCapacity(const int& n,const int& p) {

    
    if (mCapacity<n*p) {
        // resize the array
        int size=n*p*mCapacityFactor;
        T *newVector=new T[size];
        // copy the values
        for (int i=0;i<mCapacity;i++) {
            newVector[i]=mVector[i];
        }
        for (int i=mCapacity;i<size;i++) {
            newVector[i]=0;
        }
        if (mHasToBeDeleted && (mVector!=null) ) delete[] mVector;
        mVector=newVector;
        mCapacity=size;
       
    }
    
    //copy the row
    if (n>mRowsCapacity) {
        int size=getValuesNumber();
        mRowsCapacity=n*mCapacityFactor+1;
        int *rows=new int[mRowsCapacity];
        for (int i=0;i<=mRowsNumber;i++) {
            rows[i]=mRowIndices[i];
        }
        for (int i=mRowsNumber+1;i<mRowsCapacity;i++) {
            rows[i]=size;
        }
    
       
        if (mHasToBeDeleted && (mRowIndices!=null)) delete[] mRowIndices;
        mRowIndices=rows;
       
    }
    mHasToBeDeleted=true;
}

template<class T>
void CORE_Array2D<T>::setSize(const int& n,const int& p) {
    setCapacity(n,p);
    // set the row
    int r=0;
    int *rowIndices=mRowIndices;
    for (int i=0;i<n-1;i++) {
        *rowIndices=r;
        r+=p;
        rowIndices++;
    }
    // last size
    *rowIndices=r;
    mRowsNumber=n;
}

template<class T>
void CORE_Array2D<T>::resize() {
    if (mRowIndices[mRowsNumber]<mCapacity) {
        // set vector capacity
        mCapacity=mRowIndices[mRowsNumber];
        T *newVector=new T[mCapacity];
        for (int i=0;i<mCapacity;i++) {
            newVector[i]=mVector[i];
        }
        if (mHasToBeDeleted && (mVector!=null) ) delete[] mVector;
        mVector=newVector;
    }
    if (mRowsCapacity>mRowsNumber+1) {
        mRowsCapacity=mRowsNumber+1;
        int *newIndices=new int[mRowsCapacity];
        for (int i=0;i<=mRowsNumber;i++) {
            newIndices[i]=mRowIndices[i];
        }
        if (mHasToBeDeleted) delete [] mRowIndices;
        mRowIndices=newIndices;
    }
    mHasToBeDeleted=true;

}
template<class T>
void CORE_Array2D<T>::copy(const CORE_Array2D<T>& src) {
    if (this==&src) return;
    mCapacityFactor=src.getCapacityFactor();
    
    int nValues=src.getValuesNumber();

    mCapacity=nValues;
    if (mCapacity==0) mCapacity=1;
    
    if (mHasToBeDeleted) {
        if (mVector!=null) delete[] mVector;
        if (mRowIndices!=null) delete[] mRowIndices;
    }
    
    mRowsNumber=src.getRowsNumber();
    mRowsCapacity=mRowsNumber+1;
    mRowIndices=new int[mRowsCapacity];
    mVector=new T[mCapacity];
    T *curV=mVector;
    if (nValues>0) {
        const T *srcV=src[0];
        for (int i=0;i<mCapacity-1;i++) {
            *curV=*srcV;
            curV++;
            srcV++;
        }
        *curV=*srcV;
    } else {
        mVector[0]=0;
    }
    int *curR=mRowIndices;
    const int *inds=src.getRowIndices();
    for (int i=0;i<mRowsCapacity-1;i++) {
        *curR=*inds;
        inds++;
        curR++;
    }
    *curR=*inds;
    mHasToBeDeleted=true;
}


template<class T>
tString CORE_Array2D<T>::toString() const {
    tString str("");
    int n=getValuesNumber();
    int nRows=getRowsNumber();
    str+="size:"+CORE_Integer::toString(n)+"\n";
    str+="capacityFactor:"+CORE_Integer::toString(mCapacityFactor)+"\n";
    str+="capacity:"+CORE_Integer::toString(mCapacity)+"\n";
    const int *inds=&mRowIndices[1];
    int p,i0=0;
    for (int i=0;i<nRows;i++) {
        const T * vs=(*this)[i];
        p=*inds-i0;
        i0=*inds;
        inds++;
        for (int j=0;j<p;j++) {
            str+=CORE_String::toString(vs[j]);
            str+="\t";
        }
        str+="\n";
    
    
    }
    return str;
}

#endif