User Manual, Developers Guide and API Documentation

StaticFactory.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 16, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

#ifndef WNS_STATICFACTORY_HPP
#define WNS_STATICFACTORY_HPP

#include <WNS/Exception.hpp>
#include <WNS/TypeInfo.hpp>

#include <sstream>
#include <string>

#include <map>
#include <vector>

namespace wns {
    template <typename CREATOR>
    class StaticFactory {
    public:

        static void reg(std::string name, CREATOR* creator);
        typedef void (*RegisterFunction)(std::string name, CREATOR* creator);

        static CREATOR* creator(std::string name);

        static bool knows(std::string name);

        typedef std::map<std::string, CREATOR*> CreateMap;

        static CreateMap* getMap();
    };


    template <typename CREATOR>
    typename StaticFactory<CREATOR>::CreateMap*
    StaticFactory<CREATOR>::getMap()
    {
        static CreateMap plugins = CreateMap();

        return &plugins;
    } // getMap


    template <typename CREATOR>
    CREATOR*
    StaticFactory<CREATOR>::creator(std::string name)
    {
        if(getMap()->find(name) == getMap()->end()) {
            std::stringstream ss;
            ss << "StaticFactory<" << wns::TypeInfo::create<CREATOR>() << "> says:\n"
               << "You tried to create a '" << name << "' instance.\n"
               << "Valid choices are:\n\n";
            for(typename CreateMap::iterator i = getMap()->begin();
                i != getMap()->end();
                ++i) {
                ss << "  * " << i->first << std::endl;
            }
            throw Exception(ss.str().c_str());
        }

        return (*getMap())[name];
    } // create


    template <typename CREATOR>
    void
    StaticFactory<CREATOR>::reg(std::string name, CREATOR* creator)
    {
        if(StaticFactory<CREATOR>::knows(name)) {
            Exception e;
            e << "there is already a plugin registered with name '"
              << name << "', what is probably not what you want.";
            throw e;
        }

        (*getMap())[name] = creator;
    } // reg


    template <typename CREATOR>
    bool
    StaticFactory<CREATOR>::knows(std::string name)
    {
        return getMap()->count(name) == 1;
    } // knows


    template <typename T, typename KIND = T>
    class Creator :
        public Creator<KIND, KIND>
    {
    public:
        virtual KIND* create()
        {
            return new T;
        }
    };


    template <typename KIND>
    class Creator<KIND, KIND>
    {
    public:
        virtual KIND* create() = 0;

        virtual ~Creator()
        {};
    };


    template <typename T, typename KIND,
          template <typename, typename> class CREATOR = Creator >
    class StaticFactoryRegister :
        public CREATOR<T, KIND>
    {
    public:
        StaticFactoryRegister(std::string name)
        {
            StaticFactory<CREATOR<KIND, KIND> >::reg(name, this);
        }
    };

// this was taken from cppunit
#define STATIC_FACTORY_JOIN(SYMBOL1, SYMBOL2) STATIC_FACTORY_DO_JOIN(SYMBOL1, SYMBOL2)
#define STATIC_FACTORY_DO_JOIN(SYMBOL1, SYMBOL2) STATIC_FACTORY_DO_JOIN2(SYMBOL1, SYMBOL2)
#define STATIC_FACTORY_DO_JOIN2(SYMBOL1, SYMBOL2) SYMBOL1##SYMBOL2

#define STATIC_FACTORY_UNIQUE_NAME(PREFIX) \
    STATIC_FACTORY_JOIN(PREFIX,__LINE__)


#define STATIC_FACTORY_REGISTER(CLASS, INTERFACE, NAME) \
    namespace { \
    static wns::StaticFactoryRegister<CLASS, INTERFACE> STATIC_FACTORY_UNIQUE_NAME(_)(NAME); \
    } \
    class StaticFactoryRegisterDummy

#define STATIC_FACTORY_REGISTER_WITH_CREATOR(CLASS, INTERFACE, NAME, CREATOR) \
    namespace { \
    static wns::StaticFactoryRegister<CLASS, INTERFACE, CREATOR> STATIC_FACTORY_UNIQUE_NAME(_)(NAME); \
    } \
    class StaticFactoryRegisterDummy
}

#endif // NOT defined WNS_STATICFACTORY_HPP

#define STATIC_FACTORY_DEFINE(INTERFACE, CREATOR) \
    typedef CREATOR<INTERFACE> INTERFACE ## Creator;\
    typedef wns::StaticFactory<INTERFACE ## Creator> INTERFACE ## Factory;

#define STATIC_FACTORY_NEW_INSTANCE(INTERFACE, CREATOR, VIEW, ARGS...) \
    wns::StaticFactory< CREATOR<INTERFACE> >::creator(VIEW.get<std::string>("nameInStaticFactory"))->create(ARGS)

---