CORE_Array2D.h

Go to the documentation of this file.

#ifndef CORE_Array2D_H
#define CORE_Array2D_H

#include "CORE_ArrayList.h"

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

    // number of rows
    tUIndex mRowsNumber;

  
    // the index of row i. The util size of the values is mRowIndices[mRowsNumber];
    // the size if mRowCapacity > mRowsNumber+1
    tBoolean  mIsPrivateRowAllocated;
    tUIndex mRowCapacity;
    tUIndex *mRowIndices;
    
    
    // CONSTRUCTORS
public:
    CORE_Array2D();

 
    // DESTRUCTORS
    virtual ~CORE_Array2D(); 
  
 

public:
    // OPERATOR
  
    const T* operator[](const tUIndex& i) const { 
        ASSERT_IN(i<mRowCapacity);
        return  &CORE_ArrayList<T>::operator[](mRowIndices[i]);
    };

    T* operator[](const tUIndex& i) {  
        ASSERT_IN(i<mRowCapacity);
        return  &CORE_ArrayList<T>::operator[](mRowIndices[i]);
    };
    
    const T& operator()(const tUIndex& i,const tUIndex& j)  { 
        ASSERT_IN(i<mRowCapacity);
        return  CORE_ArrayList<T>::operator[](mRowIndices[i]+j);
    };
    const  T& operator()(const tUIndex& i,const tUIndex& j) const { 
        ASSERT_IN(i<mRowCapacity);
        return  CORE_ArrayList<T>::operator[](mRowIndices[i]+j);
    };

   

    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;
    };

private:
    void allocateRows(const tUIndex& n);

    void desallocateRows();
    
    // set METHODS
    // ============
public:
    virtual void clear(){
        setSize(0,0);
    };
    
    void setSize(const tUIndex& nRows,const tUIndex& nCols);
    
    void reserve(const tUIndex& nRows,const tUIndex& nCols);
    
    virtual void fitToSize();

 

    void copy(const CORE_Array2D<T>& v);

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


    void setRowsNumber(const tUIndex& nRows);

    void setRowSize(const tUIndex& i,const tUIndex& n);
    
    void setValues(const tUIndex& nvs,const T* vs,const tUIndex& nrs,const tUIndex* rs);
    
    
    void setValuesByReference(const tUIndex& nvs,T* vs,const tUIndex& nrs,tUIndex* rs);
    
    inline void set(const tUIndex& i,const tUIndex& j,const T& obj) {
        (*this)(i,j)=obj;
    };
    
    void addRow(const tUIndex& rowSize);

  
    template<class Q>
    void setRowValue(const tUIndex& i,const tUIndex& p,const Q* vs);
    
    
    template<class Q>
    void setRowValue(const tUIndex& i,const vector<Q>& vs);
    
    template<class Q>
    void setRowValue(const tUIndex& i,const CORE_Array<Q>& vs);
    
    
    template<class Q>
    void setRowValue(const tUIndex& i,const CORE_Vector<Q>& vs);
    
  
  
    inline void add(const tUIndex& iRow,
                    const T& obj){
        //get the index to add
        tUIndex *i0=&mRowIndices[iRow];
        tUIndex index=(*i0)+getColumnsNumber(iRow);
        //insert the element obj at index index
        this->insertAtIndex(index,obj);

        //update the row indices
        i0++;
        for (tUIndex i=iRow+1;i<=mRowsNumber;i++) {
            (*i0)++;
            i0++;
        }
    };  
   
 
 
   
  
    // get METHODS
    // ============
    
    inline const tUIndex& getValuesNumber() const {
        return CORE_Array<T>::getSize();
    };
   
    inline tUIndex getRowSize(const tUIndex& i) const {
        ASSERT_IN(i<mRowCapacity);
        return mRowIndices[i+1]-mRowIndices[i];
    };
    inline tUIndex getColumnsNumber(const tUIndex& i) const {
        return getRowSize(i);
    };
    
    inline const T* getRow(const tUIndex& i) const{
        return (*this)[i];
    };  
    inline T* getRow(const tUIndex& i) {
        return (*this)[i];
    };
    
    inline const T* getValues() const {
        return getRow(0);
    };
    inline T* getValues()  {
        return getRow(0);
    }; 
 
    inline const tUIndex* getRowIndices() const {
        return mRowIndices;
    };
    inline const tUIndex& getRowsNumber() const {
        return mRowsNumber;
    };
 

    // other METHODS
  

    tString toString() const; 
    
  
};

#include "CORE_Array2D.hpp"

typedef CORE_Array2D<tDouble> CORE_DoubleArray2D;
typedef CORE_Array2D<tChar> CORE_CharArray2D;
typedef CORE_Array2D<tInt> 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<tSInt> CORE_ShortArray2D;
typedef CORE_Array2D<tString> CORE_StringArray2D;
typedef CORE_Array2D<tInteger> CORE_IntegerArray2D;
typedef CORE_Array2D<tUInteger> CORE_UIntegerArray2D;


TYPEDEF_SPTR(CORE_DoubleArray2D);
TYPEDEF_SPTR(CORE_BooleanArray2D);
TYPEDEF_SPTR(CORE_CharArray2D);
TYPEDEF_SPTR(CORE_IntArray2D);
TYPEDEF_SPTR(CORE_RealArray2D);
TYPEDEF_SPTR(CORE_ComplexArray2D);
TYPEDEF_SPTR(CORE_FlagArray2D);
TYPEDEF_SPTR(CORE_UIntegerArray2D);
TYPEDEF_SPTR(CORE_IntegerArray2D);
TYPEDEF_SPTR(CORE_StringArray2D);
TYPEDEF_SPTR(CORE_ShortArray2D);

#endif