GPM_Variable.h

Go to the documentation of this file.

#ifndef GPM_Variable_H
#define GPM_Variable_H

#include "GPM_Object.h"




DEFINE_SPTR(GPM_Variable);
DEFINE_SVPTR(GPM_Variable);
class GPM_Variable : public GPM_Object{
    SP_OBJECT(GPM_Variable);  
    // ATTRIBUTES

public:
  
    static const tFlag UNDEFINED;
    static const tFlag REAL;
    static const tFlag BOOLEAN;
    static const tFlag INTEGER;
    static const tFlag STRING;
    static const tFlag SINGLE;
    static const tFlag MULTIPLE;
private:

    tFlag mType;
    double *mValues;
    int mCardinality;
    tBoolean mIsGlobal;
    
    
protected:
    // METHODS
  
    // CONSTRUCTORS 
  
    GPM_Variable(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~GPM_Variable(void);
  
  
public:

    // NEW methods

    inline static SP::GPM_Variable New() {
        SP::GPM_Variable p(new GPM_Variable(),GPM_Variable::Delete());
        p->setThis(p);
        return p;
    }

    //operator
    const double& operator[](const int& i) const {
        ASSERT_IN(i<mCardinality);
        return mValues[i];
    }
    double& operator[](const int& i)  {
        ASSERT_IN(i<mCardinality);
        return mValues[i];
    }
    
    // SET & GET methods

    virtual void copy(const GPM_Variable& var);
    virtual void copy(SPC::GPM_Variable var) {
        if (var.get()!=null) copy(*var.get());
        else {
            resize(0);
        }
    }
    
    inline void setCardinality(const int& n) {
        resize(n);
    }
    inline void setType(const tFlag& t) {
        mType=t;
    }
    inline void setIsGlobal(const tBoolean& t) {
        mIsGlobal=t;
    }
    void setValue(const int& cardinality,const double* values,const tFlag& type);
    
    void setValue(const tString& value) {
        int l=value.size();
        resize(l);
        for (int i=0;i<l;i++) mValues[i]=(double) value[i];
        mType=STRING;
    }
    void setValue(const int& n,const double* value) {
        setValue(n,value,REAL);
    }
    void setValue(const double& value) {
        setValue(1,&value,REAL);
    }



    // GET
    
    inline int getCardinality() const {
        return mCardinality;
    }
    inline tFlag getType() const {
        return mType;
    }
    inline tBoolean isGlobal() const {
        return mIsGlobal;
    }
    
   
    inline void getValue(tString& values) const {
        values.resize(mCardinality);
        for (int i=0;i<mCardinality;i++) values[i]=(char) mValues[i];
    }
    inline void getValue(int& n,double* values) const {
        n=(n<mCardinality)?n:mCardinality;
        for (int i=0;i<n;i++) values[i]=mValues[i];
    }
    inline double getValue() const {
        if (mCardinality==0) return 0;
        return mValues[0];
    }
  

    // = TEST
    inline tBoolean isEqual(const GPM_Variable& var) const {
        return isEqual(var,1.e-12);
    }
    tBoolean isEqual(const GPM_Variable& var,const double& eps) const;
    
    tBoolean isEqual(const GPM_Variable* var) const {
        if (var==null) return false;
        return isEqual(*var);
    }
    tBoolean isEqual(const SPC::GPM_Variable var) const {
        if (var.get()==null) return false;
        return isEqual(*var.get());
    }

    // PARSING methods
    
    void parse(const tString& value);
    virtual tString toString() const;

private:
    void resize(const int& n);
    void desallocate();
};

#endif