EMM_Array.h

Go to the documentation of this file.

#ifndef EMM_Array_H
#define EMM_Array_H

#include "CORE_Array.h"
#include "EMM_Types.h"


template<class T>
class EMM_Array : public CORE_Array<T> {
  
  
    // ATTRIBUTES
    
public:
    
    
   
private:
  
  
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_Array() {
      
    }
    EMM_Array(const EMM_Array<T>& c):CORE_Array<T>(c){
    }
    EMM_Array(const tUIndex& n):CORE_Array<T>(n){
    }
    
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~EMM_Array(void) {
       
    }
  
  
private:

    

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

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

    //arithmetic operator
    // ==================
   
    template<class Q>
    inline EMM_Array<T>& operator+=(const Q& f) {
        CORE_Array<T>::operator+=(f);
        return (*this);
    }
    
    template<class Q>
    inline EMM_Array<T>& operator-=(const Q& f) {
        CORE_Array<T>::operator-=(f);
        return (*this);
    }
    
    template<class Q>
    inline EMM_Array<T>& operator*=(const Q& f) {
        CORE_Array<T>::operator*=(f);
        return (*this);
    }
    template<class Q>
    inline EMM_Array<T>& operator/=(const Q& f) {
        CORE_Array<T>::operator/=(f);
        return (*this);
    }
    
    //copy operator
    // ============
    
    template<class Q>
    EMM_Array<T>& operator=(const EMM_Array<Q>& f) {
        CORE_Array<T>::copy(f);
        return *this;
    }
   

  
   
    // SET methods

  
    // GET methods

   
public:
    // OTHERS methods
      
 
    
    tBoolean saveToFile(const tString& fileName) const;


    inline tBoolean saveToStream(ofstream& f) const {
        return saveToStream(f,1);
    }

    tBoolean saveToStream(ofstream& f,const tUSInt& dim) const;
    
    static tBoolean saveToStream(ofstream& f,const vector<tUSInt>& dims,const vector<const EMM_Array<T>*>& inds);
    
    tBoolean loadFromFile(const tString& fileName);
    
    tBoolean loadFromStream(ifstream& f,const vector<tUSInt>& dims,const vector<EMM_Array<T>* >& arrays) const;
    
    tBoolean loadFromStream(ifstream& f,const tUSInt& dim);
    inline tBoolean loadFromStream(ifstream& f) {
        return loadFromStream(f,1);
    }

   
};

#include "EMM_Array.hpp"

typedef EMM_Array<double> EMM_DoubleArray;
typedef EMM_Array<long double> EMM_LDoubleArray;
typedef EMM_Array<float> EMM_FloatArray;
typedef EMM_Array<tUIndex> EMM_UIndexArray;
typedef EMM_Array<tIndex> EMM_IndexArray;
typedef EMM_Array<tUSInt> EMM_USIntArray;
typedef EMM_Array<tUInt> EMM_UIntArray;
typedef EMM_Array<tSInt> EMM_SIntArray;
typedef EMM_Array<tInt> EMM_IntArray;
typedef EMM_Array<tFlag> EMM_FlagArray;
typedef EMM_Array<tUChar> EMM_UCharArray;
typedef EMM_Array<tBoolean> EMM_BooleanArray;
typedef EMM_Array<tCellFlag> EMM_CellFlagArray;
typedef EMM_Array<tLimitCondition> EMM_LimitConditionArray;

TYPEDEF_SPTR(EMM_DoubleArray);
TYPEDEF_SPTR(EMM_LDoubleArray);
TYPEDEF_SPTR(EMM_FloatArray);
TYPEDEF_SPTR(EMM_UIndexArray);
TYPEDEF_SPTR(EMM_IndexArray)
TYPEDEF_SPTR(EMM_USIntArray);
TYPEDEF_SPTR(EMM_UIntArray);
TYPEDEF_SPTR(EMM_IntArray);
TYPEDEF_SPTR(EMM_SIntArray);
TYPEDEF_SPTR(EMM_FlagArray);
TYPEDEF_SPTR(EMM_UCharArray);
TYPEDEF_SPTR(EMM_BooleanArray);
TYPEDEF_SPTR(EMM_CellFlagArray);
TYPEDEF_SPTR(EMM_LimitConditionArray);

TYPEDEF_SVPTR(EMM_DoubleArray);
TYPEDEF_SVPTR(EMM_LDoubleArray);
TYPEDEF_SVPTR(EMM_FloatArray);
TYPEDEF_SVPTR(EMM_UIndexArray);
TYPEDEF_SVPTR(EMM_IndexArray);
TYPEDEF_SVPTR(EMM_USIntArray);
TYPEDEF_SVPTR(EMM_UIntArray);
TYPEDEF_SVPTR(EMM_SIntArray);
TYPEDEF_SVPTR(EMM_IntArray);
TYPEDEF_SVPTR(EMM_FlagArray);
TYPEDEF_SVPTR(EMM_UCharArray);
TYPEDEF_SVPTR(EMM_BooleanArray);
TYPEDEF_SVPTR(EMM_CellFlagArray);
TYPEDEF_SVPTR(EMM_LimitConditionArray);
#endif