factory.h

Go to the documentation of this file.

#ifndef _TEMPLATES__FACTORY_H_
#define _TEMPLATES__FACTORY_H_

#include <vector>
#include <map>
#include <cassert>

namespace Templates
{
        template <typename, class>
        class DefaultFactoryError;

        template <class, typename, typename, template<typename, class> class>
        class Factory;
}

template <typename IdentifierType, class AbstractProduct>
class Templates::DefaultFactoryError
{
        protected:

                DefaultFactoryError() { }

                ~DefaultFactoryError() { }

        public:

                static AbstractProduct *onUnknownType(IdentifierType /*id*/)
                {
                        // Trying to instantiate an unknown object!
                        assert(false);
                        return 0;
                }
};

template <
        class AbstractProduct,
        typename IdentifierType,
        typename ProductCreator = AbstractProduct *(*)(),
        template<typename, class>
                class FactoryErrorPolicy = Templates::DefaultFactoryError
>
class Templates::Factory: public FactoryErrorPolicy<IdentifierType, AbstractProduct>
{
        private:

                typedef std::map<IdentifierType, ProductCreator> IdToProductMap;

                IdToProductMap _associations;

        public:

                Factory(): _associations() { }

                bool registerObject(IdentifierType id, ProductCreator creator)
                {
                        return _associations.insert(
                                typename IdToProductMap::value_type(id, creator)).second;
                }

                bool unregisterObject(const IdentifierType & id) const
                {
                        return _associations.erase(id) == 1;
                }

                AbstractProduct *createObject(const IdentifierType & id) const
                {
                        typename IdToProductMap::const_iterator i = _associations.find(id);
                        if (i != _associations.end()) {
                                // Instantiate the object via registered function
                                return (i->second)();
                        }

                        return onUnknownType(id);
                }

                std::vector<IdentifierType> registeredObjects() const
                {
                        std::vector<IdentifierType> regObjects;
                        for (typename IdToProductMap::const_iterator i = _associations.begin();
                                i != _associations.end(); ++i) {
                                regObjects.push_back(i->first);
                        }
                        return regObjects;
                }
};

#endif