Factory.h

Go to the documentation of this file.

#pragma once
#include <string>
#include <map>
#include <list>
 
namespace Base
{
template <typename BaseClassType, typename ClassType>
BaseClassType* CreateObject()
{
    return new ClassType();
}
 
template <typename BaseClassType, typename UniqueIdType>
class Factory
{
protected:
    typedef BaseClassType* (*CreateObjectFunc)();
 
public:
    typedef typename std::map<UniqueIdType, CreateObjectFunc>::const_iterator ConstIterator;
    typedef typename std::map<UniqueIdType, CreateObjectFunc>::iterator Iterator;
 
    template <typename ClassType>
    bool Register(UniqueIdType unique_id)
    {
        if (m_object_creator.find(unique_id) != m_object_creator.end())
            return false;
 
        m_object_creator[unique_id] = &CreateObject<BaseClassType, ClassType>;
 
        return true;
    }
 
    bool Unregister(UniqueIdType unique_id) { return (m_object_creator.erase(unique_id) == 1); }
 
    BaseClassType* Create(UniqueIdType unique_id)
    {
        Iterator iter = m_object_creator.find(unique_id);
 
        if (iter == m_object_creator.end())
            return NULL;
 
        return ((*iter).second)();
    }
 
    ConstIterator GetBegin() const { return m_object_creator.begin(); }
    Iterator GetBegin() { return m_object_creator.begin(); }
    ConstIterator GetEnd() const { return m_object_creator.end(); }
    Iterator GetEnd() { return m_object_creator.end(); }
 
protected:
    std::map<UniqueIdType, CreateObjectFunc> m_object_creator;
};
 
class LX_BASE_EXPORT AbstractProducer
{
public:
    virtual ~AbstractProducer() = default;
    virtual void* Produce() const = 0;
};
 
class LX_BASE_EXPORT Factory2
{
public:
    void AddProducer(const char* sClassName, AbstractProducer* pcProducer);
    bool CanProduce(const char* sClassName) const;
    std::list<std::string> CanProduce() const;
 
protected:
    void* Produce(const char* sClassName) const;
    std::map<const std::string, AbstractProducer*> _mpcProducers;
    Factory2(void) {}
    virtual ~Factory2();
};
 
// --------------------------------------------------------------------
 
class LX_BASE_EXPORT ScriptFactorySingleton : public Factory2
{
public:
    static ScriptFactorySingleton& Instance(void);
    static void Destruct();
 
    const char* ProduceScript(const char* sScriptName) const;
 
private:
    static ScriptFactorySingleton* _pcSingleton;
 
    ScriptFactorySingleton() = default;
};
 
inline ScriptFactorySingleton& ScriptFactory()
{
    return ScriptFactorySingleton::Instance();
}
 
// --------------------------------------------------------------------
 
class LX_BASE_EXPORT ScriptProducer : public AbstractProducer
{
public:
    ScriptProducer(const char* name, const char* script) : mScript(script)
    {
        ScriptFactorySingleton::Instance().AddProducer(name, this);
    }
 
    virtual void* Produce() const
    {
        return (void*)mScript;
    }
 
private:
    const char* mScript;
};
 
}  // namespace Base