MMSD_DataSet.h

Go to the documentation of this file.

#ifndef MMSD_DataSet_H
#define MMSD_DataSet_H


#include "MMSD_Object.h"

#include "CORE_Array.h"
#include "MMSD_DoubleFullMatrix.h"
#include "MMSD_IntegerVector.h"
#include "CORE_Integer.h"

DEFINE_SPTR(MMSD_DataSet);
class MMSD_DataSet : public virtual MMSD_Object {
    SP_OBJECT(MMSD_DataSet);
    // ATTRIBUTES
  
private:
  
    
    static const tFlag STRING_TYPE;
    static const tFlag REAL_TYPE;
    
    int mSamplesNumber;
    
    // ASSOCIATIONS
    // poperties name
    CORE_StringArray mPropertiesName;
    
    // property index of the property in the property values list 
    CORE_IntArray mPropertiesIndex;
    
    // type of the property at index
    CORE_FlagArray mPropertiesType;
    
    // values of double properties
    SP::MMSD_DoubleFullMatrix mProperties;
    
    // value of string properties
    SV::CORE_StringArray mStringProperties;


    
  
    
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MMSD_DataSet(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~MMSD_DataSet(void);   
  
  
  
public:
    //----------------
    // NEW constructors
    // ---------------
    inline static SP::MMSD_DataSet New() {
        SP::MMSD_DataSet p(new MMSD_DataSet(),
                          MMSD_DataSet::Delete());
        p->setThis(p);
        return p;
    };
    

    // -----------------
    // SET & GET Methods
    // -----------------

  
    inline int getTotalPropertiesNumber() const {
        return mPropertiesName.getSize();
    };
    
    inline int getPropertiesNumber() const {
        return mProperties->getColumnsNumber();
    };
    inline tLVectorIndex  getSamplesNumber() const {
        return mSamplesNumber;
    };

    inline int getPropertyIndex(const tString& name) const {
      
        int i,n=mPropertiesName.getSize();
        for (i=0;i<n;i++) {
            if (mPropertiesName[i].compare(name)==0) return i;
        }
        return -1;
    };
    inline tString getStringProperty(const tString& name,const int& sampleIndex) const {
        ASSERT_IN(sampleIndex<mSamplesNumber);
        int propIndex=getPropertyIndex(name);
        if (propIndex==-1) return "";
        if (mPropertiesType[propIndex]!=STRING_TYPE) return "";
        return mStringProperties(mPropertiesIndex[propIndex])[sampleIndex];
    };
    inline tString getStringProperty(const int& index,const int& sampleIndex) const {
        ASSERT_IN(sampleIndex<mSamplesNumber);
        ASSERT_IN(index<getPropertiesNumber());
        return mStringProperties(mPropertiesIndex[index])[sampleIndex];
    };
    
    inline double getProperty(const tString& name,const int& sampleIndex) const {
        ASSERT_IN(sampleIndex<mSamplesNumber);
        int propIndex=getPropertyIndex(name);
        if (propIndex==-1) return 0;
        if (mPropertiesType[propIndex]!=REAL_TYPE) return 0;
        return (*mProperties.get())(sampleIndex,mPropertiesIndex[propIndex]);
    };
    inline double getProperty(const int& index,const int& sampleIndex) const {
        ASSERT_IN(sampleIndex<mSamplesNumber);
        ASSERT_IN(index<getPropertiesNumber());
        return (*mProperties.get())(sampleIndex,mPropertiesIndex[index]);
    };

    inline const MMSD_DoubleFullMatrix& getProperties() const {
        return *mProperties.get();
    };
    inline void getProperties(SPC::MMSD_DoubleFullMatrix& y) const {
        y=mProperties;
    };
  

    inline void setProperties(const int& n,const int& p,const double* values) {
        mSamplesNumber=n;
        mProperties->setValues(n,p,values);
        mPropertiesName.setSize(p);
        mPropertiesIndex.setSize(p);
        mPropertiesType.setSize(p);
        for (int i=0;i<p;i++) {
            mPropertiesName[i]="";
            mPropertiesIndex[i]=i;
            mPropertiesType[i]=REAL_TYPE;
        }
    };

    void scale();


    // ---------------------------
    // LOADER & SAVER FILE METHODS
    // ----------------------------

    inline tBoolean load(const tString& file) {
        vector<tString> names;
        return load(file,names);
    }

    
    tBoolean load(const tString& file,const vector<tString>& names);
  
    
    inline tBoolean load(const tString& file,const vector<int>& indices) {
        vector<tString>  names;
        int n=indices.size();
        for (int i=0;i<n;i++) names.push_back(CORE_String::toString(indices[i]));
        return load(file,names);        
    }
    

private:
    int  loadCSVFile(const tString& file,const vector<tString>& names);
    
    int  loadTXTFile(const tString& file,const vector<tString>& names);
    

private:
    tBoolean saveTXTFile(const tString& file,const int& ndigits) const;
    tBoolean saveCSVFile(const tString& file,const int& ndigits) const;

public:
    tBoolean save(const tString& file,const int& ndigits) const;
    inline tBoolean save(const tString& file) const {
        return save(file,12);
    }

    // ------------------------------
    // SAVER & LOADER for UI class
    // ------------------------------
    virtual void saveToUIClass(UI_Class& mclass) const;

    virtual void loadFromUIClass(const UI_Class& mclass);
 
    // ----------------------
    // String representation
    // ----------------------

    virtual tString toString() const {
        tString ret="";
        ret+="Properties:";
        if (mProperties.get()!=null) ret+=mProperties->toString()+"\n";
        else ret+="null\n";
        return ret;
    }
    
    
};

#endif