manager.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-02-21
 * Last modified: 2013-02-19
 *
 * License:
 *
 * Copyright 2007-2013 F. Mauger
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public  License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * Description:
 *
 *   Geometry manager
 *
 * History:
 *
 */

#ifndef GEOMTOOLS_MANAGER_H
#define GEOMTOOLS_MANAGER_H 1

// Standard library:
#include <string>
#include <map>

// Third party:
// - Boost:
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
// - Bayeux/datatools:
#include <datatools/handle.h>
#include <datatools/properties.h>
#include <datatools/multi_properties.h>
#include <datatools/service_tools.h>
#include <datatools/factory_macros.h>
#include <datatools/i_tree_dump.h>
#include <datatools/logger.h>

// This project:
#include <geomtools/shape_factory.h>
#include <geomtools/model_factory.h>
#include <geomtools/id_mgr.h>
#include <geomtools/mapping.h>

namespace datatools {
  // Forward declaration:
  class version_id;
}

namespace geomtools {

  class manager : public datatools::i_tree_dumpable
  {
  public:

    // Forward declaration:
    class plugin_entry;

    typedef std::map<std::string, plugin_entry> plugins_dict_type;

    class base_plugin
    {
    public:

      base_plugin();

      virtual ~base_plugin();

      void set_geo_manager(manager & geo_mgr_);

      const manager & get_geo_manager() const;

      virtual int initialize_standalone(const datatools::properties& config);

      virtual int initialize_simple(const datatools::properties & config_,
                                    const plugins_dict_type & plugins_);

      virtual int initialize(const datatools::properties & config_,
                             const plugins_dict_type & plugins_,
                             const datatools::service_dict_type & services_) = 0;

      virtual int reset() = 0;

      virtual bool is_initialized() const = 0;

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

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

    protected:

      void _basic_initialize(const datatools::properties & config_);

      manager & _grab_geo_manager();

      bool _has_geom_setup_requirement() const;

      void _check_geom_setup_requirement() const;

      datatools::logger::priority _logging; 

    private:

      manager * _geo_mgr_;                                
      std::vector<std::string> _geom_setup_requirements_; 

      // Factory stuff :
      DATATOOLS_FACTORY_SYSTEM_REGISTER_INTERFACE(base_plugin)
    };

    typedef datatools::handle<base_plugin> plugin_handle_type;

    class plugin_entry : public datatools::i_tree_dumpable
    {
    public:

      enum status_type {
        STATUS_BLANK        = 0x0, 
        STATUS_CREATED      = 0x1, 
        STATUS_INITIALIZED  = 0x2 
      };

      void set_name(const std::string&);

      const std::string& get_name() const;

      const std::string& get_id() const;

      void set_description(const std::string&);

      bool has_description() const;

      const std::string& get_description() const;

      const datatools::properties & get_config() const;

      void set_config(const datatools::properties &);

      datatools::properties & grab_config();

      bool is_created() const;

      bool is_initialized() const;

      bool can_be_dropped() const;

      plugin_entry();

      ~plugin_entry();

      base_plugin & grab();

      const base_plugin & get() const;

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

    protected:

      void _set_status(uint32_t);

    public:

      std::string        _name_;        
      std::string        _id_;          
      std::string        _description_; 
      datatools::properties _config_;   
      uint32_t           _status_;      
      plugin_handle_type _handle_;      

      // friend class manager;
    };

    bool is_debug() const;

    bool is_verbose() const;

    bool is_initialized() const;

    bool has_services() const;

    void set_services(datatools::service_dict_type & services_);

    void reset_services();

    void set_setup_label(const std::string &);

    const std::string & get_setup_label() const;

    void set_setup_version(const std::string &);

    const std::string & get_setup_version() const;

    void set_setup_description(const std::string &);

    const std::string & get_setup_description() const;

    void fetch_setup_version_id(datatools::version_id & vid_) const;

    void set_mapping_requested(bool);

    bool is_mapping_requested() const;

    bool is_mapping_available() const;

    void set_world_name(const std::string &);

    const std::string & get_world_name() const;

    void build_mapping(const datatools::properties & config_);

    const geomtools::shape_factory & get_shape_factory() const;

    geomtools::shape_factory & grab_shape_factory();

    const geomtools::model_factory & get_factory() const;

    geomtools::model_factory & grab_factory();

    const geomtools::id_mgr & get_id_mgr() const;

    geomtools::id_mgr & grab_id_mgr();

    const geomtools::mapping & get_mapping(const std::string & mapping_name_ = "") const;

    /* Plugins management */

    bool can_drop_plugin(const std::string& plugin_name_);

    void drop_plugin(const std::string& plugin_name_);

    void load_plugin(const std::string& plugin_name_,
                     const std::string& plugin_id_,
                     const datatools::properties& plugin_config_,
                     bool only_lock_ = false);

    void load_plugins(const datatools::multi_properties& plugin_config_,
                      bool only_lock_ = false);

    const plugins_dict_type & get_plugins() const;

    plugins_dict_type & grab_plugins();

    template<class T>
    bool is_plugin_a(const std::string & a_plugin_name) const;

    template<class T>
    T& grab_plugin(const std::string & a_plugin_name);

    template<class T>
    const T& get_plugin(const std::string & a_plugin_name) const;

    bool has_plugin(const std::string & a_plugin_name) const;

    void print_plugins(std::ostream& out = std::clog,
                       const std::string& title  = "",
                       const std::string& indent = "") const;

    void clear_plugins();

    bool has_plugin_type(const std::string& plugin_id) const;

    template <class PluginClass>
    void register_plugin_type(const std::string& plugin_id);

    void unregister_plugin_type(const std::string& plugin_id);

    /* Main interface */

    manager();

    virtual ~manager();

    void init(const datatools::properties & config_);

    void initialize(const datatools::properties & config_);

    void reset();

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

    const base_plugin::factory_register_type & get_plugins_factory_register();

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

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

    static int print_list_of_gids(const geomtools::manager & mgr_,
                                  const std::string & command_,
                                  const std::string & rules_ = "",
                                  std::ostream & out_ = std::clog);

  protected:

    virtual void _pre_init(const datatools::properties & config_);

    virtual void _post_init(const datatools::properties & config_);

    void _load_plugin(const std::string& name,
                      const std::string& id,
                      const datatools::properties& config);

    void _preload_plugins_global_dict();

    void _create_plugin(plugin_entry& entry);

    void _initialize_plugin(plugin_entry& entry);

    void _reset_plugin(plugin_entry& entry);

  private:

    virtual void _at_init_(const datatools::properties & config_);

    void _init_plugins_(const datatools::properties & config_);

  protected:

    datatools::logger::priority _logging; 

  private:

    bool                     _initialized_;       
    std::string              _setup_label_;       
    std::string              _setup_version_;     
    std::string              _setup_description_; 

    datatools::service_dict_type * _services_;    

    geomtools::shape_factory _shape_factory_;     
    geomtools::model_factory _factory_;           
    geomtools::id_mgr        _id_manager_;        
    bool                     _mapping_requested_; 
    geomtools::mapping       _mapping_;           
    datatools::multi_properties _external_mapping_rules_; 

    std::string              _world_name_;        

    bool                                _plugins_factory_preload_;  
    bool                                _plugins_force_initialization_at_load_; 
    base_plugin::factory_register_type  _plugins_factory_register_; 
    plugins_dict_type                   _plugins_;                  

  };

} // end of namespace geomtools

/***************
 * OCD support *
 ***************/
#include <datatools/ocd_macros.h>
DOCD_CLASS_DECLARATION(geomtools::manager)

#include <geomtools/detail/manager-inl.h>

#endif // GEOMTOOLS_MANAGER_H

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