MM_Class.h

Go to the documentation of this file.

#ifndef MM_Class_H
#define MM_Class_H


#include "MM_Data.h"

#include "MM_Attribute.h"

DEFINE_SPTR(MM_Class);
DEFINE_SVPTR(MM_Class);

class MM_Class : public virtual MM_Data {
    SP_OBJECT(MM_Class);
    // ATTRIBUTES
    
private:
    
    
    
    
    // id of the class
    tString mClassId;
    
    // attributes
    map<tString,SP::MM_Attribute > mAttributes;
    
    // agregate association associations name -> list of shared pointers of data
    map<tString,boost::shared_ptr< SV::MM_Data > >mCompositeAssociations;
    
    // simple association associations name -> list of weak pointers of data
    map<tString,boost::shared_ptr< WV::MM_Data > >mSimpleAssociations;
    
    
    
protected: 
    // METHODS
    
    // CONSTRUCTORS 
    
    MM_Class(void);
    
    
    
    // DESTRUCTORS 
    
    
    virtual ~MM_Class(void);   
    
    
    
public:
//----------------
// NEW constructors
// ---------------
    
    inline static SP::MM_Class New() {
        SP::MM_Class p(new MM_Class(),
                       MM_Class::Delete());
        p->setThis(p);
        return p;
    };
    
    
    // ---------------------------
    //composite association Methods
    // -----------------------------
    inline SV::MM_Data* getCompositeAssociation(const tString& name) const {
        map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator association=mCompositeAssociations.find(name);
        map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator end=mCompositeAssociations.end();
        if (association==end) return null;
        return association->second.get();
    };
    
    inline SP::MM_Data getCompositeAssociation(const tString& name,const tVectorIndex& index) {
        SP::MM_Data f;
        map<tString,boost::shared_ptr< SV::MM_Data > >::iterator iter=mCompositeAssociations.find(name);
        map<tString,boost::shared_ptr< SV::MM_Data > >::iterator end=mCompositeAssociations.end();
        if (iter==end) {
            // no composite association of name
            return f;
        }
        SV::MM_Data* list=iter->second.get();
        if (list->getSize()<=index) {
            // indes too big
            return f;
        }
        // retrun the value
        return (*list)[index];
    }
    inline void setCompositeAssociation(const tString& name,const tVectorIndex& index,SP::MM_Data data) {
        map<tString,boost::shared_ptr< SV::MM_Data > >::iterator iter=mCompositeAssociations.find(name);
        map<tString,boost::shared_ptr< SV::MM_Data > >::iterator end=mCompositeAssociations.end();
        boost::shared_ptr< SV::MM_Data > list;
        if (iter==end) {
            // association does not exists, create it
            list=SV::MM_Data::New();
            mCompositeAssociations[name]=list;
        } else {
            list=iter->second;
        }
        if (list->getSize()<=index) {
            // size of assocition too small, increase it
            list->setSize(index+1);
            
            
        } 
        // set the value
        list->set(index,data);
    }
    
     
    inline SV::MM_Data* createCompositeAssociation(const tString& name,const int& n) {
        map<tString,boost::shared_ptr< SV::MM_Data > >::iterator iter=mCompositeAssociations.find(name);
        map<tString,boost::shared_ptr< SV::MM_Data > >::iterator end=mCompositeAssociations.end();
        boost::shared_ptr< SV::MM_Data > list;
        if (iter==end) {
            // association does not exists, create it
            list=SV::MM_Data::New();
            mCompositeAssociations[name]=list;
        } else {   
            list=iter->second;
        }
        // set the size
        list->setSize(n);
        return list.get();
    }
    inline void clearCompositeAssociation(const tString& name) {
        map<tString,boost::shared_ptr< SV::MM_Data> >::iterator association=mCompositeAssociations.find(name);
        map<tString,boost::shared_ptr< SV::MM_Data> >::iterator end=mCompositeAssociations.end();
        if (end!=association) {
            association->second->clear();
        }
    };
    inline void addCompositeAssociation(const tString& name,SP::MM_Data f) {
        map<tString,boost::shared_ptr< SV::MM_Data> >::iterator association=mCompositeAssociations.find(name);
        map<tString,boost::shared_ptr< SV::MM_Data> >::iterator end=mCompositeAssociations.end();
        if (end==association) {
            boost::shared_ptr< SV::MM_Data > list=SV::MM_Data::New();
            list->add(f);
            mCompositeAssociations[name]=list;
        } else {
            association->second->add(f);
        }
    };
    inline int getCompositeAssociationsNumber() const {
        return mCompositeAssociations.size();
    };
    inline int getCompositeAssociationCardinality(const tString& name) const {
        map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator association=mCompositeAssociations.find(name);
        map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator end=mCompositeAssociations.end();
        if (association==end) return 0;
        return association->second->getSize();
    };
   
    inline void getCompositeAssociationsName(vector<tString>& fields) const {
        fields.resize(0);
        map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator iter=mCompositeAssociations.begin();
        map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator end=mCompositeAssociations.end();
        while (iter!=end) {
            fields.push_back(iter->first);
            iter++;
        }   
    }
    // ---------------------------
    // simple assoiciation Methods
    // -----------------------------
    
    inline SP::MM_Data getSimpleAssociation(const tString& name,const int& index) {
        SP::MM_Data f;
        map<tString,boost::shared_ptr< WV::MM_Data > >::iterator iter=mSimpleAssociations.find(name);
        map<tString,boost::shared_ptr< WV::MM_Data > >::iterator end=mSimpleAssociations.end();
        
        if (iter==end) {
            // no composite association of name
            return f;
        }
        WV::MM_Data  *list=iter->second.get();
        if (list->getSize()<=index) {
            // indes too big
            return f;
        }
        // return the value
        f=(*list)[index];
        return f;
    }
    inline void setSimpleAssociation(const tString& name,const int& index,SP::MM_Data data) {
        map<tString,boost::shared_ptr< WV::MM_Data > >::iterator iter=mSimpleAssociations.find(name);
        map<tString,boost::shared_ptr< WV::MM_Data > >::iterator end=mSimpleAssociations.end();
        boost::shared_ptr< WV::MM_Data> list;
        if (iter==end) {
            // association does not exists, create it
            list=WV::MM_Data::New();
            mSimpleAssociations[name]=list;
        } else {
            list=iter->second;
        };
        
        if (list->getSize()<=index) {
            // size of assocition too small, increase it
            list->setSize(index+1);
            
            
        } 
        // set the value
        list->set(index,data);
    }
     
    inline void addSimpleAssociation(const tString& name,SP::MM_Data f) {
        map<tString,boost::shared_ptr< WV::MM_Data> >::iterator association=mSimpleAssociations.find(name);
        map<tString,boost::shared_ptr< WV::MM_Data> >::iterator end=mSimpleAssociations.end();
        if (end==association) {
            boost::shared_ptr< WV::MM_Data > list=WV::MM_Data::New();
            list->add(f);
            association->second=list;
        } else {
            association->second->add(f);
        }
    };

    
    inline WV::MM_Data* createSimpleAssociation(const tString& name,const int& n) {
        map<tString,boost::shared_ptr< WV::MM_Data > >::iterator iter=mSimpleAssociations.find(name);
        map<tString,boost::shared_ptr< WV::MM_Data > >::iterator end=mSimpleAssociations.end();
        boost::shared_ptr< WV::MM_Data > list;
        if (iter==end) {
            // association does not exists, create it
            list=WV::MM_Data::New();
            mSimpleAssociations[name]=list;
        }
        // set the size
        list->setSize(n);
        return list.get();
    }
    
    inline void clearSimpleAssociation(const tString& name) {
        map<tString,boost::shared_ptr< WV::MM_Data> >::iterator association=mSimpleAssociations.find(name);
        map<tString,boost::shared_ptr< WV::MM_Data> >::iterator end=mSimpleAssociations.end();
        if (end!=association) {
            association->second->clear();
        }
    };
   
    inline int getSimpleAssociationsNumber() const {
        return mSimpleAssociations.size();
    };
    
    inline int getSimpleAssociationCardinality(const tString& name) const {
        map<tString,boost::shared_ptr< WV::MM_Data> >::const_iterator association=mSimpleAssociations.find(name);
        map<tString,boost::shared_ptr< WV::MM_Data> >::const_iterator end=mSimpleAssociations.end();
        if (association==end) return 0;
        return association->second->getSize();
    };
    inline WV::MM_Data* getSimpleAssociation(const tString& name) const {
        map<tString,boost::shared_ptr< WV::MM_Data> >::const_iterator association=mSimpleAssociations.find(name);
        map<tString,boost::shared_ptr< WV::MM_Data> >::const_iterator end=mSimpleAssociations.end();
        if (association==end) return null;
        return association->second.get();
    };
    
    inline void getSimpleAssociationsName(vector<tString>& fields) const {
        fields.resize(0);
        map<tString,boost::shared_ptr< WV::MM_Data > >::const_iterator iter=mSimpleAssociations.begin();
        map<tString,boost::shared_ptr< WV::MM_Data> >::const_iterator end=mSimpleAssociations.end();
        while (iter!=end) {
            fields.push_back(iter->first);
            iter++;
        }   
    }
    // -----------
    // Attributes
    // -----------
    
    inline int getAttributesNumber() const {
        return mAttributes.size();
    };
    
    
    inline void setAttribute(const tString& name,SP::MM_Attribute f) {
        mAttributes[name]=f;
    };
    

    inline SP::MM_Attribute getAttribute(const tString& name) {
     
        map<tString,SP::MM_Attribute>::iterator att=mAttributes.find(name);
        map<tString,SP::MM_Attribute>::iterator end=mAttributes.end();
        if (end==att) {
            SP::MM_Attribute ret;
            return ret;
        } else {
            return att->second;
        }
        
    };
    inline SPC::MM_Attribute getAttribute(const tString& name) const {
     
        map<tString,SP::MM_Attribute>::const_iterator att=mAttributes.find(name);
        map<tString,SP::MM_Attribute>::const_iterator end=mAttributes.end();
        if (end==att) {
            SPC::MM_Attribute ret;
            return ret;
        } else {
            return att->second;
        }
        
    };
    inline void getAttributesName(vector<tString>& fields) const {
        fields.resize(0);
      
        map<tString,SP::MM_Attribute >::const_iterator iter=mAttributes.begin();
        map<tString,SP::MM_Attribute >::const_iterator end=mAttributes.end();
        while (iter!=end) {
            fields.push_back(iter->first);
            iter++;
        }
    };

    // ---------
    // class id
    // ---------
 
  
    inline tString getClassId() const {
        return mClassId;
    };
    inline void setClassId(const tString& id){
        mClassId=id;
    };
   
    
    // ----------------
    // general methods
    // ----------------

    inline tBoolean  setField(const tString& name,const tBoolean& isComposite,SP::MM_Data data) {
        SP::MM_Attribute att=dynamic_sp_cast<MM_Attribute>(data);
        if (att.get()!=null) {
            setAttribute(name,att);
            return true;
        } else {
            
            SP::MM_Class cl=dynamic_sp_cast<MM_Class>(data);

            if (isComposite) setCompositeAssociation(name,0,cl);
            else setSimpleAssociation(name,0,cl);
            return true;
        }
        return false;
    }
    inline tBoolean hasField(const tString& name) const {
        map<tString,boost::shared_ptr< WV::MM_Data> >::const_iterator sass=mSimpleAssociations.find(name);
        map<tString,boost::shared_ptr< WV::MM_Data> >::const_iterator end_sass=mSimpleAssociations.end();
        if (sass!=end_sass) return true;
        map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator cass=mCompositeAssociations.find(name);
            map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator end_cass=mCompositeAssociations.end();
        if (cass!=end_cass) return true;
        
        map<tString,SP::MM_Attribute>::const_iterator att=mAttributes.find(name);
        map<tString,SP::MM_Attribute>::const_iterator end_att=mAttributes.end();
        return (att!=end_att);
        
    }

    /*\brief get the association with name at index
     */
    inline SP::MM_Data getAssociation(const tString& name,const int& index) {
        SP::MM_Data data=getCompositeAssociation(name,index);
        if (data.get()!=null) return data;
        return getSimpleAssociation(name,index);
    }
    /*\brief get the association with name at index
     */
    inline int getAssociationCardinality(const tString& name) const {
        map<tString,boost::shared_ptr< WV::MM_Data> >::const_iterator association=mSimpleAssociations.find(name);
        map<tString,boost::shared_ptr< WV::MM_Data> >::const_iterator end=mSimpleAssociations.end();
        if (association==end) {
            map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator cassociation=mCompositeAssociations.find(name);
            map<tString,boost::shared_ptr< SV::MM_Data> >::const_iterator cend=mCompositeAssociations.end();
            if (cassociation==cend) return 0;
            return cassociation->second->getSize();
        } else {
            
            return association->second->getSize();
        }
    }
  
    /*\brief get the association with name
     */
    inline SP::MM_Data getAssociation(const tString& name) {
        return getAssociation(name,0);
    };

    /*\brief get the field with name
     */
    inline SP::MM_Data getField(const tString& name) {
        SP::MM_Data  data=getAssociation(name,0);
        if (data.get()!=null) return data;
        return getAttribute(name);
    };
    inline void getFieldNames(vector<tString>& fields) const {
        fields.clear();
      
  
        map<tString,SP::MM_Attribute >::const_iterator  attributes;
        attributes=mAttributes.begin();
        while (mAttributes.end()!=attributes) {
            fields.push_back(attributes->first);
            attributes++;    
        }
        map<tString,boost::shared_ptr< SV::MM_Data > >::const_iterator compositeAssociations;
        compositeAssociations=mCompositeAssociations.begin();
        while (mCompositeAssociations.end()!=compositeAssociations) {
            fields.push_back(compositeAssociations->first);
            compositeAssociations++;    
        }
    
   
        map<tString,boost::shared_ptr< WV::MM_Data > >::const_iterator simpleAssociations;
        simpleAssociations=mSimpleAssociations.begin();
        while (mSimpleAssociations.end()!=simpleAssociations) {
            fields.push_back(simpleAssociations->first);
            simpleAssociations++;    
        }
    
    
    }
    virtual tString toString() const;
    
      
    
    
};

#endif