MATH_MaskArrayVector.h

Go to the documentation of this file.

#ifndef MATH_MaskArrayVector_H
#define MATH_MaskArrayVector_H

#include "MATH_MaskVector.h"

#include "CORE_Array.h"


DEFINE_SPTR(MATH_MaskArrayVector);

class MATH_MaskArrayVector : public MATH_MaskVector {
    SP_OBJECT(MATH_MaskArrayVector);

private:
    
    CORE_RealArray mArray;
    
protected:
    MATH_MaskArrayVector(void) {
        
    }
    
    
    
    // DESTRUCTORS 
    
  
    virtual ~MATH_MaskArrayVector(void) {
    }

public:
    inline static SP::MATH_MaskArrayVector New() {
        SP::MATH_MaskArrayVector p(new MATH_MaskArrayVector(),MATH_MaskArrayVector::Delete());
        p->setThis(p);
        return p;
    }
    virtual SP::MATH_Vector NewInstance() const  {
        return New();
    }



    //operators
    //==========
    inline MATH_MaskArrayVector& operator=(const MATH_Vector& v) {
        copy(v);
        return *this;
    }
    inline MATH_MaskArrayVector& operator=(const tReal&  v) {
        init(v);
        return *this;
    }
   inline MATH_MaskArrayVector& operator+=(const MATH_Vector&  v) {
        add(v);
        return *this;
    }

    inline MATH_MaskArrayVector& operator*=(const tReal&  v) {
        dot(v);
        return *this;
    }
    
    virtual tReal& operator[](const tUIndex& i) {
        return mArray[i];
       
    }
    virtual const tReal& operator[](const tUIndex& i) const {
        return mArray[i];
    }
    virtual const tReal& operator()(const tUIndex& i) const {
        return mArray[getStartIndex()+i*getIncrement()];
       
    }
    virtual tReal& operator()(const tUIndex& i) {
        return mArray[getStartIndex()+i*getIncrement()];
       
    }
    
   
    //SET Methods
    //===========
    /* \brief copy method
     * @param c: vector to copy
     */
    virtual void copy(const MATH_Vector& v) {
        const MATH_MaskArrayVector* av=dynamic_cast<const MATH_MaskArrayVector* >(&v);
        if (av!=null) {
            mArray.copy(av->getArray());
            
        }
        MATH_MaskVector::copy(v);
    }
    
    virtual tUIndex getSize() const {
        return mArray.getSize()/getIncrement();
    }
    
    virtual void setSize(const tUIndex& n) {

        //set the size
        mArray.setSize(  n* getIncrement() );
    }
    virtual void setCapacity(const tUIndex& n) {
        mArray.setSize(n);
    }

    virtual void setValuesByReference(const tUIndex& n,tReal *Vs ) {
        mArray.setValuesByReference(n,Vs);
    }

    //GET Methods
    //===========
    virtual tULLInt getMemorySize() const {
        return mArray.getMemorySize()+MATH_Vector::getMemorySize();
    }
    inline const CORE_RealArray& getArray() const {
        return mArray;
    }
    inline CORE_RealArray& getArray()  {
        return mArray;
    }
    
    virtual const tReal* getValues() const {
        return &mArray[0];
    } 
    virtual tReal* getValues() {
        return &mArray[0];
    }

    
    virtual tUIndex getCapacity() const {
        return mArray.getSize();
    }


    //to string
    virtual tString toString() const {
        tString ret="full size:"+CORE_Integer::toString(mArray.getSize())+":"+mArray.toString()+"\n";
        tUIndex i,n=getSize();
        ret+="mask size:"+CORE_Integer::toString(n)+":";
        ret+="[";
        const tUSInt& inc=getIncrement();
        const tReal *vs=&getValues()[getStartIndex()];
        for (i=0;i<n;i++) {
            ret+=CORE_Real::toString(*vs)+",";
            vs+=inc;
        }
        ret+="]";
        return ret;
    }
  
    
    
  

    
};
#endif