service_manager.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2011-06-07
 * Last modified : 2017-11-02
 *
 * Copyright (C) 2011-2017 Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Copyright (C) 2012 Ben Morgan <Ben.Morgan@warwick.ac.uk>
 *
 * 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:
 *
 *   A service manager.
 *
 */

#ifndef DATATOOLS_SERVICE_MANAGER_H
#define DATATOOLS_SERVICE_MANAGER_H

// Standard Library:
#include <string>
#include <sstream>
#include <typeinfo>
#include <stdexcept>

// Third Party:
// - Boost:
#include <boost/cstdint.hpp>

// This project:
#include <datatools/service_tools.h>
#include <datatools/base_service.h>
#include <datatools/i_tree_dump.h>
#include <datatools/properties.h>
#include <datatools/bit_mask.h>

namespace datatools {

  class properties;
  class multi_properties;

  class service_manager
    : public datatools::i_tree_dumpable
  {
  public:

    enum flag_type {
      BLANK                        = 0,                          
      NO_PRELOAD                   = datatools::bit_mask::bit00, 
      FORCE_INITIALIZATION_AT_LOAD = datatools::bit_mask::bit01, 
      FACTORY_VERBOSE              = datatools::bit_mask::bit02, 
      ALLOW_DYNAMIC_SERVICES       = datatools::bit_mask::bit03  
    };

    /*
    struct dependee_manager_handle
    {
      dependee_manager_handle();
      ~dependee_manager_handle();
      void initialize(const service_manager &);
      void initialize(const datatools::properties & config_,
                      const std::string & name_ = "",
                      const std::string & description_ = "",
                      const uint32_t flags_ = 0);
      void reset();
      bool is_initialized() const;
      bool is_owned() const;
      const service_manager & get_manager() const;
    private:
      const service_manager * _manager_ = nullptr; //!< Handle to the dependee manager
      bool                    _owned_   = false;   //!< Dependee manager is managed by the handle itself
    };
    */

    // typedef std::map<std::string, dependee_manager_handle> mgr_dict_type;

    service_manager(const std::string & name_ = "",
                    const std::string & description_ = "",
                    uint32_t flag_ = BLANK);

    virtual ~service_manager();

    void set_name(const std::string& name_);

    void set_description(const std::string& description_);

    const std::string& get_name() const;

    const std::string& get_description() const;

    bool is_debug() const;

    void set_debug(bool debug_ = true);

    void set_allow_dynamic_services(bool);

    bool is_allow_dynamic_services() const;

    void set_force_initialization_at_load(bool);

    bool is_force_initialization_at_load() const;

    bool is_initialized() const;

    void initialize();

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

    void reset();

    // //! Check if external dependee managers are mounted
    // bool has_mounted_dependee_managers() const;

    // //! Check if external dependee manager can be mounted
    // bool can_mount_dependee_manager() const;

    // //! Mount an external dependee manager
    // void mount_dependee_manager(const service_manager &);

    // //! Unmount an external dependee managers
    // void unmount_dependee_managers();

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

    template <class ServiceClass>
    void register_service_type(const std::string& id_);

    void unregister_service_type(const std::string& id_);

    enum service_filter_flag {
       FILTER_NONE             = 0,                          
       FILTER_NO_INITIALIZED   = datatools::bit_mask::bit00, 
       FILTER_NO_UNINITIALIZED = datatools::bit_mask::bit01, 
       FILTER_NO_CLEAR         = datatools::bit_mask::bit02, 
       FILTER_FROM_BUS         = datatools::bit_mask::bit03  
    };

    void build_list_of_services(std::vector<std::string> & list_, uint32_t flags_ = 0);

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

    bool is_initialized(const std::string & name_) const;

    template <class T>
    bool is_a(const std::string & name_) const;

    template<class T>
    T& grab(const std::string & name_);

    template<class T>
    const T& get(const std::string & name_) const;

    base_service & grab_service(const std::string & name_);

    const base_service & get_service(const std::string & name_) const;

    bool can_drop(const std::string & name_) const;

    void drop(const std::string & name_);

    void load(const std::string & name_,
              const std::string & id_,
              const datatools::properties & config_);

    base_service & load_no_init(const std::string & name_,
                                const std::string & id_);

    void configure_no_init(const std::string& name_, const datatools::properties& config_);

    void load(const datatools::multi_properties& config_);

    const service_dict_type& get_local_services() const;

    const service_dict_type& get_bus_of_services(const bool update_ = false) const;

    void dump_services(std::ostream & out_ = std::clog,
                       const std::string& title_  = "",
                       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;

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

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

    void update_service_bus();

    void sync();

  protected:

    void load_service(const std::string& name_,
                      const std::string& id_,
                      const datatools::properties& config_);

    void load_service(const std::string& name_,
                      const std::string& id_,
                      const datatools::properties * config_ptr_);

    void preload_global_dict();

    void create_service(service_entry& entry_);

    void initialize_service(service_entry& entry_);

    void reset_service(service_entry& entry_);

    void destroy_service(service_entry& entry_);

    void at_service_creation(const std::string & service_name_, const std::string & service_type_id_);

    void at_service_initialization(const std::string & service_name_);

    void at_service_reset(const std::string & service_name_);

    void at_service_drop(const std::string & service_name_);

  private:

    void set_preload(bool preload_);

  private:

    datatools::logger::priority _logging_priority_ = datatools::logger::PRIO_FATAL; 
    bool         _initialized_ = false; 
    std::string  _name_;                
    std::string  _description_;         
    bool         _preload_ = false;     
    bool         _force_initialization_at_load_ = false; 
    bool         _allow_dynamic_services_ = false;       

    // 2012-04-09 FM : support for datatools::factory system :
    base_service::factory_register_type  _factory_register_;
    // mgr_dict_type                        _dependee_managers_; //!< Dictionary of dependee managers

    service_dict_type                    _local_services_; 

    service_dict_type                    _service_bus_; 

    friend class service_entry;
  };

}  // end of namespace datatools

#include <datatools/service_manager-inl.h>

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

#endif // DATATOOLS_SERVICE_MANAGER_H

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