factory.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2012-03-19
 * Last modified : 2013-04-22
 *
 */

#ifndef DATATOOLS_FACTORY_H
#define DATATOOLS_FACTORY_H

// Standard Library:
#include <string>
#include <map>
#include <vector>
#include <iostream>
#include <sstream>
#include <stdexcept>

// Third Party:
// - Boost:
#include <boost/function.hpp>
#include <boost/functional/factory.hpp>
#include <boost/scoped_ptr.hpp>

// This project:
#include <datatools/i_tree_dump.h>
#include <datatools/exception.h>
#include <datatools/logger.h>

namespace datatools {
  class base_factory_register
  {
  public:
    enum flag_type {
      verbose = 0x1
    };

    base_factory_register();

    virtual ~base_factory_register ();
  };


  template <class BaseType>
  class factory_register
    : public base_factory_register
    ,  public datatools::i_tree_dumpable
  {
  public:

    typedef BaseType                       base_type;
    typedef boost::function<base_type*() > factory_type;

    struct factory_record_type {
      std::string  type_id;
      factory_type fact;
      const std::type_info * tinfo = nullptr;
      std::string  description;
      std::string  category;
    };
    
    typedef std::map<std::string, factory_record_type> factory_map_type;

    factory_register();

    factory_register(const std::string & label_, unsigned int flags_ = 0x0);

    virtual ~factory_register();

    datatools::logger::priority get_logging_priority() const;

    void set_logging_priority(datatools::logger::priority logging_);

    const std::string & get_label() const;

    void set_label(const std::string & label_);

    void list_of_factories(std::vector<std::string> & ids_) const;

    bool has(const std::string & id_) const;

    bool is_group(const std::string & id_) const;

    void clear();

    void reset();

    factory_type & grab(const std::string & id_);

    const factory_type & get(const std::string & id_) const;

    const factory_record_type & get_record(const std::string & id_) const;

    void registration(const std::string & id_,
                      const factory_type & factory_,
                      const std::type_info & tinfo_,
                      const std::string & description_ = "",
                      const std::string & category_ = "");

    template<class DerivedType>
    void registration(const std::string & id_,
                      const std::string & description_ = "",
                      const std::string & category_ = "");

    template<class DerivedType>
    bool fetch_type_id(std::string & id_) const;

    bool fetch_type_id(const std::type_info & tinfo_, std::string & id_) const;
                      
    void unregistration(const std::string & id_);

    void import(const factory_register & factory_register_);

    void import_some(const factory_register & factory_register_,
                     const std::vector<std::string> & imported_factories_);

    void print(std::ostream & out_, const std::string & indent_ = "") const;

    virtual void tree_dump(std::ostream & out_ = std::clog,
                           const std::string& title_ = "",
                           const std::string& indent_ = "",
                           bool inherit_ = false) const;

  private:

    std::string                 _label_;      
    datatools::logger::priority _logging_;    
    factory_map_type            _registered_; 

  };

} // end of namespace datatools

// Template definitions:
#include <datatools/factory-inl.h>

// Boost:
#include <boost/type_traits/is_base_of.hpp>

namespace datatools {

  template <class BaseType, class DerivedType>
  class _system_factory_registrator
  {
  public:

    // Constructor
    _system_factory_registrator(const std::string & type_id_)
    {
      _type_info_ = &typeid(DerivedType);
      _type_id_ = type_id_;
      this->_trigger_factory_registration_();
      return;
    }

    // Destructor
    ~_system_factory_registrator()
    {
      this->_trigger_factory_unregistration_();
      return;
    }

    const std::string & get_type_id()const
    {
      return _type_id_;
    }

  private:

    // Factory registration
    void _trigger_factory_registration_()
    {
      bool fatal = !boost::is_base_of<BaseType, DerivedType>::value;
      DT_THROW_IF(fatal,
                  std::logic_error,
                  "Class ID '" << _type_id_ << "' cannot be registered in register '"
                  << BaseType::grab_system_factory_register().get_label() << "' !");
      BaseType::grab_system_factory_register().registration(_type_id_,
                                                            boost::factory<DerivedType*>(),
                                                            typeid(DerivedType));
      return;
    }

    // Factory unregistration
    void _trigger_factory_unregistration_()
    {
      if (BaseType::grab_system_factory_register().has(_type_id_)) {
        BaseType::grab_system_factory_register().unregistration(_type_id_);
      }
      return;
    }

  private:

    const std::type_info * _type_info_ = nullptr;
    std::string _type_id_; 
    
    
  };

} // end of namespace datatools

#endif // DATATOOLS_FACTORY_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --