CORE_Array2D.h

Go to the documentation of this file.

#ifndef CORE_Array2D_H
#define CORE_Array2D_H

#include "CORE_List.h"
#include "CORE_Array.h"
#include "CORE_Vector.h"

template < class T>
class CORE_Array2D : public CORE_List {
  
private:

    tBoolean mHasToBeDeleted;
    
    // values
    T *mVector;

    // mCapacity factor
    int mCapacityFactor;

    // allocated size of mVector
    int mCapacity;

    // number of lines
    int mRowsNumber;

    // allocated size of mRowIndices
    int mRowsCapacity;

    // the index of row i. The util size of the values is mRowIndices[mRowsNumber];
    int *mRowIndices;
  
  
    // CONSTRUCTORS
public:
    CORE_Array2D();

 
    // DESTRUCTORS
    virtual ~CORE_Array2D(); 
  
 

public:
    // OPERATOR
  
    const T* operator[](int i) const { 
        ASSERT_IN(i>-1);
        ASSERT_IN(i<mRowsNumber);
        return &mVector[mRowIndices[i]];
    };

    T* operator[](int i) {  
        ASSERT_IN(i>-1);
        ASSERT_IN(i<mRowsNumber);
        return &mVector[mRowIndices[i]];
    };

    static inline boost::shared_ptr<CORE_Array2D<T> > New() {
        boost::shared_ptr<CORE_Array2D<T> > p(new CORE_Array2D<T>(),CORE_Object::Delete());
        return p;
    };
  
    // set METHODS

    inline void setCapacityFactor(const int& i) {
        mCapacityFactor=i;
    };
 
  
    void setCapacity(const int& n,const int& p);
    
    
    void setSize(const int& n,const int& p);

    void resize(); 

    void copy(const CORE_Array2D<T>& src);
    inline void copy(const CORE_Array2D<T>* src){
        if (src!=null) copy(*src);
        else clear();
    };

 
    inline void setValues(const int& nvs,const T* vs,const int& nrs,const int* rs) {
        if (mHasToBeDeleted && (mVector!=null) ) delete[] mVector;

        // cpacity factor 
        mCapacityFactor=1;

        // capacity for  values
        mCapacity=nvs;
        if (mCapacity==0) mCapacity=1;
        mVector=new T[mCapacity];
        
        T * vectc=mVector;
        const T* vsc=vs;
        for (int i=0;i<nvs-1;i++) {
            *vectc=*vsc;
            vectc++;
            vsc++;
        }
        *vectc=*vsc;

        // capacity of row indices
        if (mHasToBeDeleted && (mRowIndices!=null)) delete[] mRowIndices;
        mRowsCapacity=nrs;
        if (nrs==0) mRowsCapacity=1;
        mRowIndices=new int[mRowsCapacity];
        int *inds=mRowIndices;
        const int * rsc=rs;
        for (int i=0;i<nrs-1;i++) {
            *inds=*rsc;
            inds++;
            rsc++;
        }
        *inds=*rsc;
      
      
        mRowsNumber=nrs-1;
     
        mHasToBeDeleted=true;
        
    }
    
    inline void setValues(const int& nvs,T* vs,const int& nrs,int* rs,const tBoolean& toBeDeleted) {

        
        if (mHasToBeDeleted && (mVector!=null) ) delete[] mVector;
        mVector=vs;
       
        if (mHasToBeDeleted && (mRowIndices!=null) ) delete[] mRowIndices;
        mRowIndices=rs;
        

        mCapacityFactor=1;
        mCapacity=nvs;
        mRowsNumber=nrs-1;
        mRowsCapacity=nrs;

        mHasToBeDeleted=toBeDeleted;
        
    }
    
    inline void set(const int& i,const int& j,const T& obj) {
        (*this)[i][j]=obj;
    };
    inline void addRow(const int& rowSize){
        // get the actual size
        int size=getValuesNumber();
        // new size
        int newSize=size+rowSize;
        if (newSize>mCapacity) {
            int n=newSize*mCapacityFactor;
            // new allocation
            T *newVector=new T[n];
            // copy the values
            for (int i=0;i<mCapacity;i++) {
                newVector[i]=mVector[i];
            }
            for (int i=mCapacity;i<n;i++) {
                newVector[i]=0;
            }
            if (mHasToBeDeleted && (mVector!=null) ) {
                delete[] mVector;
            }
            mVector=newVector;
            mCapacity=n;
            mHasToBeDeleted=true;
            
        }
        mRowsNumber++;
        if (mRowsNumber+1>mRowsCapacity) {
            mRowsCapacity=(mRowsNumber+1)*mCapacityFactor+1;
            // new allocation
            int *rows=new int[mRowsCapacity];
            for (int i=0;i<mRowsNumber;i++) {
                rows[i]=mRowIndices[i];
            }
            for (int i=mRowsNumber;i<mRowsCapacity;i++) {
                rows[i]=newSize;
            }
            if (mHasToBeDeleted && (mRowIndices!=null) ) delete[] mRowIndices;
            mRowIndices=rows;
            mHasToBeDeleted=true;
        }

        
        mRowIndices[mRowsNumber]=newSize;
        
    }; 

    void setRowSize(const int& r,const int& s) {
        ASSERT_IN(r<mRowsNumber);
        int n=getValuesNumber();
        int p=s-getRowSize(r);
        int newValuesNumber=n+p;
        
        
        // set the new row indices
        for (int i=r+1;i<mRowsNumber;i++)
            mRowIndices[i]+=p;
        
        if (newValuesNumber>mCapacity) {
            // reallocate the values
            int n=newValuesNumber*mCapacityFactor;
            // new allocation
            T *newVector=new T[n];
            // copy the values
            for (int i=0;i<mCapacity;i++) {
                newVector[i]=mVector[i];
            }
            for (int i=mCapacity;i<n;i++) {
                newVector[i]=0;
            }
            if (mHasToBeDeleted && (mVector!=null) ) delete[] mVector;
            mVector=newVector;
            mCapacity=n;
            mHasToBeDeleted=true;
        }
        
        // move the values if needed
        if (mRowIndices[r+1]!=newValuesNumber) {
            if (p>0) {
                T *curN=&mVector[getValuesNumber()-1];
                const T *curP=curN-p;
                const T *curR=&mVector[mRowIndices[r+1]];
                while (curN>=curR) {
                    *curN=*curP;
                    curN--;
                    curP--;
                }
            } else {
                const T *curR=&mVector[getValuesNumber()-1];
                T *curN=&mVector[mRowIndices[r+1]];
                const T *curP=curN-p;//curN < curP
                
                while (curN<=curR) {
                    *curN=*curP;
                    curN++;
                    curP++;
                }
            }
        }
    };
    inline void setRowValue(const int& i,const int& p,const T* vs) {
        setRowSize(i,p);
        T *v=mVector[mRowIndices[i]];
        const T * vc=vs;
        for (int j=0;j<p-1;j++) {
            *v=*vc;
            vc++;
            v++;
        }
        *v=*vc;
    }; 
    inline void setRowValue(const int& i,const vector<T>& vs) {
        int p=vs.size();
        setRowSize(i,p);
        T *v=mVector[mRowIndices[i]];
        if (p>0) for (int j=0;j<p-1;j++) {*v=vs[j];v++;};*v=vs[p-1];
        
    }; 
    template<class Q>
    void setRowValue(const int& i,const CORE_Array<Q>& vs) {
        int p=vs.getSize();
        setRowSize(i,p);
        T *v=mVector[mRowIndices[i]];
        if (p>0) for (int j=0;j<p-1;j++) {*v=(T) vs[j];v++;};*v=vs[p-1];
    }; 
    template<class Q>
    void setRowValue(const int& i,const CORE_Vector<Q>& vs) {
        int p=vs.getSize();
        setRowSize(i,p);
        T *v=mVector[mRowIndices[i]];
        if (p>0) {
            for (int j=0;j<p-1;j++) {
                *v=(T) vs[j];
                v++;
            }
            *v=vs[p-1];
        }
    };
  
  
    inline void add(const int& i,
                    const T& obj){
       
        int p=getRowSize(i);
        setRowSize(i,p+1);
        mVector[mRowIndices[i]+p]=obj;
    };  
   
 
 
    virtual void clear(){
        setSize(0,0);
    };
  
    // get METHODS
  
    inline int getValuesNumber() const {
        return mRowIndices[mRowsNumber];
    };
   
    inline int getRowSize(const int& i) const {
        int *rowp=&mRowIndices[i+1];
        int *row=rowp-1; 
        return (*rowp)-(*row);
    };
    inline const T* getRow(const int& i) const{
        return (*this)[i];
    };  
    inline T* getRow(const int& i) {
        return (*this)[i];
    };
    inline const T* getValues() const {
        return mVector;
    };
    inline T* getValues()  {
        return mVector;
    }; 
 
    inline const int* getRowIndices() const {
        return mRowIndices;
    };
    inline int getRowsNumber() const {
        return mRowsNumber;
    };
    
    inline int getCapacityFactor() const {
        return mCapacityFactor;
    };
    inline int getCapacity() const {
        return mCapacity;
    };
   

    // other METHODS
  

    tString toString() const; 
  
  
};

#include "CORE_Array2D.hpp"

typedef CORE_Array2D<double> CORE_DoubleArray2D;
typedef CORE_Array2D<tCharacter> CORE_CharacterArray2D;
typedef CORE_Array2D<int> CORE_IntArray2D;
typedef CORE_Array2D<tBoolean> CORE_BooleanArray2D;
typedef CORE_Array2D<tReal> CORE_RealArray2D;
typedef CORE_Array2D<tComplex> CORE_ComplexArray2D;
typedef CORE_Array2D<tFlag> CORE_FlagArray2D;
typedef CORE_Array2D<tShort> CORE_ShortArray2D;
typedef CORE_Array2D<tString> CORE_StringArray2D;
typedef CORE_Array2D<tInteger> CORE_IntegerArray2D;
typedef CORE_Array2D<tRelativeInteger> CORE_RelativeIntegerArray2D;


TYPEDEF_SPTR(CORE_DoubleArray2D);
TYPEDEF_SPTR(CORE_BooleanArray2D);
TYPEDEF_SPTR(CORE_CharacterArray2D);
TYPEDEF_SPTR(CORE_IntArray2D);
TYPEDEF_SPTR(CORE_RealArray2D);
TYPEDEF_SPTR(CORE_ComplexArray2D);
TYPEDEF_SPTR(CORE_FlagArray2D);
TYPEDEF_SPTR(CORE_RelativeIntegerArray2D);
TYPEDEF_SPTR(CORE_IntegerArray2D);
TYPEDEF_SPTR(CORE_StringArray2D);
TYPEDEF_SPTR(CORE_ShortArray2D);

#endif