AsyncFactory.h

Go to the documentation of this file.

 
#ifndef ASYNC_FACTORY_INCLUDED
#define ASYNC_FACTORY_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <map>
#include <string>
#include <sstream>
#include <cassert>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
template <class T, typename... Args>
class Factory
{
  public:
    static T *createNamedObject(const std::string& name, Args... args)
    {
      typename std::map<std::string, Factory<T, Args...>*>::iterator it;
      it = factories().find(name);
      if (it == factories().end())
      {
        return 0;
      }
 
      return (*it).second->createObject(args...);
    } /* Factory::createNamedObject */
 
    static std::string validFactories(void)
    {
      std::stringstream ss;
      for (typename FactoryMap::const_iterator it = factories().begin();
           it != factories().end(); ++it)
      {
        ss << "\"" << (*it).first << "\" ";
      }
      return ss.str();
    }
 
    Factory(const std::string &name) : m_name(name)
    {
      typename FactoryMap::iterator it = factories().find(m_name);
      assert(it == factories().end());
      factories()[name] = this;
    } /* Factory::Factory */
 
    Factory(const Factory<T, Args...>&) = delete;
 
    Factory& operator=(const Factory<T, Args...>&) = delete;
 
    virtual ~Factory(void)
    {
      typename FactoryMap::iterator it = factories().find(m_name);
      assert(it != factories().end());
      factories().erase(it);
    } /* Factory::~Factory */
 
  protected:
    virtual T *createObject(Args... args) = 0;
 
  private:
    typedef std::map<std::string, Factory<T, Args...>*> FactoryMap;
    std::string m_name;
 
    static FactoryMap& factories(void)
    {
      static FactoryMap factory_map;
      return factory_map;
    }
};  /* class Factory */
 
 
template <class Base, class T, typename... Args>
class SpecificFactory : public Factory<Base, Args...>
{
  public:
    SpecificFactory(const std::string &name) : Factory<Base, Args...>(name) {}
 
  protected:
    T *createObject(Args... args)
    {
      return new T(args...);
    }
};
 
 
} /* namespace Async */
 
#endif /* ASYNC_FACTORY_INCLUDED */
 
/*
 * This file has not been truncated
 */