Factory.h

Go to the documentation of this file.

#pragma once

#include <assert.h>

#include <string>
#include <map>
#include <set>
#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:
    AbstractProducer() {}
    virtual ~AbstractProducer() {}
    virtual void* Produce(void) 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(void);

    const char* ProduceScript(const char* sScriptName) const;

private:
    static ScriptFactorySingleton* _pcSingleton;

    ScriptFactorySingleton() {}
    ~ScriptFactorySingleton() {}
};

inline ScriptFactorySingleton& ScriptFactory(void)
{
    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 ~ScriptProducer(void) {}

    virtual void* Produce(void) const
    {
        return (void*)mScript;
    }

private:
    const char* mScript;
};

}  // namespace Base