service_tools.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2011-06-07
 * Last modified : 2017-07-13
 *
 * Copyright (C) 2011-2017 Francois Mauger <mauger@lpccaen.in2p3.fr>
 *
 * 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:
 *
 *   Service tools, typedefs.
 *
 */

#ifndef DATATOOLS_SERVICE_TOOLS_H
#define DATATOOLS_SERVICE_TOOLS_H

// Standard Library:
#include <string>
#include <map>
#include <vector>
#include <memory>

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

// This project:
#include <datatools/exception.h>
#include <datatools/handle.h>
#include <datatools/i_tree_dump.h>
#include <datatools/properties.h>
#include <datatools/bit_mask.h>

namespace datatools {

  class base_service;
  typedef datatools::handle<base_service> service_handle_type;

  enum dependency_level_type {
    DEPENDENCY_UNKNOWN  = -1, 
    DEPENDENCY_NONE     =  0, 
    DEPENDENCY_OPTIONAL =  1, 
    DEPENDENCY_WEAK     =  2, 
    DEPENDENCY_STRICT   =  3  
  };

  struct dependency_info_type {

    std::string id;              
    std::string version;         
    std::string meta;            
    dependency_level_type level; 
    dependency_info_type();
    void reset();
  };

  // Long typedef names
  typedef std::map<std::string, int> dependency_level_dict_type;
  typedef std::map<std::string, dependency_info_type> service_dependency_dict_type;

  class service_manager;

  class service_entry
    : public datatools::i_tree_dumpable
  {
  public:

    enum status_type {
      STATUS_BLANK             = 0,                          
      STATUS_CREATED           = datatools::bit_mask::bit00, 
      STATUS_INITIALIZED       = datatools::bit_mask::bit01, 
      STATUS_BROKEN_DEPENDENCY = datatools::bit_mask::bit02  
    };

  public:

    service_entry();

    service_entry(const std::string & name_, service_manager & mgr_);

    ~service_entry();

    const std::string & get_service_name() const;

    void set_service_name(const std::string &);

    const std::string & get_service_id() const;

    void set_service_id(const std::string &);

    const datatools::properties & get_service_config() const;

    datatools::properties & grab_service_config();

    void set_service_config(const datatools::properties &);

    bool can_be_dropped() const;

    uint32_t get_service_status() const;

    void update_service_status(uint32_t);

    void reset_service_status(uint32_t);

    bool is_created() const;

    bool is_initialized() const;

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

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

    const service_handle_type & get_service_handle() const;

    service_handle_type & grab_service_handle();

    bool has_service_manager() const;

    void set_service_manager(service_manager & smgr_);

    const service_manager & get_service_manager() const;

    service_manager & grab_service_manager();

  private:
    
    std::string           service_name;   
    service_manager *     manager = nullptr; 
    std::string           service_id;     
    datatools::properties service_config; 
    uint32_t              service_status = STATUS_BLANK; 
    service_handle_type   service_handle; 
    
  public:
    
    // Not supported for now:
    service_dependency_dict_type service_masters; 
    // dependency_level_dict_type   service_slaves;  ///< The list of depending services (by names)
    
  };

  typedef std::shared_ptr<service_entry> service_entry_ptr;

  typedef std::map<std::string, service_entry_ptr> service_dict_type;

  bool service_exists(const service_dict_type & services_,
                      const std::string & service_name_);

  bool service_of_type_exists(const service_dict_type & services_,
                              const std::string & service_type_id_,
                              const std::string & service_name_);

  void merge_services(service_dict_type & services_,
                      service_dict_type & merged_,
                      bool duplicate_throw_ = false);

  bool find_service_name_with_id(const service_dict_type & services_,
                                 const std::string & service_type_id_,
                                 std::string & service_name_);

  bool find_service_names_with_id(const service_dict_type & services_,
                                  const std::string & service_type_id_,
                                  std::vector<std::string> & service_names_);

  base_service & grab_service(service_dict_type & services_,
                              const std::string & service_name_);

  const base_service & get_service(const service_dict_type & services_,
                                   const std::string & service_name_);

}  // end of namespace datatools

#endif // DATATOOLS_SERVICE_TOOLS_H

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