CORE_MorseArray.h

Go to the documentation of this file.

#ifndef CORE_MorseArray_H
#define CORE_MorseArray_H

#include "CORE_Object.h"
#include "CORE_Array.h"

#include "CORE_MorseArrayIterator.h"
#include "CORE_MorseArrayConstIterator.h"

template<class T>
class CORE_MorseArray : public CORE_Object {
  
  
    // ATTRIBUTES
    
public:
    
    
   
private:
    
    //size of the array
    tUIndex mSize;
    
    //values of the morse array
    CORE_Array<T> mValues;
    
    //index of the first value for each element i in [0,mSize[ 
    SP::CORE_UIndexArray mIndices;
    tBoolean mIsIndicesReferenced;
    
    //max number of values per element 
    tUIndex mLD;

    //increment of the indices array
    tBoolean mIncI;

    //number of packs
    tUInteger mPacksNumber;

    //true if all the not null value is the same
    tBoolean mIsConstant;
    
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    CORE_MorseArray() {
        mSize=0;
        mLD=1;
        mIncI=0;
        mPacksNumber=1;
        mIsConstant=false;
        mIndices=CORE_UIndexArray::New();
        mIsIndicesReferenced=false;
    }
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~CORE_MorseArray(void) {
       
    }
  
  
private:

    

public:
    // -------------------------
    // shared pointer operator
    // ------------------------
    void getSharedPointer(boost::shared_ptr<CORE_MorseArray<T> >& p){
        SP::CORE_Object r;
        CORE_Object::getSharedPointer(r);       
        p=boost::dynamic_pointer_cast<CORE_MorseArray<T> >(r);  
    };
    void getSharedPointer( boost::shared_ptr<const CORE_MorseArray<T> >& p) const{              
        SPC::CORE_Object r;
        CORE_Object::getSharedPointer(r);               
        p=boost::dynamic_pointer_cast<const CORE_MorseArray<T> >(r);                            
    }; 
private:
    inline boost::shared_ptr<CORE_MorseArray<T> > getThis() {
        boost::shared_ptr<CORE_MorseArray<T> > p;
        getSharedPointer(p);
        return p;                               
    }; 
    inline  boost::shared_ptr<const CORE_MorseArray<T> > getThis() const {                                      
        boost::shared_ptr<const CORE_MorseArray<T> > p;
        getSharedPointer(p);
        return p;       
    };

public:
  // ----------------
    // New constructors
    // ----------------
public:
    static inline boost::shared_ptr<CORE_MorseArray<T> > New() {
        boost::shared_ptr<CORE_MorseArray<T> > p(new CORE_MorseArray<T>(),
                                          CORE_Object::Delete());
        p->setThis(p);
        return p;
    };
    
    // ACCESSORS
    //==========

    inline T* operator[](const tUIndex& i) {
        return &mValues[getIndex(i)];
       
    }
    inline const T* operator[](const tUIndex& i) const {
        return &mValues[getIndex(i)];
    }
    
    //arithmetic operator
    // ==================
   
    template<class Q>
    inline CORE_MorseArray<T>& operator+=(const Q& f) {
        mValues+=f;
        return *this;
    }
    
    template<class Q>
    CORE_MorseArray<T>& operator-=(const Q& f) {
        mValues-=f;
    }
    
    
    template<class Q>
    inline CORE_MorseArray<T>& operator*=(const Q& f) {
        mValues*=f;
        return (*this);
    }
    template<class Q>
    inline CORE_MorseArray<T>& operator/=(const Q& f) {
        mValues/=f;
        return (*this);
    }
    
    //copy operator
    // ============
    
    template<class Q>
    CORE_MorseArray<T>& operator=(const CORE_MorseArray<Q>& f) {
        copy(f);
        return *this;
    }
   

    //iterators
    //==========
    
    inline void begin(const tUIndex& start,
                      const tUInteger& iPack,
                      CORE_MorseArrayIterator<T>& iter ) {
        if (start>=mSize)
            throw CORE_Exception("emicrom/core",
                                 "CORE_MorseArray::begin(start,ipack,iter)",
                                 CORE_Integer::toString(start)+" is too big (>="+CORE_Integer::toString(mSize)+")");
        //get the index of the first value at index start
        tUIndex &index=getIndices()[start+iPack];
        //init the iterator from values at index*mLD (index is not supposed to be set)
        //the index iterator to fill it at index start
        iter.init(&getValues()[start*mLD],
                  &index,
                  mIncI);
        
    }
    inline void begin(const tUIndex& start,
                      CORE_MorseArrayIterator<T>& iter ) {
        if (start>=mSize)
            throw CORE_Exception("emicrom/core",
                                 "CORE_MorseArray::begin(start,ipack,iter)",
                                 CORE_Integer::toString(start)+" is too big (>="+CORE_Integer::toString(mSize)+")");
        //get the index of the first value at index start
        tUIndex &index=getIndices()[start];
        //init the iterator from values at index*mLD (index is not supposed to be set)
        //the index iterator to fill it
        iter.init(&getValues()[index],
                  &index,
                  mIncI);
        
    }
    
    inline void begin(CORE_MorseArrayIterator<T>& iter ) {
        begin(0,0,iter);
    }
    
    inline void begin(const tUIndex& start, CORE_MorseArrayConstIterator<T>& iter) const {
        tUIndex i=start*mIncI;
        if (i>=mSize)
            throw CORE_Exception("emicrom/core",
                                 "CORE_MorseArray::begin(start,iter)",
                                 CORE_Integer::toString(i)+" is too big (>="+CORE_Integer::toString(mSize)+")");
        
        const tUIndex &index=getIndices()[i];
        iter.init(&getValues()[index],
                  &index,
                  mIncI);
   
    }
    inline void begin(CORE_MorseArrayConstIterator<T>& iter) const {
        begin(0,iter);
    }

   
    // SET methods
    //============

    template<class Q>
    void copy(const CORE_MorseArray<Q>& c) {
        mIncI=c.getIndexIncrement();
        mValues.copy(c.getValues());
        mIndices->copy(c.getIndices());
        mLD=c.getMaxValuesNumberPerElement();
        mSize=c.getSize();
    }

    inline void clear() {
        mSize=0;
        mIndices->clear();
        mValues.clear();
        mIncI=0; 
    }
    inline void setUniformSize(const tUIndex& n,const tUIndex& ld) {
        mLD=ld;
        mSize=n;
        mIndices->setSize(2);
        mValues.setSize(mLD);
        (*mIndices.get())[0]=0;
        (*mIndices.get())[1]=mLD;
        mIncI=0;
    }
    inline void setSize(const tUIndex& n,const tUIndex& m,const tUInteger& p) {
        //size of each element
        mLD=m;
        //number of elements
        mSize=n;
        //set the size of the indices
        mIndices->setSize(n+p);
        //set the total number of values
        mValues.setSize(n*mLD);
        //increment of index array
        mIncI=1;
        //number of packs
        mPacksNumber=p;
    }
    inline void setSize(const tUIndex& n,const tUIndex& m) {
        setSize(n,m,1);
    }

    inline void setIndicesByReference(SP::CORE_UIndexArray indices) {
        mIndices=indices;
        mIsIndicesReferenced=true;
    }


    void removeValue(const T& v);
    

    inline void reset() {
        mIndices->initArray(0);
        mValues.initArray(0);
        
    }
    // GET methods

    virtual tULLInt getMemorySize() const {
        return mValues.getMemorySize()+((mIsIndicesReferenced)?0:mIndices->getMemorySize());
            
    }
    
    inline const tUIndex& getSize() const {
        return mSize;
    }
    inline tUIndex getSize(const tUIndex& i) const {
        const tUIndex *index=&(*mIndices.get())[i*mIncI];
        return (tUIndex) ((*(index+1))-(*index));
    }
    
    inline const tBoolean& getIndexIncrement() const {
        return mIncI;
    }
    inline const tUIndex& getMaxValuesNumberPerElement() const {
        return mLD;
    }

    inline const tUInteger& getPacksNumber() const {
        return mPacksNumber;
    }
    inline const CORE_Array<T>& getValues() const {
        return mValues;
    }
    inline SP::CORE_UIndexArray getIndicesByReference()  const {
        return mIndices;
    }
    inline const CORE_UIndexArray& getIndices() const {
        return *mIndices.get();
    }
     
    tBoolean saveToFile(const tString& fn) const;

    tBoolean loadFromFile(const tString& fn);
    
    
    inline CORE_Array<T>& getValues()  {
        return mValues;
    }
    inline CORE_UIndexArray& getIndices()  {
        return *mIndices.get();
    }
  
   
    
    inline const tUIndex& getIndex(const tUIndex& i)   const {
        return (*mIndices.get())[i*mIncI];
    }
    inline tUIndex& getIndex(const tUIndex& i)   {
        return (*mIndices.get())[i*mIncI];
    }

    inline tBoolean isUniform() const {
        return (mIncI==0) || (mIndices->getSize()==2);
    }
    inline const tBoolean& isConstant() const {
        return mIsConstant;
    }


    inline void merge() {
        MergeMorseArray(mPacksNumber,*mIndices.get(),mLD,mValues);
    }
    
    inline void fitToSize() {
        mValues.setSize((*mIndices.get())[mIndices->getSize()-1]);
        mValues.fitToSize();
    }
    
    // OTHERS methods
      
 

public:
    inline tBoolean uniformize() {
        return uniformize(mIsConstant);
    }
    
private:
    tBoolean uniformize(tBoolean& isConstant);

public:
    static void MergeMorseArrays(const tUInteger& nSubsets,
                                 CORE_UIndexArray& indices,
                                 const tUIndex& ld,
                                 const vector<CORE_Array<T>* >& arrays);
    
    static void MergeMorseArray(const tUInteger& P,
                                CORE_UIndexArray& indices,
                                const tUIndex& ld,
                                CORE_Array<T>& array);
    
    virtual tString toString() const;
    
    
   
   
};

#include "CORE_MorseArray.hpp"

typedef CORE_MorseArray<double> CORE_DoubleMorseArray;
typedef CORE_MorseArray<long double> CORE_LDoubleMorseArray;
typedef CORE_MorseArray<float> CORE_FloatMorseArray;
typedef CORE_MorseArray<tUIndex> CORE_UIndexMorseArray;
typedef CORE_MorseArray<tIndex> CORE_IndexMorseArray;
typedef CORE_MorseArray<tChar> CORE_CharMorseArray;
typedef CORE_MorseArray<tUChar> CORE_UCharMorseArray;
typedef CORE_MorseArray<tUSInt> CORE_USIntMorseArray;
typedef CORE_MorseArray<tFlag> CORE_FlagMorseArray;
typedef CORE_MorseArray<tReal> CORE_RealMorseArray;
typedef CORE_MorseArray<tBoolean> CORE_BooleanMorseArray;

TYPEDEF_SPTR(CORE_DoubleMorseArray);
TYPEDEF_SPTR(CORE_LDoubleMorseArray);
TYPEDEF_SPTR(CORE_FloatMorseArray);
TYPEDEF_SPTR(CORE_UIndexMorseArray);
TYPEDEF_SPTR(CORE_IndexMorseArray);
TYPEDEF_SPTR(CORE_USIntMorseArray);
TYPEDEF_SPTR(CORE_UCharMorseArray);
TYPEDEF_SPTR(CORE_CharMorseArray);
TYPEDEF_SPTR(CORE_FlagMorseArray);
TYPEDEF_SPTR(CORE_RealMorseArray);
TYPEDEF_SPTR(CORE_BooleanMorseArray);

TYPEDEF_SVPTR(CORE_DoubleMorseArray);
TYPEDEF_SVPTR(CORE_LDoubleMorseArray);
TYPEDEF_SVPTR(CORE_FloatMorseArray);
TYPEDEF_SVPTR(CORE_UIndexMorseArray);
TYPEDEF_SVPTR(CORE_IndexMorseArray);
TYPEDEF_SVPTR(CORE_USIntMorseArray);
TYPEDEF_SVPTR(CORE_UCharMorseArray);
TYPEDEF_SVPTR(CORE_CharMorseArray);
TYPEDEF_SVPTR(CORE_FlagMorseArray);
TYPEDEF_SVPTR(CORE_RealMorseArray);
TYPEDEF_SVPTR(CORE_BooleanMorseArray);
#endif