UI_Class.h

Go to the documentation of this file.

#ifndef UI_Class_H
#define UI_Class_H

#include "UI_Object.h"
#include "CORE_Array2D.h"
#include "CORE_SharedPointersVMap.h"
#include "CORE_ListPointers.h"
#include "CORE_Map.h"
#include "CORE_Exception.h"

#include "CORE_ClassFactory.h"

DEFINE_SPTR(UI_Class);
class UI_Class : public virtual CORE_Object {
    SP_OBJECT(UI_Class);
    // ATTRIBUTES

    static const tFlag INTERFACE;
    static const tFlag BACKUP;
   
    
private:
 
    tBoolean mIsArrayCopied;
    tBoolean mInterfaceType;
    
    // ASSOCIATIONS
    
    WP::CORE_ClassFactory mFactory;
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    UI_Class(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~UI_Class(void);   
  
  
  
public:
    //----------------
    // NEW constructors
    // ---------------

   
    
    virtual SP::UI_Class NewInstance() const=0;

  


    /* \brief set the classes factory
     */
    inline void setFactory(SP::CORE_ClassFactory fact) {
        mFactory=fact;
    }
private:
    /* \brief get the classes factory
     */
    inline SP::CORE_ClassFactory getFactory() const {
        SP::CORE_ClassFactory f(mFactory.lock());
        return f;
    }
public:
    // -----------------------
    // Data Type verification
    // -----------------------

    inline void setInterfaceType(const tFlag& f) {
        mInterfaceType=f;
    }
    inline int getInterfaceType() const {
        return mInterfaceType;
    }
    inline void setIsArrayCopied(const tBoolean& v) {
        mIsArrayCopied=v;
    };

    inline tBoolean isArrayCopied() const {
        return mIsArrayCopied;
    }

    inline void setVersion(const tString& v) {
        if (v.compare("")!=0) saveField("version",v);
    };
    inline tString getVersion() const {
        tString v="";
        loadField("version",v);
        return v;
    };
    
   
    
    
    /*\brief  verify the data of the class is boolean
     * @param isVector is set to truie is the data is a vector, false if it is a scalar
     */
    virtual tBoolean isBoolean(tBoolean& isVector) const=0;
    
    /*\brief  verify the data of the class is char
     * @param isVector is set to truie is the data is a vector, false if it is a scalar
     * @param isUnsigned is the data is unsigned
     */
    virtual tBoolean isChar(tBoolean& isVector, tBoolean& isUnsigned) const=0;

    /*\brief  verify the data of the class is  short int
     * @param isVector is set to truie is the data is a vector, false if it is a scalar
     * @param isUnsigned is the data is unsigned
     */
    virtual tBoolean isShortInt(tBoolean& isVector, tBoolean& isUnsigned) const=0;
    
    /*\brief  verify the data of the class is  int
     * @param isVector is set to truie is the data is a vector, false if it is a scalar
     * @param isUnsigned is the data is unsigned
     */
    virtual tBoolean isInt(tBoolean& isVector, tBoolean& isUnsigned) const=0;

    /*\brief  verify the data of the class is  long int
     * @param isVector is set to truie is the data is a vector, false if it is a scalar
     * @param isUnsigned is the data is unsigned
     */
    virtual tBoolean isLongInt(tBoolean& isVector, tBoolean& isUnsigned) const=0;
    
    /*\brief  verify the data of the class is  long int
     * @param isVector is set to truie is the data is a vector, false if it is a scalar
     * @param isUnsigned is the data is unsigned
     */
    virtual tBoolean isLongLongInt(tBoolean& isVector, tBoolean& isUnsigned) const=0;
  
    /*\brief  verify the data of the class is an integer vector
     */
    virtual tBoolean isInteger(tBoolean& isVector,tBoolean& isUnsigned) const {
        return (isChar(isVector,isUnsigned) ||
                isShortInt(isVector,isUnsigned) ||
                isInt(isVector,isUnsigned) ||
                isLongInt(isVector,isUnsigned) ||
                isLongLongInt(isVector,isUnsigned)); 
        
    }
    
    /*\brief  verify the data of the class is  float
     * @param isVector is set to truie is the data is a vector, false if it is a scalar
     * @param isUnsigned is the data is unsigned
     */
    virtual tBoolean isFloat(tBoolean& isVector) const=0;
    
    /*\brief  verify the data of the class is  double
     * @param isVector is set to truie is the data is a vector, false if it is a scalar
     * @param isUnsigned is the data is unsigned
     */
    virtual tBoolean isDouble(tBoolean& isVector) const=0;

    /*\brief  verify the data of the class is  long double
     * @param isVector is set to truie is the data is a vector, false if it is a scalar
     * @param isUnsigned is the data is unsigned
     */
    virtual tBoolean isLongDouble(tBoolean& isVector) const=0;
     

    /*\brief  verify the data of the class is a string
     */
    virtual tBoolean isString(tBoolean& isVector) const =0;
    
 
    /*\brief  verify that the data class is double full maxtrix
     */
    virtual tBoolean isDoubleFullMatrix() const=0;
   
    
    virtual tBoolean isClass() const=0;
    virtual tBoolean hasField(const tString& field) const=0;
    
    virtual tBoolean hasFields(const vector<tString>& fields) const=0;
    
    virtual tString getClassName() const=0;
   

    // ------------------
    // Conversion methods
    // -------------------

    // ----------
    // GET SCALAR
    // ----------
    
    virtual tBoolean  getString(tString& name) const=0;
    
    virtual tBoolean  getScalar(tString& name) const {
        return getString(name);
    };
    
    virtual tBoolean  getScalar(tBoolean& value) const=0;
    
    virtual tBoolean  getScalar(char& value) const=0;
    virtual tBoolean  getScalar(unsigned char& value) const=0;
    
    virtual tBoolean  getScalar(short int& value) const=0;
    virtual tBoolean  getScalar(int& value) const=0;
    
    virtual tBoolean  getScalar(long int& value) const=0;

    virtual tBoolean  getScalar(long long int& value) const=0;

    virtual tBoolean  getScalar(unsigned long long int& value) const=0;

    
    virtual tBoolean  getScalar(double& value) const=0;
    
    virtual tBoolean  getScalar(long double& value) const=0;
    
     // ------------------------
    // GET Vector of pointers
    // -------------------------
    
   
    virtual tBoolean getVector(int& n,tString*& value,tBoolean& isCopied) const=0;
    
    virtual tBoolean getVector(int& n,bool*& value,tBoolean& isCopied) const=0;
    
    virtual tBoolean getVector(int& n,int*& value,tBoolean& isCopied) const=0;

    virtual tBoolean getVector(int& n,unsigned int*& value,tBoolean& isCopied) const=0;
    
    virtual tBoolean getVector(int& n,unsigned long int*& value,tBoolean& isCopied) const=0;

    virtual tBoolean getVector(int& n,unsigned char*& value,tBoolean& isCopied) const=0;
    
    virtual tBoolean getVector(int& n,long int*& value,tBoolean& isCopied) const=0;
    
    virtual tBoolean getVector(int& n,long long int*& value,tBoolean& isCopied) const=0;

    virtual tBoolean getVector(int& n,double*& value,tBoolean& isCopied) const=0;

    virtual tBoolean getVector(int& n,long double*& value,tBoolean& isCopied) const=0;
    
    // ----------
    // GET Vector
    // ----------
    
         
    virtual tBoolean  getVector(vector<tString>& name) const=0;

    virtual tBoolean  getVector(vector<bool>& value) const {
        int n;
        bool *values=null;
        tBoolean isCopied=false;
         tBoolean succeeds=getVector(n,values,isCopied);
        if (succeeds) {
            value.resize(n);
            for (int i=0;i<n;i++) value[i]=values[i];
             if (isCopied) delete[] values;
        }
        return succeeds;
    }
    virtual tBoolean  getVector(vector<unsigned char>& value) const {
        int n;
        int *values=null;
        tBoolean isCopied=false;
         tBoolean succeeds=getVector(n,values,isCopied);
        if (succeeds) {
            value.resize(n);
            for (int i=0;i<n;i++) value[i]=values[i];
             if (isCopied) delete[] values;
        }
        return succeeds;
    };
    
    virtual tBoolean  getVector(vector<int>& value) const {
        int n;
        int *values=null;
        tBoolean isCopied=false;
        tBoolean succeeds=getVector(n,values,isCopied);
        if (succeeds) {
            value.resize(n);
            for (int i=0;i<n;i++) value[i]=values[i];
            if (isCopied) delete[] values;
            
        }
        return succeeds;
    };
    
    virtual tBoolean  getVector(vector<double>& value) const {
        int n;
        double  *values=null;
        tBoolean isCopied=false;
        tBoolean succeeds=getVector(n,values,isCopied);
        if (succeeds) {
            value.resize(n);
            for (int i=0;i<n;i++) value[i]=values[i];
            if (isCopied) delete[] values;
        }
        return succeeds;
        
    };
    virtual tBoolean  getVector(vector<long double>& value) const {
        int n;
        long double  *values=null;
        tBoolean isCopied=false;
        tBoolean succeeds=getVector(n,values,isCopied);
        if (succeeds) {
            value.resize(n);
            for (int i=0;i<n;i++) value[i]=values[i];
            if (isCopied) delete[] values;
        }
        return succeeds;
        
    }

    // ----------
    // GET MATRIX
    // -----------
    
    
    virtual tBoolean  getFullMatrix(int& nRows,int& nCols,
                                    double*& value,
                                    tBoolean& isCopied) const=0;

    /* \brief get the full symmetric matrix stored as a vector of size nRows * nRows
     * @param nrows: is the number of rows ofthe matrix
     * the size of the value array is nRows * nRows
     */
    tBoolean getFullSymmetricMatrix(int& nRows,double*& value,tBoolean& isCopied) const {
        tBoolean succeeds=getVector(nRows,value,isCopied);
        nRows=sqrt(nRows);
        return succeeds;
    }
    /* \brief get the full symmetric matrix stored as a vector of size nRows*(nRows+1)/2
     * @param nrows: is the number of rows ofthe matrix
     * the size of the value array is nRows * (nRows+1)/2
     */
    tBoolean getPackedSymmetricMatrix(int& nRows,double*& value,tBoolean& isCopied) const {
        tBoolean succeeds=getVector(nRows,value,isCopied);
        nRows=(int)(((sqrt(1+8*nRows)-1.)/2.)+0.5);
        return succeeds;
    }
    template<class T>
    tBoolean getVector2D(CORE_Array2D<T>& array2D,tBoolean& isCopied) const {
      
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        tBoolean succeeds=true;

        int *rs=null;
        int nRows=0;
        getField("rows",*f.get());
        succeeds = succeeds && f->getVector(nRows,rs,isCopied);
        
        T* vs=null;
        int n=0;
        getField("values",*f.get());
        succeeds = succeeds && f->getVector(n,vs,isCopied);

        tBoolean toBeDeleted=true;
        if (!isCopied) {
            toBeDeleted=false;
        }
        
        array2D.setValues(n,vs,nRows,rs,toBeDeleted);
        
        return succeeds;
    };
    
    // ---------
    // GET LIST
    // ---------

    template<class T,class Q>
    tBoolean getPrimitiveMap(map<T,Q>& primitiveMap) const {


        vector<T> keys;
        vector<Q> values;
        // verify the class is a map one
        if (!hasField("keys")) return false;
        if (!hasField("values")) return false;

        // load the keys & values
        loadField("keys",keys);
        loadField("values",values);

        // set the map
        primitiveMap.clear();
        int n=keys.size();
        int m=values.size();
        n=(m<n)?m:n;
        for (int i=0;i<n;i++) {
            primitiveMap[keys[i]]=values[i];
        }
        // return value
        return true;
    };
    
  
    template<class T,class Q>
    tBoolean getPrimitiveMap(CORE_Map<T,Q>& primitiveMap) const {
        vector<T> keys;
        vector<Q> values;
        // verify the class is a map one
        if (!hasField("keys")) return false;
        if (!hasField("values")) return false;
        
        // load the keys & values
        loadField("keys",keys);
        loadField("values",values);
        
        // set the map
        primitiveMap.clear();
        int n=keys.size();
        int m=values.size();
        n=(m<n)?m:n;
        for (int i=0;i<n;i++) {
            primitiveMap.put(keys[i],values[i]);
        }
        // return value
        return true;
    };

   
    // ----------------
    // Scalar Creation method
    // ----------------
    virtual void createString(const tString& value)=0;
    virtual void createScalar(const tString& value) {
        createString(value);
    };
    virtual void createScalar(const unsigned char& value)=0;
    virtual void createScalar(const unsigned int& value)=0;
    virtual void createScalar(const short int& value)=0;
    virtual void createScalar(const int& value)=0;    
    virtual void createScalar(const long int& value)=0;
    virtual void createScalar(const long long int& value)=0;
    virtual void createScalar(const unsigned long long int& value)=0;  
    virtual void createScalar(const tBoolean& value)=0;
    virtual void createScalar(const double& value)=0;
    virtual void createScalar(const long double& value)=0;
    
   
    // ----------------
    // Vector Creation method
    // ----------------
    virtual double *createDoubleVector(const int& n)=0;
    virtual int *createIntVector(const int& n)=0;
    
    virtual void createVector(const vector<tString>& values)=0;

    
    virtual void createVector(const vector<tBoolean>& values)=0;
    
    virtual void createVector(const vector<unsigned char>& values)=0;
     
    virtual void createVector(const vector<int>& values)=0;
    
    virtual void createVector(const vector<double>& values)=0;
    
    virtual void createVector(const vector<long double>& values)=0;
   
    virtual void createVector(const int& n,const tString*& values,const tBoolean& isCopied)=0; 
    virtual void createVector(const int& n,const tBoolean*& values,const tBoolean& isCopied)=0;
    
    virtual void createVector(const int& n,const int*& values,const tBoolean& isCopied)=0; 
    
    virtual void createVector(const int& n,const unsigned char*& values,const tBoolean& isCopied)=0;
    
    virtual void createVector(const int& n,const long int*& values,const tBoolean& isCopied)=0;
    virtual void createVector(const int& n,const long long int*& values,const tBoolean& isCopied)=0;
    virtual void createVector(const int& n,const double*& values,const tBoolean& isCopied)=0;
    virtual void createVector(const int& n,const long double*& values,const tBoolean& isCopied)=0;

    virtual void createVector(const int& n,const tBoolean* values) {
        tBoolean isCopied=mIsArrayCopied;
        createVector(n,values,isCopied);
    };
    
    virtual void createVector(const int& n,const int* values){
        tBoolean isCopied=mIsArrayCopied;
        createVector(n,values,isCopied);
    };
    
    virtual void createVector(const int& n,const long int* values){
        tBoolean isCopied=mIsArrayCopied;
        createVector(n,values,isCopied);
    };
    virtual void createVector(const int& n,const double* values){
        tBoolean isCopied=mIsArrayCopied;
        createVector(n,values,isCopied);
    };
    virtual void createVector(const int& n,const long double* values){
        tBoolean isCopied=mIsArrayCopied;
        createVector(n,values,isCopied);
    };
    
    // ---------------
    // MATRIX creation
    // -----------------
    
    virtual void createFullMatrix(const int& nRows,const int& nCols,const double* values,tBoolean& isCopied)=0;
    virtual void createFullMatrix(const int& nRows,const int& nCols,const double* values) {
        tBoolean isCopied=true;
        createFullMatrix(nRows,nCols,values,isCopied);
    }
    virtual double *createFullMatrix(const int& nRows,const int& nCols)=0;
  
    virtual void createFullSymmetricMatrix(const int& nRows,const double* values,const tBoolean& isCopied) {
        int n=nRows*nRows;
        createVector(n,values,isCopied);
    }
    virtual void createFullSymmetricMatrix(const int& nRows,const double* values) {
        tBoolean isCopied=mIsArrayCopied;
        createFullSymmetricMatrix(nRows,values,isCopied);
    }
    
    
    virtual void createPackedSymmetricMatrix(const int& nRows,const double* values,const tBoolean& isCopied) {
        int n=nRows*(nRows+1)/2;
        createVector(n,values,isCopied);
    };
    virtual void createPackedSymmetricMatrix(const int& nRows,const double* values) {
        tBoolean isCopied=mIsArrayCopied;
        createPackedSymmetricMatrix(nRows,values,isCopied);
    };
    
  
    
    template<class T>
    void createVector2D(const CORE_Array2D<T>& array2D,const tBoolean& isCopied) {
        // create the class
        createClass(array2D.getClassName());
        saveField("values",array2D.getValuesNumber(),array2D.getValues(),isCopied);
        saveField("rows",array2D.getRowsNumber()+1,array2D.getRowIndices(),isCopied);
    };  
    template<class T>
    void createVector2D(const CORE_Array2D<T>& array2D) {
        tBoolean isCopied=mIsArrayCopied;
        createVector2D(array2D,isCopied);
    };


    // --------------
    // List creation
    // ---------------

    template<class T,class Q>
    void createPrimitiveMap(const map<T,Q>& primitiveMap) {
        
        // fill the struture
        typename::map<T,Q>::const_iterator iter=primitiveMap.begin();

        // get the keys & values
        vector<T> keys;
        vector<Q> values;
        while (iter!=primitiveMap.end()) {
            keys.push_back(iter->first);
            values.push_back(iter->second);
            iter++;
        }


        // save it in class
        createClass("map");
        saveField("keys",keys);
        saveField("values",values);
     
       
    };

    template<class T,class Q>
    void createPrimitiveMap(const CORE_Map<T,Q>& primitiveMap) {
        // get the keys
        vector<T> keys;
        vector<Q> values;
        primitiveMap.getKeys(keys);
        primitiveMap.getValues(values);
       
        // create the class with fields
        createClass(primitiveMap.getIdentityString());
        saveField("keys",keys);
        saveField("values",values);
    };
    

    // ------------------------
    // Class creation
    // ----------------------


    inline void saveClass(const UI_Object& obj) {
        SP::CORE_ClassFactory factory=getFactory();
        if (factory.get()==null) {
            factory=CORE_ClassFactory::New();
            setFactory(factory);
        }
        createClass(obj.getIdentityString());
        factory->addClass(obj.getIdentityString(),getThis());
        obj.saveToUIClass(*this);
        finalize();
    }
    virtual void createClass(const tString& id)=0;
    
    virtual tBoolean createClass(const tString& id,CORE_SharedPointersVMap<tString,UI_Class> &fields);
    
    
    virtual void createClassesList(const tString& fieldName,const tBoolean& isComposite,const int& n)=0;
  
    virtual tBoolean setClassIntoList(const tString& fieldName,const int& index,UI_Class& fieldValue)=0;
    
    
    virtual tBoolean setField(const tString& fieldName,const tBoolean& isComposite,UI_Class& fieldValue)=0;
    virtual tBoolean setField(const tString& fieldName,UI_Class& fieldValue) {
        tBoolean isCopied=mIsArrayCopied;
        return setField(fieldName,isCopied,fieldValue);
    };
    
    
    
    // -----------------------
    // Get Class Field
    // -----------------------
    
    virtual tBoolean getClassFromList(const tString& fieldName,const int& index,UI_Class& uiClass) const=0;
    
    virtual tBoolean getField(const tString& field,UI_Class& uiClass) const=0;
   
  
    
    virtual int getClassesListSize(const tString& fieldName) const=0;

    virtual void getFieldNames(vector<tString>& name) const=0;

   


    // -------------
    // print methods
    // -------------

    virtual void printErrorMessage(const tString& msg) const=0;

    virtual void printMessage(const tString& msg) const=0;

    // -----------------------
    // class loader attributes
    // -----------------------


    // ---------------------------------------------
    // load field (const tString& name, T& v) const
    // ---------------------------------------------

    inline tBoolean loadField(const tString& name,tString& v) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,bool & v) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    }; 
    inline tBoolean loadField(const tString& name,unsigned char & v) const {
        
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,char & v) const {
        
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,short & v) const {
        v=0;
        SP::UI_Class f=NewInstance();
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,int & v) const {

        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,long int & v) const {
        v=0;
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };
     inline tBoolean loadField(const tString& name,long long int & v) const {
         v=0;
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,unsigned long long int & v) const {
         v=0;
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };
    
    inline tBoolean loadField(const tString& name,double & v) const {
  
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };  
    inline tBoolean loadField(const tString& name,long double & v) const {
   
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getScalar(v);
        };
        return false;
    };

    
    // --------------------------------------------------------
    // load field (const tString& name, vector<T>& v) const
    // ----------------------------------------------------------
    inline tBoolean loadField(const tString& name,vector<tString>& v) const {

        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getVector(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,vector<tBoolean>& v) const {
   
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getVector(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,vector<unsigned char>& v) const {

        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getVector(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,vector<int>& v) const {
    
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getVector(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,vector<double>& v) const {
 
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getVector(v);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,vector<long double>& v) const {
  
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getVector(v);
        };
        return false;
    };
    
    template<class T>
    inline tBoolean loadField(const tString& name,
                              CORE_Array<T>& v) const {
        tBoolean isCopied=mIsArrayCopied;
        return loadField(name,v,isCopied);
            
    };
    
    template<class T>
    inline tBoolean loadField(const tString& name,
                              CORE_Array<T>& v,
                              tBoolean& isCopied) const {
        int n=0;
        T* vs=null;
        tBoolean isArrayCopied=false;
        tBoolean succeeds=loadField(name,n,vs,isArrayCopied);
        if (succeeds) {
            if (isCopied || isArrayCopied) {
                v.setValues(n,vs);
            } else {
                v.setValuesByReference(n,vs,false);
            }
        }
        return succeeds;
    };
    
    template<class T>
    inline tBoolean loadField(const tString& name,CORE_Array2D<T>& array2D,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getVector2D(array2D,isCopied);
        }
        return false;
    };
    template<class T>
    inline tBoolean loadField(const tString& name,CORE_Array2D<T>& array2D) const {
        tBoolean isCopied=mIsArrayCopied;
        return loadField(name,array2D,isCopied);
    };
    
    template<class T>
    inline tBoolean loadField(const tString& name,CORE_Vector<T>& v) const {
        vector<T> &vs=v.getValues();
        tBoolean succeeds=loadField(name,vs);
      
        return succeeds;
    };

    // --------------------------------------------------------------------
    // load field (const tString& name, int& n, T*& v, tBoolean& isCopied)
    // --------------------------------------------------------------------
    
    inline tBoolean loadField(const tString& name,int& n,tString *&v,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        n=0;
        if (getField(name,*f.get())) {
            return f->getVector(n,v,isCopied);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,int& n,tBoolean *&v,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        n=0;
        if (getField(name,*f.get())) {
            return f->getVector(n,v,isCopied);
        };
        return false;
    };  
    inline tBoolean loadField(const tString& name,int& n,unsigned char *&v,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        n=0;
        if (getField(name,*f.get())) {
            return f->getVector(n,v,isCopied);
        } 
        return false;
    };
    inline tBoolean loadField(const tString& name,int& n,int *&v,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        n=0;
        if (getField(name,*f.get())) {
            return f->getVector(n,v,isCopied);
        } 
        return false;
    };
     
    inline tBoolean loadField(const tString& name,int& n,unsigned long int  *&v,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        n=0;
        if (getField(name,*f.get())) {
            return f->getVector(n,v,isCopied);
        };
        return false;
    };
    inline tBoolean loadField(const tString& name,int& n,double *&v,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        n=0;
        if (getField(name,*f.get())) {
            return f->getVector(n,v,isCopied);
            
        };
        return false;
    };
     inline tBoolean loadField(const tString& name,int& n,long double *&v,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        n=0;
        if (getField(name,*f.get())) {
            return f->getVector(n,v,isCopied);
            
        };
        return false;
    };
   
    // ---------------------------------------------------
    // load field (const tString& name, int& n, T*& v)
    // ----------------------------------------------------
    
    inline tBoolean loadField(const tString& name,int& n,long double *&v) const { 
         tBoolean isCopied=mIsArrayCopied;
         return loadField(name,n,v,isCopied);
    };
    inline tBoolean loadField(const tString& name,int& n,double *&v) const {
         tBoolean isCopied=mIsArrayCopied;
         return loadField(name,n,v,isCopied);
    };
    inline tBoolean loadField(const tString& name,int& n,tString *&v) const {
         tBoolean isCopied=mIsArrayCopied;
         return loadField(name,n,v,isCopied);
    };
    inline tBoolean loadField(const tString& name,int& n,int *&v) const {
         tBoolean isCopied=mIsArrayCopied;
         return loadField(name,n,v,isCopied);
    };  
   
    // ---------------------------------------------------
    // load field (const tString& name, int& n, T*& v)
    // ----------------------------------------------------
    
    inline tBoolean loadField(const tString& name,const int& n,long double v[]) const { 
         tBoolean isCopied=false;
         int ns=n;
         long double *vs;
         tBoolean succeeds=loadField(name,ns,vs,isCopied);
         for (int i=0;i<n;i++) {
             v[i]=vs[i];
         }
         if (isCopied) delete[] vs;
         return succeeds;
    };
    inline tBoolean loadField(const tString& name,const int& n,double v[]) const { 
         tBoolean isCopied=false;
         int ns=n;
         double *vs;
         tBoolean succeeds=loadField(name,ns,vs,isCopied);
         for (int i=0;i<n;i++) {
             v[i]=vs[i];
         }
         if (isCopied) delete[] vs;
         return succeeds;
    };
    inline tBoolean loadField(const tString& name,const int& n,int v[]) const { 
         tBoolean isCopied=false;
         int ns=n;
         int *vs;
         tBoolean succeeds=loadField(name,ns,vs,isCopied);
         for (int i=0;i<n;i++) {
             v[i]=vs[i];
         }
         if (isCopied) delete[] vs;
         return succeeds;
    };
   
    // ---------------------------------------------------
    // load field (const tString& name, int& n, map or list & v)
    // ----------------------------------------------------
    template<class T,class Q>
    inline tBoolean loadField(const tString& name,map<T,Q>& primitiveMap) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getPrimitiveMap(primitiveMap);
        }
        return false;
    };
    template<class T,class Q>
    inline tBoolean loadField(const tString& name,CORE_Map<T,Q>& primitiveMap) const {
        primitiveMap.clear();
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        if (getField(name,*f.get())) {
            return f->getPrimitiveMap(primitiveMap);
        }
        return false;
    };
    // ---------------------------------------------------
    // load matrix field
    // ----------------------------------------------------
    inline tBoolean loadFullMatrixField(const tString& name,int& nRows,int& nCols,double*& values,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        nCols=0;nRows=0;
        if (getField(name,*f.get())) {
            return f->getFullMatrix(nRows,nCols,values,isCopied);
        }
        return false;
    }
    inline tBoolean loadFullMatrixField(const tString& name,int& nRows,int& nCols,double*& values) const {
        tBoolean isCopied=mIsArrayCopied;
        return loadFullMatrixField(name,nRows,nCols,values,isCopied);
    }
    inline tBoolean loadFullSymmetricMatrixField(const tString& name,int& nRows,double*& values,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        nRows=0;
        if (getField(name,*f.get())) {
            return f->getFullSymmetricMatrix(nRows,values,isCopied);
        }
        return false;
    }
    inline tBoolean loadFullSymmetricMatrixField(const tString& name,int& nRows,double*& values) const {
        tBoolean isCopied=mIsArrayCopied;
        return loadFullSymmetricMatrixField(name,nRows,values,isCopied);
    }
    inline tBoolean loadPackedSymmetricMatrixField(const tString& name,int& nRows,double*& values,tBoolean& isCopied) const {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        nRows=0;
        if (getField(name,*f.get())) {
            return f->getPackedSymmetricMatrix(nRows,values,isCopied);
        }
        return false;
    }
    inline tBoolean loadPackedSymmetricMatrixField(const tString& name,int& nRows,double*& values) const {
        tBoolean isCopied=mIsArrayCopied;
        return loadPackedSymmetricMatrixField(name,nRows,values,isCopied);
    }
    // -----------------------
    // class saver attributes
    // -----------------------

    // ---------------------------------------------
    // save field (const tString& name, const T& v)
    // ----------------------------------------------
    
    inline tBoolean saveField(const tString& name,const tString & v)  {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
  
    inline tBoolean saveField(const tString& name,const tBoolean & v)  {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
  
    inline tBoolean saveField(const tString& name,const char & v) {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    }; 
    inline tBoolean saveField(const tString& name,const unsigned char & v)  {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
    inline tBoolean saveField(const tString& name,const short int & v) {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
    inline tBoolean saveField(const tString& name,const int & v) {
       
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
    inline tBoolean saveField(const tString& name,const long int & v)  {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
    inline tBoolean saveField(const tString& name,const long long int & v)  {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
    inline tBoolean saveField(const tString& name,const unsigned long long int & v)  {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
    inline tBoolean saveField(const tString& name,const double & v)  {
        SP::UI_Class f=NewInstance();
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
    inline tBoolean saveField(const tString& name,const long double & v)  {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createScalar(v);
        setField(name,*f.get());
        return true;
    };
   
   
    // -----------------------------------------------------------
    // save field (const tString& name, const int& n,const T* v)
    // --------------------------------------------------------------
   
    template<class T>
    inline tBoolean saveField(const tString& name,const int& n, const T* v) {
        tBoolean isCopied=mIsArrayCopied;
        return saveField(name,n,v,isCopied);
   
    };
    template<class T>
    inline tBoolean saveField(const tString& name,const int& n, const T* v,const tBoolean& isCopied) {
        
        SP::UI_Class f=NewInstance();
        f->createVector(n,v,isCopied);
        setField(name,*f.get());
        return true;
    };
   
    // -----------------------------------------------------------
    // save field (const tString& name, const vector or map <T>& v)
    // --------------------------------------------------------------
   
    template<class T>
    inline tBoolean saveField(const tString& name,const vector<T>& v) {
        SP::UI_Class f=NewInstance();
        f->createVector(v);
        setField(name,*f.get());
        return true;
    };
    template<class T,class Q>
    inline tBoolean saveField(const tString& name,const map<T,Q>& primitiveMap) {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createPrimitiveMap(primitiveMap);
        setField(name,*f.get());
        return true;
    }
    // -----------------------------------------------------------
    // save field (const tString& name, const CORE_XXX<T>& v)
    // --------------------------------------------------------------
   
    template<class T>
    inline tBoolean saveField(const tString& name,const CORE_Array<T>& v) {
        tBoolean isCopied=mIsArrayCopied;
        int n=v.getSize();
        return saveField(name,n,v.getValues(),isCopied);
    };
    template<class T>
    inline tBoolean saveField(const tString& name,const CORE_Array2D<T>& v) {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createVector2D(v);
        setField(name,*f.get());
        return true;
    };
    
    template<class T>
    inline tBoolean saveField(const tString& name,const CORE_Vector<T>& v) {
        return saveField(name,v.getValues());
    };

    template<class T,class Q>
    inline tBoolean saveField(const tString& name,const CORE_Map<T,Q>& primitiveMap) {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createPrimitiveMap(primitiveMap);
        setField(name,*f.get());
        return true;
    }
    
   
   

    // -----------------
    // save matrix field
    // ------------------
    inline tBoolean createFullMatrixField(const tString& name,const int& nRows,const int& nCols) {
        SP::UI_Class f=NewInstance();
        //SP::UI_Class f=mField;
        f->createFullMatrix(nRows,nCols);
        setField(name,*f.get());
        return true;
    } 
    inline tBoolean saveFullMatrixField(const tString& name,const int& nRows,const int& nCols,const double* values) {
        SP::UI_Class f=NewInstance();
        tBoolean isCopied=mIsArrayCopied;
        //SP::UI_Class f=mField;
        f->createFullMatrix(nRows,nCols,values,isCopied);
        setField(name,*f.get());
        return true;
    } 
    inline tBoolean saveFullSymmetricMatrixField(const tString& name,const int& nRows,const double* values) {
        SP::UI_Class f=NewInstance();
        tBoolean isCopied=mIsArrayCopied;
        //SP::UI_Class f=mField;
        f->createFullSymmetricMatrix(nRows,values,isCopied);
        setField(name,*f.get());
        return true;
    }
    inline tBoolean savePackedSymmetricMatrixField(const tString& name,const int& nRows,const double* values) {
        SP::UI_Class f=NewInstance();
        tBoolean isCopied=mIsArrayCopied;
        //SP::UI_Class f=mField;
        f->createPackedSymmetricMatrix(nRows,values,isCopied);
        setField(name,*f.get());
        return true;
    }
    
    // ----------------
    // save & load association
    // ----------------
public:
    virtual void finalize() {
    };
    
    void  saveAssociation(const tString& name,const tBoolean& isComposite,const CORE_Object* obj);
   
    SP::CORE_Object loadAssociation(const tString& name,const tBoolean& isComposite) const;
    
    inline void  saveAssociation(const tString& name,const CORE_Object* obj) {
        saveAssociation(name,true,obj);
    }
    inline SP::CORE_Object loadAssociation(const tString& name) const {
        return loadAssociation(name,true);
    }
    
    template<class T>
    void  saveAssociation(const tString& name,const boost::shared_ptr<T>& obj) {
        saveAssociation(name,true,obj.get());
    }
    template<class T>
    void loadAssociation(const tString& name,boost::shared_ptr<T>& object) const {
        object=dynamic_sp_cast<T>(loadAssociation(name,true));
    }
    
    template<class T>
    void  saveAssociation(const tString& name,const boost::weak_ptr<T>& obj) {
        SPC::CORE_Object l_obj(obj.lock());
        if (l_obj) saveAssociation(name,false,l_obj.get());
    }
   
  
    template<class T>
    void loadAssociation(const tString& name,boost::weak_ptr<T>& object) const {
        boost::shared_ptr<T> obj;
        obj=dynamic_sp_cast<T>(loadAssociation(name,false));
        object=obj;
    }
   
    
    template<class T>
    void  saveAssociation(const tString& name,const CORE_SharedPointersList<T>& obj);
    
    template<class T>
    void  loadAssociation(const tString& name,CORE_SharedPointersList<T>& objs) const;
    
    template<class T>
    void  saveAssociation(const tString& name,const CORE_WeakPointersList<T>& obj);
    
    template<class T>
    void  loadAssociation(const tString& name,CORE_WeakPointersList<T>& objs) const;
    
    template<class T,class V>
    void  saveAssociation(const tString& name,
                          const CORE_SharedPointersVMap<T,V>& objs);
   
    
    template<class K,class V>
    void  loadAssociation(const tString& name,
                          CORE_SharedPointersVMap<K,V>& objs) const;

  
    
   
    

    
};
#include "UI_Class.hpp"
#endif