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_ArrayList<T>() {
    
    mRowsNumber=0;
    mRowCapacity=0;
    mRowIndices=null;
    
    mIsPrivateRowAllocated=false;

  
  
}

template<class T>
CORE_Array2D<T>::~CORE_Array2D() {
    desallocateRows();
}


template<class T>
void CORE_Array2D<T>::desallocateRows() {
    if ( mIsPrivateRowAllocated && (mRowIndices!=null)) {
        delete[] mRowIndices;
        mRowIndices=null;
        mIsPrivateRowAllocated=false;
        mRowCapacity=0;
        mRowsNumber=0;
        
    }
}

template<class T>
void CORE_Array2D<T>::allocateRows(const tUIndex& s) {
    
    //nothink to do
    if (s==mRowCapacity) return;

    //save the old size
    tUIndex oldSize=mRowsNumber;
    
    //allocate the new values
    tUIndex* newValues=null;
    try {
        //allocate with an element more for iteration with pointer
        newValues=new tUIndex[s+1];
    } catch(std::exception& e) {
        throw CORE_Exception("common/core",
                             "CORE_Array::allocate("+CORE_Integer::toString(s)+")",
                             "not enought memory for allocation");
    }
    if (newValues==null) {
        throw CORE_Exception("common/core",
                             "CORE_Array::allocate("+CORE_Integer::toString(s)+")",
                             "not enought memory for allocation");
    }
    
    //copy the old values
    tUIndex* p=newValues;
    const tUIndex* oldP=mRowIndices;
    //m = min(mCapacity,s);
    tUIndex i,m=(mRowCapacity<s)?mRowCapacity:s;
    for (i=0;i<m;i++) {
        *p=*oldP;
        p++;
        oldP++;
    }
    //reset to 0 the new values
    if (s>m) memset(p,0,(s-m)*sizeof(*p));
    
    
    //desallocate the values array: sze is reduced to 0
    desallocateRows();
    
    //set the new values
    mRowIndices=newValues;
    mIsPrivateRowAllocated=true;
    mRowCapacity=s;
    //update the size 
    mRowsNumber=(oldSize>=mRowCapacity)?mRowCapacity:oldSize;
}

template<class T>
void CORE_Array2D<T>::setSize(const tUIndex& nRows,const tUIndex& nCols) {
    
    //set the size of values
    CORE_Array<T>::setSize(nRows*nCols);

    //set the rows nuuber
    setRowsNumber(nRows);
    
}
template<class T>
void CORE_Array2D<T>::reserve(const tUIndex& nRows,const tUIndex& nCols) {
    
    //set the size of values
    CORE_Array<T>::reserve(nRows*nCols);

    //set the rows number
    if (mRowCapacity<nRows) allocateRows(nRows);
    
}

template<class T>
void CORE_Array2D<T>::setRowsNumber(const tUIndex& nRows) {
    //allocate the row
    if (nRows+1>mRowCapacity) {
        
        //allocate the new rows indices
        allocateRows(nRows+1);
  
    }
    
    //set the rows number
    mRowsNumber=nRows;
}

template<class T>
void CORE_Array2D<T>::fitToSize() {
    CORE_Array<T>::fitToSize();
     
    tUIndex n=getRowsNumber()+1;
    if (mRowCapacity==n) return;
    allocateRows(n);

}

template<class T>
void CORE_Array2D<T>::copy(const CORE_Array2D<T>& src) {
    //copy the values
    CORE_ArrayList<T>::setValues(src.getSize(),src.getValues());
    
    //copy the rows
     tUIndex k,n=src.getRowsNumber();
    
    //allocate the vector
    if (n+1>=mRowCapacity) {
        mRowsNumber=n;
        allocateRows(n+1);
    }
    
    //copy the rows indices
    const tUIndex* pf=src.getRowIndices();
    tUIndex * vs=mRowIndices;
    for (k=0;k<=n;k++) {
        *vs=*pf;
        vs++;
        pf++;
        
    }
}


template<class T>
void CORE_Array2D<T>::setValues(const tUIndex& nvs,const T* vs,const tUIndex& nrs,const tUIndex* rs) {
    //set the values
    CORE_ArrayList<T>::setValues(nvs,vs);
    
    //set the indices
    setRowsNumber(nrs-1);
    
    //copy it
    const tUIndex* pf=rs;
    tUIndex * rows=mRowIndices;
    for (tUIndex k=0;k<nrs;k++) {
        *rows=*pf;
        rows++;
        pf++;
        
    }
}
template<class T>
void CORE_Array2D<T>::setValuesByReference(const tUIndex& nvs,T* vs,const tUIndex& nrs,tUIndex* rs) {
    //set the values
    CORE_Array<T>::setValuesByReference(nvs,vs);
    
    //set the indices
    setRowsNumber(nrs-1);
    
    //copy it
    desallocateRows();
    
    mRowIndices=rs;
    mRowsNumber=nrs-1;
    mRowCapacity=nrs;
    mIsPrivateRowAllocated=false;
}

template<class T>
void CORE_Array2D<T>::setRowSize(const tUIndex& iRow,const tUIndex& n) {

    //get the old size of the row
    tUIndex nOld=getRowSize(iRow);
    if (nOld==n) return ;
    tUIndex oldSize=getValuesNumber();
    
    //pointer to the values'index of the row iRow
    tUIndex *rIndex=&mRowIndices[iRow];
    
    //values
    T *values=getValues();

    //number of element to add
    tIndex p=n-nOld;
    
    //if nOld > n
    if (p<0) {
       
        //number of element to translate
        tUIndex nElementsToTranslate=oldSize-(*rIndex)-nOld;
        //first  element of the element to translate
        const T *ovs=&values[(*rIndex)+nOld];
        //new position of the translated element
        T* vs=ovs+p;
        //move the indices of rows
        for (tUIndex i=0;i<nElementsToTranslate;i++) {
            *vs=*ovs;
            vs++;
            ovs++;
        }
        
        tUIndex newSize=getValuesNumber()+p;
        CORE_ArrayList<T>::setSize(newSize);
        
        return;
    }
    
    //set the new size
    tUIndex newSize=getValuesNumber()+p;
    CORE_ArrayList<T>::setSize(newSize);

    //move the element from index = mRowIndices[i]+nOld-1 to the end
    //last element of the old values
    const T *ovs=&values[oldSize-1];
    
    //last element of rows
    const T *lastRowElement=&values[(*rIndex)+nOld];

    //last element of the new values
    T* vs=&values[newSize-1];

    //move the last element to end of new arrays
    while (ovs!=lastRowElement) {
        *vs=*ovs;
        ovs--;
        vs--;
    }

    //set the new indices of element
    rIndex++;
    for (tUIndex i=iRow+1;i<=mRowsNumber;i++) {
        (*rIndex)+=p;
        rIndex++;
    }

    
    
}
template<class T>
template<class Q>
void CORE_Array2D<T>::setRowValue(const tUIndex& i,const CORE_Vector<Q>& vs) {
    //set the szie of the row
    setRowSize(i,vs.getSize());
    //set the value
    T*  values=&getValues()[mRowIndices[i]];
    typename vector<Q>::const_iterator iter=vs.begin();
    while (iter!=vs.end()) {
        *values=(T) *iter;
        iter++;
        values++;
    }
}
template<class T>
template<class Q>
void CORE_Array2D<T>::setRowValue(const tUIndex& i,const vector<Q>& vs) {
    //set the szie of the row
    setRowSize(i,vs.getSize());
    //set the value
    T*  values=&getValues()[mRowIndices[i]];
    typename vector<Q>::const_iterator iter=vs.begin();
    while (iter!=vs.end()) {
        *values=(T) *iter;
        iter++;
        values++;
    }
}
template<class T>
template<class Q>
void CORE_Array2D<T>::setRowValue(const tUIndex& index,const CORE_Array<Q>& vs) {
    tUIndex i,n=vs.getSize();
    //set the size of the row
    setRowSize(index,n);
    //set the value
    T*  values=&getValues()[mRowIndices[i]];
    const Q* iter=&vs[0];
    while (i<n) {
        *values=(T) *iter;
        iter++;
        values++;
        i++;
    }
}
template<class T>
template<class Q>
void CORE_Array2D<T>::setRowValue(const tUIndex& index,const tUIndex& n,const Q* vs) {
    tUIndex i;
    //set the size of the row
    setRowSize(index,n);
    
    //set the value
    T*  values=&getValues()[mRowIndices[i]];
    const Q* iter=vs;
    while (i<n) {
        *values=(T) *iter;
        iter++;
        values++;
        i++;
    }
}

template<class T>
void CORE_Array2D<T>::addRow(const tUIndex& n) {
    tUIndex oldSize=CORE_ArrayList<T>::getSize();
    //set the new size of the values
    CORE_ArrayList<T>::setSize(oldSize+n);
    //set the new size of rows
    setRowsNumber(getRowsNumber()+1);
    //resgister the last inde of the new row
    mRowIndices[getRowsNumber()]=oldSize+n;
}

template<class T>
tString CORE_Array2D<T>::toString() const {
    tString str="";
    tUIndex n=getValuesNumber();
    tUIndex i,nRows=getRowsNumber();
    str+="size:"+CORE_Integer::toString(n)+"\n";

    //row indices
    const tUIndex *inds=mRowIndices;
    tUIndex i0=*inds;
    inds++;
    
    //row values
    const T * vs=getValues();
    
    tUIndex j,nCols;
    
    for (i=0;i<nRows;i++) { //loop on row

        //number of element of the column
        nCols=(*inds)-i0;
        for (j=0;j<nCols;j++) {
            str+=CORE_String::toString(*vs);
            str+="\t";
            //next column
            vs++;
        }
        str+="\n";

        //next row
        i0=(*inds);
        inds++;
    
    }
    
    return str;
}

#endif