source: ThirdParty/CodePatterns/src/CodePatterns/ManipulablePrototypeFactory.hpp

/*
 * ManipulablePrototypeFactory.hpp
 *
 *  Created on: Jan 6, 2011
 *      Author: heber
 */

#ifndef MANIPULABLEDPROTOTYPEFACTORY_HPP_
#define MANIPULABLEDPROTOTYPEFACTORY_HPP_

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <map>
#include <typeinfo>

#include "CodePatterns/Assert.hpp"

#include "CodePatterns/ManipulableClone.hpp"

class ManipulablePrototypeFactoryTest;

/** \section <ManipulablePrototypeFactory> (Manipulable Prototype Factory Howto)
 *
 * This template produces the generic manipulable prototype factory pattern.
 *
 * <h2> Introduction </h2>
 *
 * The prototype factory is very similar to the factory pattern with one
 * important difference: An prototype factory contains prototypes that are
 * cloned, whereas a factory contains creation wrappers that just create
 * a new object (i.e. without copying any additional information). Here, you
 * may additionally \a manipulate the protype at run-time.
 *
 * A prototype factory is a class that instantiates other types. In order to be
 * able to do so the following prerequisites must be met:
 * -# there is a list of types the factory should be able to produce
 * -# these types have to implement the Clone pattern, i.e. derive from it and
 *    implement a function clone(), see @ref <Clone> ''(Clone)''.
 * -# they all must be derived from a common class (e.g. an interface) which is
 *    the type of the reference the factory returned the newly created objects
 *    as.
 *
 * The reason for the last one is that it is not possible -- except by an ugly
 * static_cast -- to retrieve the particular type and if nonetheless needed,
 * factory is probably the wrong pattern. After all what a factory does is
 * hiding the specifics of a certain subtype, e.g. to control a motor it is not
 * necessary to know how fast it goes and what it precisely does, you just need
 * need the throttle as a control and some kind of rpm feedback. This control
 * and feedback would be the stuff abstracted into the interface class.
 *
 * <h2>How to make a class Prototype Factory</h2>
 *
 * If you want to make a class a Prototype Factory you can use the following
 * sequence of steps.
 *
 * Before we begin, we assume the following #defines to represent ...
 * - Abstract_Interface_Class: the aforementioned common interface of all
 *    particular types the factory should produce.
 * - Abstract_Encapsulation_Class: we need to connect the interface class (which
 *    must not be a template) with the types to put into the factory. Hence, we
 *    need this (templated) class that encapsulates each possible type as its
 *    template argument while deriving from (and implementing) the abstract
 *    interface as well.
 * - MyManipulablePrototypeFactory: Your specific factory that spills out references to
 *    Abstract_Interface_Class that are embodied by
 *    Abstract_Encapsulation_Class instances.
 *
 * For present code, have a look at RandomNumberDistributionFactory.def,
 * RandomNumberDistribution_Encapsulation.hpp and
 * RandomNumberDistributionFactory.hpp.
 *
 * @attention{
 * One last \b warning before we begin: Your types should reside in a distinct
 * (and not the global) namespace, otherwise you may get strange errors such
 * as
 * \verbatim
 * /usr/include/boost/preprocessor/iteration/detail/local.hpp:34: error: type/value mismatch at argument 1 in template parameter list for ‘template<class T> class stub’
 * /usr/include/boost/preprocessor/iteration/detail/local.hpp:34: error:   expected a type, got ‘(FactoryTypeList::ListOfKnownTypes)0u’
 * \endverbatim
 * i.e. the compiler cannot discern between the enumerated types and the true
 * types due.
 * @remarks But having your particular types in their own name space is always
 *          a good idea.
 * }
 *
 * Now beginning, first remember that all we need is a list of already present
 * types, i.e. implemented classes. The rest is the stuff below which is all
 * you need (and although it looks like quite a lot, it is actually not).
 *
 * Then, do the following steps:
 * - create a file "RandomNumberDistributionFactory.def" containing only
 *   preprocessor defines as follows:
 *   @code
 *   #ifndef RANDOMNUMBERDISTRIBUTIONMANIPULABLEPROTOTYPEFACTORY_DEF_
 *   #define RANDOMNUMBERDISTRIBUTIONMANIPULABLEPROTOTYPEFACTORY_DEF_
 *
 *   #define type_seq (uniform_smallint)(uniform_int)
 *   #define Abstract_Interface_Class RandomNumberDistribution
 *   #define Abstract_Encapsulation_Class RandomNumberDistribution_Encapsulation
 *   #define type_name_space boost::
 *   #undef type_suffix
 *
 *   #endif //RANDOMNUMBERDISTRIBUTIONMANIPULABLEPROTOTYPEFACTORY_DEF_
 *   @endcode
 *   where \a type_seq is the list of types, each element in round brackets,
 *   \a Abstract_Interface_Class is the class name of the abstract base class
 *   which a reference to the factory spills out, and
 *   \a Abstract_Encapsulation_Class is the class name of the (templated)
 *   encapsulation class of each type. Optionally, these types may reside in
 *   some other name_space, define this one via type_name_space (with suffixes
 *   double colons!). If you need to add something to the types such as "<>",
 *   do so in type_suffix.
 *   Note that the first two and the last line are just to avoid double
 *   inclusion, also the define made therein is used for the following step ...
 * - create the undefine file "RandomNumberDistributionFactory.undef" which
 *   undefines all the previously made definitions to allow for more factories
 *   created without the danger of the various defines getting in the way of
 *   each other:
 *   @code
 *   #ifdef RANDOMNUMBERDISTRIBUTIONMANIPULABLEPROTOTYPEFACTORY_DEF_
 *
 *   #undef type_seq
 *   #undef type_seq_size
 *   #undef Abstract_Interface_Class
 *   #undef Abstract_Encapsulation_Class
 *   #undef type_name_space
 *   #undef type_suffix
 *
 *   #undef RANDOMNUMBERDISTRIBUTIONMANIPULABLEPROTOTYPEFACTORY_DEF_
 *   #endif
 *   @endcode
 * - Create the encapsulation of the desired types, listed in the above define
 *   type_seq via a templated class:
 *   @code
 *    #include "Clone.hpp"  // the creator wrapper
 *    #include "RandomNumberDistribution.hpp" // the abstract interface class
 *    template <class type>
 *    class RandomNumberDistribution_Encapsulation :
 *      public RandomNumberDistribution,  // inherit from abstract interface
 *      public Clone<RandomNumberDistribution> // the specialized clone pattern
 *    {
 *      // Our Prototype Factory is friend because it needs to access protected cstor
 *      // to instantiate prototypes.
 *      friend class RandomNumberDistributionFactory;
 *
 *    protected: // no one except factory and ourselves should be allowed to call them
 *      RandomNumberDistribution_Encapsulation() {} // constructor
 *      virtual ~RandomNumberDistribution_Encapsulation() {} // virtual destructor
 *    public:
 *      // ... some interface functions here with template implementation ...
 *      // i.e. those defined as virtual functions in the abstract interface
 *      RandomNumberDistribution* clone() {
 *        // .. instantiate a clone of this instance ..
 *        return MyClone;
 *      };
 *    private:
 *      type encapsulated_type; // the instance of the type to encapsulate
 *    };
 *   @endcode
 * - in the header of your factory put these before any declaration:
 *   @code
 *   // has to be appear BEFORE ManipulablePrototypeFactory.hpp is included!
 *   #include "RandomNumberDistributionFactory.def"
 *   #include "CodePatterns/FactoryTypeList.hpp"
 *   #include "RandomNumberDistributionFactory.undef"
 *   #include "CodePatterns/ManipulablePrototypeFactory.hpp"
 *   @endcode
 *   Then declare your factory by inheriting from Factory<Abstract_Interface_Class>
 *   @code
 *   class RandomNumberDistributionFactory :
 *     public Factory<RandomNumberDistribution>
 *   {
 *    // place here all other classes as friends that are allowed to access
 *    // Factory<RandomNumberDistribution>::getPrototypeManipulator()
 *   public:
 *     void FillPrototypeTable(); // these are defined automatically
 *     void EmptyPrototypeTable(); // you don't have to implement them
 *
 *     RandomNumberDistributionFactory();
 *     virtual ~RandomNumberDistributionFactory();
 *
 *   };
 *   #include "RandomNumberDistributionFactory.undef"
 *   @endcode
 *   where the last includes undefines the defines made in the first step and
 *   assures that another factory can be created without any old defines
 *   getting in the way.
 *   @note FactoryTypeList.hpp is necessary as we can't have a forward
 *         declaration of an enum which we need in the header of
 *         ManipulablePrototypeFactory<T>. Hence, there is an extra class the wraps the
 *         enum which we inherit.
 * - finally implement the prototype factory by:
 *   @code
 *   #include "RandomNumberDistribution_Encapsulation.hpp"
 *   #include "RandomNumberDistributionFactory.hpp"
 *   // has to be included BEFORE ManipulablePrototypeFactory_impl.hpp!
 *   #include "RandomNumberDistributionFactory.def"
 *   #include "CodePatterns/ManipulablePrototypeFactory_impl.hpp"
 *
 *   RandomNumberDistributionFactory::RandomNumberDistributionFactory() {
 *    FillPrototypeTable();
 *   }
 *   RandomNumberDistributionFactory::~RandomNumberDistributionFactory() {
 *    EmptyPrototypeTable();
 *   }
 *
 *   CONSTRUCT_SINGLETON(RandomNumberDistributionFactory)
 *   CONSTRUCT_MANIPULABLEPROTOTYPEFACTORY(RandomNumberDistribution)
 *
 *   #include "RandomNumberDistributionFactory.undef"
 *   @endcode
 *   @note the two functions within the constructor that fill and empty the
 *   prototype table are constructed automatically but you have to call them
 *   because only you (that is RandomNumberDistributionFactory in our case)
 *   is a true friend of RandomNumberDistribution_Encapsulation and can access
 *   its cstor and dstor.
 *
 * That's all.
 */
template <class T, class ParamT>
class ManipulablePrototypeFactory : public FactoryTypeList<T>
{
public:
  /** Constructor of class ManipulablePrototypeFactory.
   *
   */
  ManipulablePrototypeFactory()
  {
    FillEnumTable();
//    FillPrototypeTable();
  }

  /** (virtual) Destructor of class ManipulablePrototypeFactory.
   *
   */
  virtual ~ManipulablePrototypeFactory()
  {
    // clear out factories map to allow boost::shared_ptr to do their work (i.e. to release mem)
    // this is necessary as factory is an object
    enums.clear();
    names.clear();
//    EmptyPrototypeTable();
//    PrototypeTable.clear();
  }


  /** Typedef of enumeration of all types known to this factory
   *
   * @note The true enumeration has to be stored in a wrapper class
   * FactoryTypeList because enumerations cannot be forward declared as is
   * necessary here.
   */
  typedef enum FactoryTypeList<T>::ListOfKnownTypes TypeList;

  /** Setter for currenttype to produce.
   *
   * @param instance_name name of type
   */
  void setCurrentType(const std::string instance_name)
  {
    ASSERT(enums.count(instance_name) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::setCurrentType() - type "+instance_name+" is not registered.");
    currenttype = enums[instance_name];
  }

  /** Setter for currenttype to produce.
   *
   * @param instance_type enumeration index of type
   */
  void setCurrentType(TypeList instance_type)
  {
    ASSERT(names.count(instance_type) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::setCurrentType() - enum type "+toString(instance_type)+" is not registered.");
    currenttype = instance_type;
  }

  /** Getter for currenttype to produce.
   *
   * @return name of currenttype
   */
  const std::string & getCurrentTypeName() const
  {
    return names[currenttype];
  }

  /** Getter for currenttype to produce.
   *
   * @return enumeration index of currenttype
   */
  TypeList getCurrentTypeEnum() const
  {
    return currenttype;
  }

  /** Getter for desired type of product.
   *
   * @param enumeration index of product
   * @return reference to copy of product
   */
  T* getProduct(TypeList instance_type) const
  {
    ASSERT(names.count(instance_type) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::getProduct() - enum type "+toString(instance_type)+" is not registered.");
    return ManipulablePrototypeTable[instance_type]->clone();
  }

  /** Getter for desired type of product.
   *
   * @param instance_name name of product
   * @return reference to copy of product
   */
  T* getProduct(const std::string instance_name) const
  {
    ASSERT(enums.count(instance_name) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::getProduct() - type name "+instance_name+" is not registered.");
    return ManipulablePrototypeTable[ enums[instance_name] ]->clone();
  }

  /** Getter for desired type of product.
   *
   * @param instance_type_info object of the desired type
   * @return reference to copy of current type product or NULL if type mismatch
   */
  T* getProduct(const std::type_info &instance_type_info) const
  {
    ASSERT(types.count(instance_type_info.name()) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::getProduct() - type info name "+instance_type_info.name()+" is not registered.");
    return ManipulablePrototypeTable[ types[instance_type_info.name()] ]->clone();
  }

  /** Getter for current type of product.
   *
   * @return reference to copy of current type product
   */
  T* getProduct() const
  {
    return ManipulablePrototypeTable[currenttype]->create();
  }

  /** Getter for the name of the desired type of product.
   *
   * @return name of distribution
   */
  const std::string &getName(TypeList instance_type) const
  {
    ASSERT(names.count(instance_type) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::getName() - enum type "+toString(instance_type)+" is not registered.");
    return names[instance_type];
  }

  /** Getter for the enumeration index of the desired type of product.
   *
   * @return enum of distribution
   */
  TypeList getEnum(const std::string instance_name) const
  {
   ASSERT(enums.count(instance_name) != 0,
       "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::getEnum() - type name "+instance_name+" is not registered.");
   return enums[instance_name];
  }


protected:
  /** Yields true prototype of the product and sets entry to NULL on
   *  PrototypeTable.
   *
   * @warning This method is \b intentionally protected such that only
   * specific friends are allowed to access it.
   * @warning This method performs a dynamic_cast from Clone<IPrototype>* to
   * IPrototype*. This prevents also that prototype is cloneable outside of
   * factory.
   *
   * @param instance_name name of product
   * @return reference to prototype stored in this factory
   */
  T& getPrototype(const std::string instance_name)
  {
    ASSERT(enums.count(instance_name) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::getPrototype() - type name "+instance_name+" is not registered.");
    T* prototype = dynamic_cast<T *>(ManipulablePrototypeTable[ enums[instance_name] ]);
    return *prototype;
  }

  /** Yields true prototype of the product and sets entry to NULL on
   *  PrototypeTable.
   *
   * @warning This method is \b intentionally protected such that only
   * specific friends are allowed to access it.
   *
   * @param enumeration index of product
   * @return reference to prototype stored in this factory
   */
  T& getPrototype(TypeList instance_type)
  {
    ASSERT(names.count(instance_type) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::getPrototype() - enum type "+toString(instance_type)+" is not registered.");
    T* prototype = dynamic_cast<T *>(ManipulablePrototypeTable[instance_type]);
    return *prototype;
  }

  /** Yields true prototype of the product and sets entry to NULL on
   *  PrototypeTable.
   *
   * @warning This method is \b intentionally protected such that only
   * specific friends are allowed to access it.
   *
   * @param instance_type_info object of the desired type
   * @return reference to prototype stored in this factory
   */
  T& getPrototype(const std::type_info &instance_type_info)
  {
    ASSERT(types.count(instance_type_info.name()) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::getPrototype() - type info name "+instance_type_info.name()+" is not registered.");
    T* prototype = dynamic_cast<T *>(ManipulablePrototypeTable[ types[instance_type_info.name()] ]);
    return *prototype;
  }

  /** Yields true prototype of the currenttype product and sets entry to NULL
   *  on PrototypeTable.
   *
   * @warning This method is \b intentionally protected such that only
   * specific friends are allowed to access it.
   *
   * @return reference to prototype stored in this factory
   */
  T& getPrototype()
  {
    T* prototype = dynamic_cast<T *>(ManipulablePrototypeTable[ currenttype ]);
    return *prototype;
  }

  /** Allows for manipulation of the installed prototype via its constructor
   * and a defined set of parameters.
   *
   * @param instance_name name of product
   * @param _params set of parameters
   */
  void manipulatePrototype(const std::string instance_name, const ParamT &_params)
  {
    ASSERT(enums.count(instance_name) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::manipulatePrototype() - type name "+instance_name+" is not registered.");
    ManipulableClone<T, ParamT> * prototype = ManipulablePrototypeTable[ enums[instance_name] ];
    ManipulablePrototypeTable[ enums[instance_name] ] = prototype->manipulatedclone(_params);
    delete prototype;
  }

  /** Allows for manipulation of the installed prototype via its constructor
   * and a defined set of parameters.
   *
   * @param enumeration index of product
   * @param _params set of parameters
   */
  void manipulatePrototype(TypeList instance_type, const ParamT &_params)
  {
    ASSERT(names.count(instance_type) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::manipulatePrototype() - enum type "+toString(instance_type)+" is not registered.");
    ManipulableClone<T, ParamT> * prototype = ManipulablePrototypeTable[ instance_type ];
    ManipulablePrototypeTable[ instance_type ] = prototype->manipulatedclone(_params);
    delete prototype;
  }

  /** Allows for manipulation of the installed prototype via its constructor
   * and a defined set of parameters.
   *
   * @param instance_type_info object of the desired type
   * @param _params set of parameters
   */
  void manipulatePrototype(const std::type_info &instance_type_info, const ParamT &_params)
  {
    ASSERT(types.count(instance_type_info.name()) != 0,
        "ManipulablePrototypeFactory<"+toString(typeid(T).name())+">::manipulatePrototype() - type info name "+instance_type_info.name()+" is not registered.");
    ManipulableClone<T, ParamT> * prototype = ManipulablePrototypeTable[ types[instance_type_info.name()] ];
    ManipulablePrototypeTable[ types[instance_type_info.name()] ] = prototype->manipulatedclone(_params);
    delete prototype;
  }

  /** Allows for manipulation of the installed prototype via its constructor
   * and a defined set of parameters.
   *
   * @param _params set of parameters
   */
  void manipulatePrototype(const ParamT &_params)
  {
    ManipulableClone<T, ParamT> * prototype = ManipulablePrototypeTable[ currenttype ];
    ManipulablePrototypeTable[ currenttype ] = prototype->manipulatedclone(_params);
    delete prototype;
  }

  /** Creates instances of all possible distribution types
   *  and stores them in \a DistributionPrototypeTable.
   *
   *  @note This has to be handed down to the actual implementation of the
   *  desired prototype factory class as cstor and dstor of the abstract
   *  encapsulation class are protected (of a @ref <Clone> (Clone)) and hence
   *  cannot be accessed from this class (because we cannot befriend it from
   *  here).
   */
  virtual void FillPrototypeTable() = 0;

  /** Removes all prototypes from \a PrototypeTable and free's memory.
   *
   *  \sa FillPrototypeTable()
   */
  virtual void EmptyPrototypeTable() = 0;

  /** Create association for enums to strings and vice versa
   *  and stores them in \a distributions tables.
   */
  void FillEnumTable();

  typedef std::map<
      std::string,
      TypeList
      > TypeMap;
  typedef std::map<
      std::string,
      TypeList
      > EnumMap;
  typedef std::map<
      TypeList,
      ManipulableClone<T,ParamT> *
      > InstanceTable;
  typedef std::map<
      TypeList,
      std::string
      > NameMap;

  static TypeList currenttype;
  static TypeMap types;
  static EnumMap enums;
  static InstanceTable ManipulablePrototypeTable;
  static NameMap names;
};

template <class T, class ParamT> typename ManipulablePrototypeFactory<T,ParamT>::TypeList ManipulablePrototypeFactory<T,ParamT>::currenttype = (typename ManipulablePrototypeFactory<T,ParamT>::TypeList)0;
template <class T, class ParamT> typename ManipulablePrototypeFactory<T,ParamT>::TypeMap ManipulablePrototypeFactory<T,ParamT>::types;
template <class T, class ParamT> typename ManipulablePrototypeFactory<T,ParamT>::EnumMap ManipulablePrototypeFactory<T,ParamT>::enums;
template <class T, class ParamT> typename ManipulablePrototypeFactory<T,ParamT>::NameMap ManipulablePrototypeFactory<T,ParamT>::names;
template <class T, class ParamT> typename ManipulablePrototypeFactory<T,ParamT>::InstanceTable ManipulablePrototypeFactory<T,ParamT>::ManipulablePrototypeTable;

/**
 * This define allows simple instantiation of the necessary factory functions
 * at a chosen place.
 */
#define CONSTRUCT_MANIPULABLEPROTOTYPEFACTORY(InstanceType, ParamType) \
    template ManipulablePrototypeFactory<InstanceType, ParamType>::ManipulablePrototypeFactory(); \
    template ManipulablePrototypeFactory<InstanceType, ParamType>::~ManipulablePrototypeFactory(); \
    template void ManipulablePrototypeFactory<InstanceType, ParamType>::setCurrentType(const std::string instance_name); \
    template void ManipulablePrototypeFactory<InstanceType, ParamType>::setCurrentType(TypeList instance_type); \
    template const std::string & ManipulablePrototypeFactory<InstanceType, ParamType>::getCurrentTypeName() const; \
    template ManipulablePrototypeFactory<InstanceType, ParamType>::TypeList ManipulablePrototypeFactory<InstanceType, ParamType>::getCurrentTypeEnum() const; \
    template InstanceType* ManipulablePrototypeFactory<InstanceType, ParamType>::getProduct(TypeList instance_type) const; \
    template InstanceType* ManipulablePrototypeFactory<InstanceType, ParamType>::getProduct(const std::string instance_name) const; \
    template const std::string &ManipulablePrototypeFactory<InstanceType, ParamType>::getName(TypeList instance_type) const; \
    template ManipulablePrototypeFactory<InstanceType, ParamType>::TypeList ManipulablePrototypeFactory<InstanceType, ParamType>::getEnum(const std::string instance_name) const;


#endif /* MANIPULABLEPROTOTYPEFACTORY_HPP_ */