MM_Structure.h

Go to the documentation of this file.

#ifndef MM_Structure_H
#define MM_Structure_H

#include "UI_Class.h"
#include "MM_Data.h"
#include "MM_Class.h"
#include "MM_Attribute.h"
#include "CORE_Exception.h"

DEFINE_SPTR(MM_Structure);
class MM_Structure : public virtual UI_Class {
    SP_OBJECT(MM_Structure);
    // ATTRIBUTES
  
private:
 
   
  
    // ASSOCIATIONS
    SP::MM_Data mData;
    
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MM_Structure(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~MM_Structure(void);   
  
    
  
public:
    //----------------
    // NEW constructors
    // ---------------

    inline static SP::MM_Structure New() {
        SP::MM_Structure p(new MM_Structure(),
                           MM_Structure::Delete());
        p->setThis(p);
        return p;
    };
    virtual SP::UI_Class NewInstance() const {
        return New();
    };
    // -----------
    // DATA setting
    // ------------
    inline void setData(SP::MM_Data data) {
        mData=data;
    };
   
    inline SP::MM_Data getData() const {
        return mData;
    };
  


    // -----------------------
    // Data Type verification
    // -----------------------
     
    /*\brief  verify the data of the class is a boolean scalar
     */
    virtual tBoolean isBoolean(tBoolean& isVector) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return data->isBoolean();
    }

    
    /*\brief  verify the data of the class is double vector
     */
    virtual tBoolean isChar(tBoolean& isVector,tBoolean& isUnsigned) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return data->isChar(isUnsigned);
    };
    /*\brief  verify the data of the class is double vector
     */
    virtual tBoolean isShortInt(tBoolean& isVector,tBoolean& isUnsigned) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return data->isShortInt(isUnsigned);
    };  
    /*\brief  verify the data of the class is double vector
     */
    virtual tBoolean isInt(tBoolean& isVector,tBoolean& isUnsigned) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return data->isInt(isUnsigned);
    };
    /*\brief  verify the data of the class is double vector
     */
    virtual tBoolean isLongInt(tBoolean& isVector,tBoolean& isUnsigned) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return data->isLongInt(isUnsigned);
    };
    /*\brief  verify the data of the class is double vector
     */
    virtual tBoolean isLongLongInt(tBoolean& isVector,tBoolean& isUnsigned) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return data->isLongLongInt(isUnsigned);
    };

    /*\brief  verify the data of the class is double vector
     */
    virtual tBoolean isFloat(tBoolean& isVector) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return (data->isFloat());
    }
    /*\brief  verify the data of the class is double vector
     */
    virtual tBoolean isDouble(tBoolean& isVector) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return (data->isDouble());
    }
    /*\brief  verify the data of the class is double vector
     */
    virtual tBoolean isLongDouble(tBoolean& isVector) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return (data->isLongDouble());
    }
    
    /*\brief  verify the data of the class is a string vector
     */
    virtual tBoolean isString(tBoolean& isVector) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        isVector=data->isVector();
        return data->isString(); 
    }
    

    /*\brief  verify that the data is double full maxtrix
     */
    virtual tBoolean isDoubleFullMatrix() const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        if (data==null) return false;
        return (data->isDouble() && data->isMatrix());
    };
    

    
    virtual tBoolean isClass()  const {
        const MM_Class *data=dynamic_cast<const MM_Class*>(mData.get());
        return  (data!=null);
     
    }
    virtual tBoolean hasField(const tString& field)  const {
        const MM_Class *data=dynamic_cast<const MM_Class*>(mData.get());
        if (data==null) return false;
        return data->hasField(field);
    };
    virtual tBoolean hasFields(const vector<tString>& fields)  const {
        const MM_Class *data=dynamic_cast<const MM_Class*>(mData.get());
        if (data==null) return false;
        int nFields=fields.size();
        for (int i=0;i<nFields;i++) {
            if (!data->hasField(fields[i])) return false;
        }
        return true;
    };
  
    
    // -------------------------
    // Scalar Conversion methods
    // -------------------------

       
    virtual tBoolean  getString(tString& name) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        return (data->getValue(name));
    }
    
    virtual tBoolean  getScalar(tBoolean& value) const {
        tBoolean isVector=false;
        isString(isVector);
        if (isVector) return false;
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        data->getValue(value);
        return true;
    }
    virtual tBoolean  getScalar(char& value) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        data->getValue(value);
        return true;
    }
    virtual tBoolean  getScalar(unsigned char& value) const {
        
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        data->getValue(value);
        return true;
    }
    virtual tBoolean  getScalar(int& value) const {
      
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        data->getValue(value);
        return true;
    }
    virtual tBoolean  getScalar(short int& value) const {
        
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        data->getValue(value);
        return true;
    }
    virtual tBoolean  getScalar(long int& value) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
       
        data->getValue(value);
        return true;
    }
    virtual tBoolean  getScalar(long long int& value) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
       
        data->getValue(value);
        return true;
    }
    virtual tBoolean  getScalar(unsigned long long int& value) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
       
        data->getValue(value);
        return true;
    }
    virtual tBoolean  getScalar(unsigned long int & value) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
       
        data->getValue(value);
        return true;
    }
   
    virtual tBoolean  getScalar(double& value) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
       
        data->getValue(value);
        return true;
    }
    
    virtual tBoolean  getScalar(long double& value) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        data->getValue(value);
        return true;
    }
   
    
    // -------------------------
    // Vector Conversion methods
    // -------------------------
    
    virtual tBoolean  getVector(vector<tString>& names) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        return data->getValue(names);
    };
   
       
    virtual tBoolean  getVector(int& n,tString*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false;
        if (!isString(isVector)) return false;
        if (!isVector) return false;
        if (isCopied) {
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const tString*&) value);
    };
    
    virtual tBoolean  getVector(int& n,bool*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false;
        tBoolean isBool=isBoolean(isVector);
        if (!isVector) return false;
        if (isCopied || !isBool) {
            isCopied=true;
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const bool*&) value);
    };
            
    virtual tBoolean  getVector(int& n,unsigned char*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false,isUnsigned=false;
        tBoolean isTypeOk=isChar(isVector,isUnsigned);
        if (!isVector) return false;
        if (!isUnsigned) return false;
        if (isCopied || !isTypeOk) {
            isCopied=true;
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const unsigned char*&) value);
    };
    
    virtual tBoolean  getVector(int& n,unsigned int*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false,isUnsigned=false;
        tBoolean isTypeOk=isInt(isVector,isUnsigned);
        if (!isVector) return false;
        if (!isUnsigned) return false;
        if (isCopied || !isTypeOk) {
            isCopied=true;
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const unsigned int*&) value);
    };
    
    virtual tBoolean  getVector(int& n,int*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false,isUnsigned=false;
        tBoolean isTypeOk=isInt(isVector,isUnsigned);
        if (!isVector) return false;
        if (isUnsigned) return false;
        if (isCopied || !isTypeOk) {
            isCopied=true;
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const int*&) value);
    };
    virtual tBoolean  getVector(int& n,unsigned long int*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false,isUnsigned=false;
        tBoolean isTypeOk=isLongInt(isVector,isUnsigned);
        if (!isVector) return false;
        if (!isUnsigned) return false;
        if (isCopied || !isTypeOk ) {
            isCopied=true;
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const unsigned long int*&) value);
    };
    virtual tBoolean  getVector(int& n,long int*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false,isUnsigned=false;
        tBoolean isTypeOk=isLongInt(isVector,isUnsigned);
        if (!isVector) return false;
        if (isUnsigned) return false;
        if (isCopied || !isTypeOk ) {
            isCopied=true;
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const long int*&) value);
    };
    virtual tBoolean  getVector(int& n,long long int*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false,isUnsigned=false;
        tBoolean isTypeOk=isLongLongInt(isVector,isUnsigned);
        if (!isVector) return false;
        if (isUnsigned) return false;
        if (isCopied || !isTypeOk ) {
            isCopied=true;
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const long long int*&) value);
    };
   
    virtual tBoolean  getVector(int& n,double*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false;
        tBoolean isTypeOk=isDouble(isVector);
        if (!isVector) return false;
        if (isCopied || !isTypeOk ) {
            isCopied=true;
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const double*&) value);
    };
    
    virtual tBoolean  getVector(int& n,long double*& value,tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isVector=false;
        tBoolean isTypeOk=isLongDouble(isVector);
        if (!isVector) return false;
        if (isCopied || !isTypeOk ) {
            isCopied=true;
            return data->getValue(n,value);
        }
        else return data->getValue(n,(const long double*&) value);
    };
  
    virtual tBoolean  getFullMatrix(int& nRows,int& nCols,
                                    double*& value,
                                    tBoolean& isCopied) const {
        const MM_Attribute *data=dynamic_cast<const MM_Attribute*>(mData.get());
        tBoolean isTypeOk=isDoubleFullMatrix();
        int n=0;
        if (isCopied || !isTypeOk ) {
            isCopied=true;
            return data->getValue(nRows,nCols,n,(double*&)value);
        }
        else return data->getValue(nRows,nCols,n,(const double*&)value);
        
    };

  
    // ------------------------------
    // attributes Creation method
    // ------------------------------
    void createValue(const tString& type,
                     const tString& card,
                     const tString& value,
                     const tString& separator,const tString& start,const tString& end) {
        SP::MM_Attribute data=MM_Attribute::New();
        data->setValue(type,card,value,separator,start,end);
        mData=data;
    }
    
 
    
    virtual void createString(const tString& value);
    virtual void createScalar(const unsigned char& value);
    virtual void createScalar(const short int& value);
    virtual void createScalar(const unsigned int& value);
    virtual void createScalar(const int& value);
    virtual void createScalar(const long int& value);
    virtual void createScalar(const long long int& value);
    virtual void createScalar(const unsigned long long int& value);  
    virtual void createScalar(const tBoolean& value);
    virtual void createScalar(const double& value);
    virtual void createScalar(const long double& value);

    virtual double *createDoubleVector(const int& n);
    virtual int *createIntVector(const int& n);

    virtual void createVector(const vector<tString>& values);

    virtual void createVector(const vector<bool>& values);
    virtual void createVector(const vector<unsigned char>& values);
    virtual void createVector(const vector<int>& values);
    virtual void createVector(const vector<double>& values);
    virtual void createVector(const vector<long double>& values);
    
    virtual void createVector(const int& n,const tString* values) {
        createVector(n,values,true);
    }
    virtual void createVector(const int& n,const tBoolean* values) {
        createVector(n,values,true);
    }
    /* size of values must be n
     */
    virtual void createVector(const int& n,const unsigned char* values) {
        createVector(n,values,true);
    }
    /* size of values must be n
     */
    virtual void createVector(const int& n,const unsigned int* values) {
        createVector(n,values,true);
    }
    /* size of values must be n
     */
    virtual void createVector(const int& n,const int* values) {
        createVector(n,values,true);
    }
    virtual void createVector(const int& n,const long int* values) {
        createVector(n,values,true);
    };
    virtual void createVector(const int& n,const long long int* values) {
        createVector(n,values,true);
    };
  
    virtual void createVector(const int& n,const double* values) {
        createVector(n,values,true);
    }
  
    virtual void createVector(const int& n,const long double* values) {
        createVector(n,values,true);
    }
 
  
    virtual void createVector(const int& n,const tString*& values,const tBoolean& isCopied);
    virtual void createVector(const int& n,const tBoolean*& values,const tBoolean& isCopied);
   
    virtual void createVector(const int& n,const unsigned char*& values,const tBoolean& isCopied);
    virtual void createVector(const int& n,const unsigned int*& values,const tBoolean& isCopied);
    virtual void createVector(const int& n,const int*& values,const tBoolean& isCopied);
    virtual void createVector(const int& n,const long int*& values,const tBoolean& isCopied);
    virtual void createVector(const int& n,long int*& values,const tBoolean& isCopied) {
        createVector(n,(const long int *&) values,isCopied);
    };
    virtual void createVector(const int& n,const long long int*& values,const tBoolean& isCopied);
    virtual void createVector(const int& n,long long int*& values,const tBoolean& isCopied) {
        createVector(n,(const long long int *&) values,isCopied);
    };
  
    virtual void createVector(const int& n,const double*& values,const tBoolean& isCopied);
    virtual void createVector(const int& n,const long double*& values,const tBoolean& isCopied);
  
    virtual void createFullMatrix(const int& nRows,const int& nCols,const double* values,tBoolean& isCopied);
        
    virtual double *createFullMatrix(const int& nRows,const int& nCols);
  
   

    // -----------------
    // class creation
    // -----------------
    virtual void createClass(const tString& id);
   

    virtual tBoolean createClass(const tString& id,CORE_SharedPointersVMap<tString,UI_Class> &fields) {
        return UI_Class::createClass(id,fields);
    }
    
    virtual void createClassesList(const tString& fieldName,const tBoolean& isComposite,const int& n);
  
  
    
    
    virtual tBoolean setClassIntoList(const tString& fieldName,const int& index,UI_Class& fieldValue);
    
    
    virtual tBoolean setField(const tString& fieldName,const tBoolean& isComposite,UI_Class& fieldValue);
    virtual tBoolean setField(const tString& fieldName,UI_Class& fieldValue) {
        return setField(fieldName,true,fieldValue);
    };
    
    
   
    // -------------
    // Get Class  fields
    // --------------
    virtual void getFieldNames(vector<tString>& fields) const {
        MM_Class *data=dynamic_cast<MM_Class*>(mData.get());
        if (data==null) return ;
        return data->getFieldNames(fields);
    }
    virtual tString getClassName() const {
        MM_Class *data=dynamic_cast<MM_Class*>(mData.get());
        if (data==null) return "";
        return data->getClassId();
    };
    
    virtual int getClassesListSize(const tString& name) const {
        const MM_Class *data=dynamic_cast<const MM_Class*>(mData.get());
        if (data==null) return 0;
        return data->getAssociationCardinality(name);
    }

    virtual tBoolean getClassFromList(const tString& name,const int& index,UI_Class& uiClass)  const {
        // get the class
        MM_Class *data=dynamic_cast<MM_Class*>(mData.get());
        if (data==null) return false;
        
        // get the class at index 
        SP::MM_Data value=data->getAssociation(name,index);
        
        // set the data
        MM_Structure *mmClass=dynamic_cast< MM_Structure *>(&uiClass);
        if (mmClass==null) return false;
        mmClass->setData(value);
        return (value.get()!=null);
    }
    virtual tBoolean getField(const tString& field,UI_Class& uiClass) const {
        // get the class
        MM_Class *data=dynamic_cast<MM_Class*>(mData.get());
        if (data==null) return false;
        
        // get the class
        SP::MM_Data value=data->getField(field);
        
        // set the data
        
        MM_Structure *mmClass=dynamic_cast< MM_Structure *>(&uiClass);
        if (mmClass==null) return false;
        mmClass->setData(value);
        return (value.get()!=null);
    }
  
  
     // -------------
    // print methods
    // -------------
    virtual void printErrorMessage(const tString& msg) const {      
        throw CORE_Exception("ui/metamodel","MM_Structure",msg);
    };

    virtual void printMessage(const tString& msg) const {
        cout << msg.c_str() << "\n";
    };

    virtual tString toString() const {
        return mData->toString();
    }
};

#endif