CORE_ClassFactory.h

#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 "shared_pointer.h"
 
//list of options
#include "CORE_OptionsList.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 CORE_OptionsList& arguments) const;
    
    inline CORE_UniquePointer<CORE_Object> NewInstance(const tString& name) const {
        CORE_OptionsList arguments;
        return NewInstance(name,arguments);
    }
    
    
    template<class T>
    inline CORE_UniquePointer<T> NewInstance(const tString& name,
                                             const CORE_OptionsList& arguments) const {
        return shared_pointer::dynamic_up_cast<T>(NewInstance(name,arguments));
    }
    
    template<class T>
    inline CORE_UniquePointer<T> NewInstance(const tString& name) const {
        CORE_OptionsList nullArguments;
        return NewInstance<T>(name,nullArguments);
    }
 
 
    template<class T>
    inline CORE_SharedPointer<T> NewSharedPointer(const tString& name,
                                                  const CORE_OptionsList& arguments) const {
        CORE_UniquePointer<T> up=NewInstance<T>(name,arguments);
        if (up.get()!=null) return up->setThis(up);
        else {
            CORE_UniquePointer<T> nullPtr;
            return nullPtr;
        }
    }
    template<class T>
    inline CORE_SharedPointer<T> NewSharedPointer(const tString& name) const {
        CORE_OptionsList nullArguments;
        return NewSharedPointer<T>(name,nullArguments);
    }
    template<class T>
    inline CORE_SharedPointer<T> NewSharedPointer() const {
        CORE_OptionsList nullArguments;
        return NewSharedPointer<T>(nullArguments);
    }
    template<class T>
    inline CORE_SharedPointer<T> NewSharedPointer(const CORE_OptionsList& arguments) const {
        return NewSharedPointer<T>(functions_type::getTypeName<T>(),arguments);
    }
 
    template<class T>
    static inline CORE_SharedPointer<T> NewSharedPointer(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> NewSharedPointer(CORE_UniquePointer<T>&& up)  {
        if (up.get()!=null) return up->setThis(up);
        CORE_SharedPointer<T> nullPtr;
        return nullPtr;
    }
 
 
    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();
    }
 
    
   
    
 
 
    
};
 
//UniquePointer = Instance definition
#define NewUniquePointer NewInstance
#define NewUniqueInstance NewInstance
#define NewSharedInstance NewSharedPointer
#endif