CORE_Array.h

Go to the documentation of this file.

#ifndef CORE_Array_H
#define CORE_Array_H


#include "CORE_Object.h"
#include "CORE_List.h"
#include "CORE_ListPointers.h"

#include "types.h"
#include <vector>


template <class T>
class CORE_Array : public CORE_List {
private:
    // values of the array
    T* mVector; 
    // current vector
    T* mCVector;
    // size of the array
    tArrayIndex mSize; 
    // memory size of the array
    tArrayIndex mCapacity;
    // capacity factor: the memory size of the array is the (mStartIndex + mSize) * mCapacityFactor by default
    tFlag  mCapacityFactor;
  
    // start index of the array (0 by default)
    tArrayIndex  mStartIndex;

    tBoolean mHasToBeDeleted;

    // CONSTRUCTORS
public:
    CORE_Array();
    template<class Q>
    CORE_Array(const std::vector<Q>&  values);
    
    CORE_Array(const tArrayIndex& n);

 
    // DESTRUCTORS
    virtual ~CORE_Array(); 
  
 

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

    // ----------------
    // New constructors
    // ----------------
public:
    static inline boost::shared_ptr<CORE_Array<T> > New() {
        boost::shared_ptr<CORE_Array<T> > p(new CORE_Array<T>(),
                                            CORE_Object::Delete());
        p->setThis(p);
        return p;
    };  
    static inline boost::shared_ptr<CORE_Array<T> > New(const tArrayIndex& n) {
        boost::shared_ptr<CORE_Array<T> > p(new CORE_Array<T>(n),
                                            CORE_Object::Delete());
        p->setThis(p);
        return p;
    };
    
    // ---------------------------
    // Accessor & basic operators
    // ---------------------------
public:
    inline const T& operator[](const tArrayIndex& i) const { 
        ASSERT_IN(i<mSize);
        return mCVector[i];
    };

    inline T& operator[](const tArrayIndex& i) {  
        ASSERT_IN(i<mSize);
        return mCVector[i];
    };
    inline T& operator()(const tArrayIndex& i) {
        ASSERT_IN(i<mSize);
        return mCVector[i];
    };
    inline const T& operator()(const tArrayIndex& i) const {
        ASSERT_IN(i<mSize);
        return mCVector[i];
    };
    
    inline T& operator=(const CORE_Array<T>& f) {
        for (tArrayIndex i=0;i<mSize;i++) mCVector[i]=f[i];
        return mCVector[0];
    };
   
    inline T& operator/=(const T& f) {
        for (tArrayIndex i=0;i<mSize;i++) mCVector[i]/=f;
        return mCVector[0];
    };
    inline T& operator*=(const T& f) {
        for (tArrayIndex i=0;i<mSize;i++) mCVector[i]*=f;
        return mCVector[0];
    };
    inline T& operator+=(const T& f) {
        for (int i=0;i<mSize;i++) mCVector[i]+=f;
        return mCVector[0];
    };
    inline T& operator-=(const T& f) {
        for (tArrayIndex i=0;i<mSize;i++) mCVector[i]-=f;
        return mCVector[0];
    };
 
    inline const T& get(const tArrayIndex& i) const { 
    
        ASSERT_IN(i<mSize);
        return mCVector[i];
    }; 
    inline T& get(const tArrayIndex& i) { 
      
        ASSERT_IN(i<mSize);
        return mCVector[i];
    }; 
    inline const T& getValue(const tArrayIndex& i) const { 
        ASSERT_IN(i<mSize);
        return mCVector[i];
    };

    inline const T& getLastElement() {
        if (mSize==0) throw CORE_Exception("common/core","CORE_Array::getLastElement()","no element in array");
        tArrayIndex n=mSize;
        return mCVector[n-1];
    };
    
    inline const tFlag& getCapacityFactor() const {return mCapacityFactor;};
    
    inline const tArrayIndex& getStartIndex() const {return mStartIndex;};
    
    inline const tArrayIndex& size() const {return mSize;};
    
    inline const tArrayIndex& getSize() const {return mSize;}; 
    
    inline const tArrayIndex& getCapacity() const {return mCapacity;};
    
    // -------------
    // copy methods
    // -------------

    void copy(const CORE_Array<T>& src);
    inline void copy(const CORE_Array<T>*src){
        if (src!=null) copy(*src);
    };
  
    // -----------
    // SET Methods
    // ------------
public:
    void setStartIndex(const tArrayIndex& n) {
        if (n>mCapacity) throw CORE_Exception("common/core",
                                              "CORE_Array::setStartIndex()",
                                              "start index out of bounds");
        
        long long int d=n-mStartIndex;
        mStartIndex=n;
        mSize-=d;
        mCVector=&mVector[mStartIndex];
    };
    void setSize(const tArrayIndex& n); 
    inline void setCapacityFactor(const tFlag& n) {
        mCapacityFactor=n;
    };
    
    void setCapacity(const tArrayIndex& c); 

    void setValues(const CORE_Array<T>& array,const tArrayIndex& fromIndex); 
    inline void setValues(const CORE_Array<T>& array) {
        setValues(array,0);
    };
 
    inline void setValues(const CORE_Array<T>* array) {
        if (array!=null) setValues(*array);
        else setSize(0);
    }
    void setValues(const tArrayIndex& n,const T* array,const tArrayIndex& fromIndex); 

    inline void setValues(const tArrayIndex& n,const T* array) {
        setValues(n,array,0);
    }

    inline void setValuesByReference(const tArrayIndex& n,T*& array,const tBoolean& hasToBeDeleted) {
        if ((mVector!=null) && (mHasToBeDeleted)) delete[] mVector;
        mVector=array;
        mCVector=mVector;
        mCapacity=n;
        mSize=n;
        mStartIndex=0;
        mHasToBeDeleted=hasToBeDeleted;
    }
    

    void setValues(const vector<T>& array,const tArrayIndex& fromIndex);
    
    inline void setValues(const vector<T>& array) {
        setValues(array,0);
    } 
    void setValues(const tString& str,const tArrayIndex& fromIndex);
    void setValues(const tString& str) {
        setValues(str,0);
    } 

    inline void set(const tArrayIndex& i,const T& obj) {
        ASSERT_IN(i<mSize);
        mCVector[i]=obj;
    };
    inline void setValue(const tArrayIndex& i,const T& obj){
        set(i,obj);
    };
    inline void initValues(const T& v) {
        for (tArrayIndex i=0;i<mSize;i++) 
            mCVector[i]=v;
    };
    
    void resize(); 
    void resize(const tArrayIndex & n);
    
    void contractToLastElements(const tArrayIndex& n);
    
public:
    inline const T* getValues(tArrayIndex& s) const {
        s=mSize;
        return mCVector;
    };
    inline const T* getValues() const {
        tArrayIndex s=0;
        return getValues(s);
    };
    inline T* getValues()  {
        tArrayIndex s=0;
        return getValues(s);
    }; 
    inline T* getValues(tArrayIndex& s) {
        s=mSize;
        return mCVector;
    };  

    inline const T* getCompleteValues(tArrayIndex& s) const {
        s=mCapacity;
        return mVector;
    }; 
 
    inline T* getCompleteValues(tArrayIndex& s) {
        s=mCapacity;
        return mVector;
    };  
 
   

public:
    // -----------------
    // ADDING Methods
    // -----------------
    
    void addAfterIndex(const tArrayIndex& index,const T& v);
  
    void addAfterIndices(const CORE_Array<tArrayIndex>& indices,
                         CORE_SharedPointersList<CORE_Array <T> >& values);

   
    tArrayIndex insert(const tArrayIndex& i,const T& obj);
 
    tArrayIndex insertInOrder(const T& obj,const tBoolean& evenIfEqual); 
    inline tArrayIndex insert(const T& obj){
        return insertInOrder(obj,false);
    };
 
    void add(const T& obj);
   
  
    void merge(const CORE_Array<T>& array);
    
    inline void append(const CORE_Array<T>& array) {merge(array);};

    // ----------------
    // REMOVING methods
    // ----------------
    
    tBoolean remove(const T& obj);

    tBoolean removeAtIndex(const tArrayIndex& i);
  
    inline tBoolean remove() {
        tArrayIndex n=size();
        if (n==0) return false;
        return removeAtIndex(n-1);
    }
    virtual void clear(){
        setSize(0);
    };
    
    // -----------------
    // ITERATOR methods
    // ----------------
    
    tBoolean getIndex(const T& v,tArrayIndex& index) const; 
    tBoolean getInfIndex(const T& v,tArrayIndex& index) const; 
    tBoolean getSupIndex(const T& v,tArrayIndex& index) const;  
    
    
    inline tBoolean exists(const T& obj) const { 
        for (tArrayIndex i=0;i<mSize;i++) {
            if (mCVector[i]==obj) {
                return true;
            }
        }
        return false;
    }

    // other METHODS
  
    void reverse();


    static tBoolean search(const T* values, const tArrayIndex& n,
                           const T& value,const tString& order,tArrayIndex& index);
    
    int search(const T& value,const tString& order) {
        return search(mCVector,mSize,value,order);
    }
    
    inline void sort() {
        sort(mCVector,mSize,">");
    };
    inline void sort(const tString& order) {
        sort(mCVector,mSize,order);
    };
    static void sort(T*& items,const tArrayIndex& N,
                     const tString& order);
    // -------------
    // PRINT Methods
    // -------------
  
    tString toString() const; 


    // ------------------------
    // Mathematiocal operation
    // ------------------------
 
    inline T norm2() const {
        T s=(T) 0;
        T aux;
        for (tArrayIndex i=0;i<mSize;i++) {
            aux=mCVector[i];
            s+=aux*aux;
        }
        return s;
    }
    inline T norm() const{
        return sqrt(norm2());
    };
    inline T distance2(const CORE_Array<T>& y) const {
        T s=(T) 0;
        T d;
        tArrayIndex n=mSize;
        for (tArrayIndex i=0;i<n;i++) {
            d=mCVector[i]-y[i];
            s+=d*d;
        }
        return s;
    };
    inline T distance(const CORE_Array<T>& y) const{
        return sqrt(distance2(y));
    };
  
 
};

#include "CORE_Array.hpp"

typedef CORE_Array<double> CORE_DoubleArray;
typedef CORE_Array<tCharacter> CORE_CharacterArray;
typedef CORE_Array<int> CORE_IntArray;
typedef CORE_Array<tBoolean> CORE_BooleanArray;
typedef CORE_Array<tReal> CORE_RealArray;
typedef CORE_Array<tComplex> CORE_ComplexArray;
typedef CORE_Array<tDoubleComplex> CORE_DoubleComplexArray;
typedef CORE_Array<tFlag> CORE_FlagArray;
typedef CORE_Array<tShort> CORE_ShortArray;
typedef CORE_Array<tString> CORE_StringArray;
typedef CORE_Array<tInteger> CORE_IntegerArray;
typedef CORE_Array<tRelativeInteger> CORE_RelativeIntegerArray;
typedef CORE_Array<tLong> CORE_LongArray;


TYPEDEF_SPTR(CORE_DoubleArray);
TYPEDEF_SPTR(CORE_BooleanArray);
TYPEDEF_SPTR(CORE_CharacterArray);
TYPEDEF_SPTR(CORE_IntArray);
TYPEDEF_SPTR(CORE_RealArray);
TYPEDEF_SPTR(CORE_ComplexArray);
TYPEDEF_SPTR(CORE_FlagArray);
TYPEDEF_SPTR(CORE_RelativeIntegerArray);
TYPEDEF_SPTR(CORE_IntegerArray);
TYPEDEF_SPTR(CORE_StringArray);
TYPEDEF_SPTR(CORE_ShortArray);
TYPEDEF_SPTR(CORE_LongArray);

TYPEDEF_SVPTR(CORE_DoubleArray)
TYPEDEF_SVPTR(CORE_BooleanArray);
TYPEDEF_SVPTR(CORE_CharacterArray);
TYPEDEF_SVPTR(CORE_IntArray);
TYPEDEF_SVPTR(CORE_RealArray);
TYPEDEF_SVPTR(CORE_ComplexArray);
TYPEDEF_SVPTR(CORE_FlagArray);
TYPEDEF_SVPTR(CORE_RelativeIntegerArray);
TYPEDEF_SVPTR(CORE_IntegerArray);
TYPEDEF_SVPTR(CORE_StringArray);
TYPEDEF_SVPTR(CORE_ShortArray);
#endif