CORE_ClassFactory.h

Go to the documentation of this file.

#ifndef CORE_ClassFactory_H
#define CORE_ClassFactory_H
 
//vector header
#include <vector>
 
//map header
#include <map>
 
//include the base class of the package
#include "CORE_Object.h"
 
//shared pointer functions
#include "sp.h"
 
 
class CORE_ClassFactory : public virtual CORE_Object  { // class
 
  
    // ASSOCIATION
 
    //list of sub classes
    
    // ATTRIBUTES
  
private:
  
  
    // ASSOCIATIONS
  
    //list of factory classes
    std::vector<CORE_UniquePointer<CORE_ClassFactory> > mFactoryClasses;
    
    // METHODS
  
  
protected:
    // CONSTRUCTORS
    CORE_ClassFactory(); 
  
  
  
  
    // DESTRUCTORS
    virtual ~CORE_ClassFactory(void);  
 
  
  
  
  
public:
   
    virtual tMemSize getMemorySize() const override{
        return sizeof(*this)+getContentsMemorySize();
    }
   
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=CORE_Object::getContentsMemorySize();
        std::for_each(mFactoryClasses.cbegin(),mFactoryClasses.cend(),
                      [&](const auto& cf) {mem+=cf->getMemorySize();});
        return mem;
    }
public:
 
    // SET
 
    inline void addClassFactory(CORE_UniquePointer<CORE_ClassFactory> child) {
        mFactoryClasses.push_back(std::move(child));
        
    }
 
 
     inline void clearClassFactories() {
         mFactoryClasses.clear();
     }
  
    
public:
 
    //New class Factory
    inline static CORE_UniquePointer<CORE_ClassFactory> New() {
        return CORE_UniquePointer<CORE_ClassFactory>(new CORE_ClassFactory(),CORE_ClassFactory::Delete());
    }
    
    // OTHERS
   
   
    virtual CORE_UniquePointer<CORE_Object> NewInstance(const tString& name,
                                                        const std::map<tString,tString>& arguments) const;
    
    inline CORE_UniquePointer<CORE_Object> NewInstance(const tString& name) const {
        std::map<tString,tString> arguments;
        return NewInstance(name,arguments);
    }
    
    
    template<class T>
    inline CORE_UniquePointer<T> NewUniqueInstance(const tString& name,
                                                   const std::map<tString,tString>& arguments) const {
        return sp::dynamic_upointer_cast<T>(NewInstance(name,arguments));
    }
    
    template<class T>
    inline CORE_UniquePointer<T> NewUniqueInstance(const tString& name) const {
        std::map<tString,tString> nullArguments;
        return sp::dynamic_upointer_cast<T>(NewInstance(name,nullArguments));
    }
 
 
    template<class T>
    inline CORE_SharedPointer<T> NewSharedInstance(const tString& name,
                                                   const std::map<tString,tString>& arguments) const {
        CORE_UniquePointer<T> up=sp::dynamic_upointer_cast<T>(NewInstance(name,arguments));
        return up->setThis(up);
    }
    template<class T>
    inline CORE_SharedPointer<T> NewSharedInstance(const tString& name) const {
        std::map<tString,tString> nullArguments;
        CORE_UniquePointer<T> up=sp::dynamic_upointer_cast<T>(NewInstance(name,nullArguments));
        return up->setThis(up);
    }
    template<class T>
    inline CORE_SharedPointer<T> NewSharedInstance() const {
        std::map<tString,tString> nullArguments;
        return NewSharedInstance<T>(nullArguments);
    }
    template<class T>
    inline CORE_SharedPointer<T> NewSharedInstance(const std::map<tString,tString>& arguments) const {
        std::map<tString,tString> nullArguments;
        CORE_UniquePointer<T> up=sp::dynamic_upointer_cast<T>(NewInstance(core_functions::getTypeName<T>(),arguments));
        return up->setThis(up);
    }
 
    template<class T>
    static inline CORE_SharedPointer<T> NewSharedInstance(CORE_UniquePointer<T>& up)  {
        if (up.get()==null) {
            CORE_SharedPointer<T>  nullPtr;
            return nullPtr;
        }
        return up->setThis(up);
    }
    template<class T>
    static inline CORE_SharedPointer<T> NewSharedInstance(CORE_UniquePointer<T>&& up)  {
        return up->setThis(up);
    }
 
 
    virtual tString toString() const override {
 
        std::stringstream ret;
        ret<<"class factories:"<<getIdentityString()<<"\n";
        std::vector<CORE_UniquePointer<CORE_ClassFactory> >::const_iterator iter=mFactoryClasses.begin();
        std::vector<CORE_UniquePointer<CORE_ClassFactory> >::const_iterator iterE=mFactoryClasses.end();
        while (iter!=iterE) {
            //try to create a new instance of the class with name
            ret<<"\t"<<(*iter)->getIdentityString()<<"\n";
            //next classes factory
            iter++;
        }
 
        return ret.str();
    }
 
    
   
    
 
 
    
};
    
#endif