objfactory.h

Go to the documentation of this file.

// -*- C++ -*-
/*! @file
 * @brief Factory class for objects from XML input
 */
 
#ifndef __objfact_h__
#define __objfact_h__
 
#include "chromabase.h"
 
#include "typeinfo.h"
#include "typelist.h"
#include <map>
#include <exception>
 
 
namespace Chroma
{
 
////////////////////////////////////////////////////////////////////////////////
// class template DefaultFactoryError
// Manages the "Unknown Type" error in an object factory
////////////////////////////////////////////////////////////////////////////////
 
  template <typename IdentifierType, class AbstractProduct>
  struct DefaultFactoryError
  {
    struct Exception : public std::exception
    {
      const char* what() const throw() { return "Unknown Type"; }
    };
        
    static AbstractProduct* OnUnknownType(const IdentifierType& id)
      {
        throw Exception();
      }
  };
 
////////////////////////////////////////////////////////////////////////////////
// class template StringFactoryError
// Manages the "Unknown Type" error in an object factory
////////////////////////////////////////////////////////////////////////////////
 
  template <typename IdentifierType, class AbstractProduct>
  struct StringFactoryError
  {
    static AbstractProduct* OnUnknownType(const IdentifierType& id)
      {
        std::ostringstream os;
        os << "Factory error: unknown identifier: id = " << id << std::endl;
        throw os.str();
      }
  };
 
////////////////////////////////////////////////////////////////////////////////
// class template NullFactoryError
// Manages the "Unknown Type" error in an object factory
////////////////////////////////////////////////////////////////////////////////
 
  template <typename IdentifierType, class AbstractProduct>
  struct NullFactoryError
  {
    static AbstractProduct* OnUnknownType(const IdentifierType&)
      {
        return 0;
      }
  };
 
 
//! Object factory class
/*! @ingroup actions
 *
 * Supports abstract creation of objects
 */
  template<class AbstractProduct, 
           typename IdentifierType,
           class TList = NullType,
           typename ProductCreator = AbstractProduct* (*)(),
           template<typename, class>
             class FactoryErrorPolicy = DefaultFactoryError>
  class ObjectFactory : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
  {
  public:
    // Handy type definitions for the body type
    typedef TList ParmList;
    typedef typename TL::TypeAtNonStrict<ParmList,0,NullType>::Result  Parm1;
    typedef typename TL::TypeAtNonStrict<ParmList,1,NullType>::Result  Parm2;
    typedef typename TL::TypeAtNonStrict<ParmList,2,NullType>::Result  Parm3;
    typedef typename TL::TypeAtNonStrict<ParmList,3,NullType>::Result  Parm4;
    typedef typename TL::TypeAtNonStrict<ParmList,4,NullType>::Result  Parm5;
    typedef typename TL::TypeAtNonStrict<ParmList,5,NullType>::Result  Parm6;
    typedef typename TL::TypeAtNonStrict<ParmList,6,NullType>::Result  Parm7;
    typedef typename TL::TypeAtNonStrict<ParmList,7,NullType>::Result  Parm8;
    typedef typename TL::TypeAtNonStrict<ParmList,8,NullType>::Result  Parm9;
 
    // Member functions
    //! Register the object
    /*! 
     * \param id       object id
     * \param creator  the callback function to create the object
     * \return returns true if registration successful
     */
    bool registerObject(const IdentifierType& id, ProductCreator creator)
      {
        return associations_.insert(
          typename IdToProductMap::value_type(id, creator)).second;
      }
  
    //! Unregister the object
    /*! 
     * \param id       object id
     * \return returns true if object name was registered before
     */
    bool unregisterObject(const IdentifierType& id)
      {
        return associations_.erase(id) == 1;
      }
 
    //! Create the object
    /*! 
     * \param id       object id
     * \return returns pointer to the object
     */
    AbstractProduct* createObject(const IdentifierType& id)
    {
      typename IdToProductMap::const_iterator i = associations_.find(id);
      if (i == associations_.end()) {
        
        typedef typename IdToProductMap::const_iterator CI;
        QDPIO::cerr << "Couldnt find key " << id << " in the std::map: " << std::endl;
        QDPIO::cerr << "Available Keys are : " << std::endl;
        for( CI j = associations_.begin();
             j != associations_.end(); j++) {
          QDPIO::cerr << j->first << std::endl << std::flush;
        }
        
        return this->OnUnknownType(id);
      }
      else {
        return (i->second)();
      }
    }
        
    //! Create the object
    /*! 
     * \param id       object id
     * \param p1       first parameter arg to callback
     * \return returns pointer to the object
     */
    AbstractProduct* createObject(const IdentifierType& id, Parm1 p1)
    {
      typename IdToProductMap::const_iterator i = associations_.find(id);
      if (i == associations_.end()) {
        
        typedef typename IdToProductMap::const_iterator CI;
        QDPIO::cerr << "Couldnt find key " << id << " in the std::map: " << std::endl;
        QDPIO::cerr << "Available Keys are : " << std::endl;
        for( CI j = associations_.begin();
             j != associations_.end(); j++) {
          QDPIO::cerr << j->first << std::endl << std::flush;
        }
 
        return this->OnUnknownType(id);
      }
      else {
        return (i->second)(p1);
      }
    }
        
    AbstractProduct* createObject(const IdentifierType& id, Parm1 p1, Parm2 p2)
    {
      typename IdToProductMap::const_iterator i = associations_.find(id);
      if (i == associations_.end()) {
 
        typedef typename IdToProductMap::const_iterator CI;
        QDPIO::cerr << "Couldnt find key " << id << " in the std::map: " << std::endl;
        QDPIO::cerr << "Available Keys are : " << std::endl;
        for( CI j = associations_.begin();
             j != associations_.end(); j++) {
          QDPIO::cerr << j->first << std::endl << std::flush;
        }
        
        return this->OnUnknownType(id);
      }
      else {
          return (i->second)(p1, p2);
      }
    }
    
    AbstractProduct* createObject(const IdentifierType& id, Parm1 p1, Parm2 p2, Parm3 p3)
    {
      typename IdToProductMap::const_iterator i = associations_.find(id);
      if (i == associations_.end()) {
        
        typedef typename IdToProductMap::const_iterator CI;
        QDPIO::cerr << "Couldnt find key " << id << " in the std::map: " << std::endl;
        QDPIO::cerr << "Available Keys are : " << std::endl;
        for( CI j = associations_.begin();
             j != associations_.end(); j++) {
          QDPIO::cerr << j->first << std::endl << std::flush;
        }
        
        return this->OnUnknownType(id);
      }
      else {
          return (i->second)(p1, p2, p3);
      }
    }
        
    AbstractProduct* createObject(const IdentifierType& id, Parm1 p1, Parm2 p2, Parm3 p3,
                                  Parm4 p4)
    {
      typename IdToProductMap::const_iterator i = associations_.find(id);
      if (i == associations_.end()) {
        
        typedef typename IdToProductMap::const_iterator CI;
        QDPIO::cerr << "Couldnt find key " << id << " in the std::map: " << std::endl;
        QDPIO::cerr << "Available Keys are : " << std::endl;
        for( CI j = associations_.begin();
             j != associations_.end(); j++) {
          QDPIO::cerr << j->first << std::endl << std::flush;
        }
        
        return this->OnUnknownType(id);
      }
      else {
        return (i->second)(p1, p2, p3, p4);
      }
    }
        
    AbstractProduct* createObject(const IdentifierType& id, Parm1 p1, Parm2 p2, Parm3 p3,
                                  Parm4 p4, Parm5 p5)
    {
      typename IdToProductMap::const_iterator i = associations_.find(id);
      if (i == associations_.end()) {
        
        typedef typename IdToProductMap::const_iterator CI;
        QDPIO::cerr << "Couldnt find key " << id << " in the std::map: " << std::endl;
        QDPIO::cerr << "Available Keys are : " << std::endl;
        for( CI j = associations_.begin();
             j != associations_.end(); j++) {
          QDPIO::cerr << j->first << std::endl << std::flush;
        }
        
        return this->OnUnknownType(id);
      }
      else {
        return (i->second)(p1, p2, p3, p4, p5);
      }
    }
 
    AbstractProduct* createObject(const IdentifierType& id, Parm1 p1, Parm2 p2, Parm3 p3,
                                  Parm4 p4, Parm5 p5, Parm6 p6)
    {
      typename IdToProductMap::const_iterator i = associations_.find(id);
      if (i == associations_.end()) {
        
        typedef typename IdToProductMap::const_iterator CI;
        QDPIO::cerr << "Couldnt find key " << id << " in the std::map: " << std::endl;
        QDPIO::cerr << "Available Keys are : " << std::endl;
        for( CI j = associations_.begin();
             j != associations_.end(); j++) {
          QDPIO::cerr << j->first << std::endl << std::flush;
        }
        
        return this->OnUnknownType(id);
      }
      else {
        return (i->second)(p1, p2, p3, p4, p5, p6);
      }
    }
 
    AbstractProduct* createObject(const IdentifierType& id, Parm1 p1, Parm2 p2, Parm3 p3,
                                  Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7)
    {
      typename IdToProductMap::const_iterator i = associations_.find(id);
      if (i == associations_.end()) {
        
        typedef typename IdToProductMap::const_iterator CI;
        QDPIO::cerr << "Couldnt find key " << id << " in the std::map: " << std::endl;
        QDPIO::cerr << "Available Keys are : " << std::endl;
        for( CI j = associations_.begin();
             j != associations_.end(); j++) {
          QDPIO::cerr << j->first << std::endl << std::flush;
        }
        
        return this->OnUnknownType(id);
      }
      else {
        return (i->second)(p1, p2, p3, p4, p5, p6, p7);
      }
    }
 
    AbstractProduct* createObject(const IdentifierType& id, Parm1 p1, Parm2 p2, Parm3 p3,
                                  Parm4 p4, Parm5 p5, Parm6 p6, Parm7 p7, Parm8 p8)
    {
      typename IdToProductMap::const_iterator i = associations_.find(id);
      if (i == associations_.end()) {
        
        typedef typename IdToProductMap::const_iterator CI;
        QDPIO::cerr << "Couldnt find key " << id << " in the std::map: " << std::endl;
        QDPIO::cerr << "Available Keys are : " << std::endl;
        for( CI j = associations_.begin();
             j != associations_.end(); j++) {
          QDPIO::cerr << j->first << std::endl << std::flush;
        }
        
        return this->OnUnknownType(id);
      }
      else {
        return (i->second)(p1, p2, p3, p4, p5, p6, p7, p8);
      }
    }
 
  
  private:
    typedef std::map<IdentifierType, ProductCreator> IdToProductMap;
    IdToProductMap associations_;
  };
 
}   // namespace Chroma
 
#endif