urn_db_service.h

Go to the documentation of this file.

/* Author(s):     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2017-03-06
 * Last modified: 2017-03-31
 *
 * License:
 *
 * Copyright (C) 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:
 *
 *   URN information database.
 *
 */

#ifndef DATATOOLS_URN_DB_SERVICE_H
#define DATATOOLS_URN_DB_SERVICE_H

// Standard Library:
#include <string>
#include <map>
#include <set>

// Third party:
// - Boost:
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>

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

namespace datatools {

  class dependency_graph;

  /*
  */
  class urn_db_service
    : public ::datatools::base_service
  {
  public:

    struct dependee_db_entry
    {
      dependee_db_entry();
      explicit dependee_db_entry(const urn_db_service & db_);
      void make(const urn_db_service & db_);
      const urn_db_service & get_db() const;
    private:
      const urn_db_service * _db_ = nullptr;
    };

    typedef std::map<std::string, dependee_db_entry> dependee_db_dict_type;

    struct urn_record
    {
      bool is_local() const;
      bool is_mounted() const;
      bool is_valid() const;
      void make_local(const std::string & urn_,
                      const std::string & category_,
                      const std::string & description_);
      void make_mounted(const urn_db_service & mounted_db_,
                        const std::string & mounted_urn_);
      const urn_info & get() const;
    private:
      urn_info & _grab_();
    public:
      urn_info               _uinfo_;
      const urn_db_service * _mounted_db_ref_ = nullptr;
      const urn_info *       _mounted_uinfo_ = nullptr;
      friend urn_db_service;
    };

    typedef std::map<std::string, urn_record> urn_record_dict_type;

    struct backward_links
    {
      std::size_t get_number_of_links() const;
      bool is_linked_to_urn(const std::string & urn_) const;
      void add_link_to_urn(const std::string & urn_);
      void remove_link_to_urn(const std::string & urn_);
      void clear();
      const std::set<std::string> & get_urns() const;
    private:
      std::set<std::string> _urns_; 
    };

    typedef std::map<std::string, backward_links> backward_links_dict_type;

    urn_db_service();

    virtual ~urn_db_service();

    bool is_allow_mounted() const;

    void set_allow_mounted(bool m_);

    bool has_explicit_allowed_categories() const;

    bool has_allowed_category(const std::string & category_) const;

    void add_allowed_category(const std::string & category_);

    void remove_allowed_category(const std::string & category_);

    const std::set<std::string> & get_allowed_categories() const;

    bool check_category(const std::string & category_) const;

    bool has_allowed_link_topic(const std::string & link_topic_) const;

    bool has_explicit_allowed_link_topics() const;

    void add_allowed_link_topic(const std::string & link_topic_);

    void remove_allowed_link_topic(const std::string & link_topic_);

    const std::set<std::string> & get_allowed_link_topics() const;

    bool check_link_topic(const std::string & link_topic_) const;

    void connect_db(const urn_db_service & db_);

    bool has_dependees() const;

    std::set<std::string> get_dependees() const;

    virtual bool is_initialized() const;

    virtual int initialize(const datatools::properties & config_,
                           datatools::service_dict_type & services_);

    virtual int reset();

    virtual void tree_dump(std::ostream& out = std::clog,
                           const std::string & title = "",
                           const std::string & indent = "",
                           bool inherit = false) const;

    void load(const std::string & filename_);

    void load_csv(const std::string & filename_);

    bool is_mounted(const std::string & urn_) const;

    bool is_local(const std::string & urn_) const;

    static bool parse_mount_rule(const std::string & rule_,
                                 std::string & external_db_,
                                 std::string & mounted_urn_);

    // //! Parse mount rule
    // static bool parse_mount_rule(const std::string & rule_,
    //                              std::string & external_db_,
    //                              std::set<std::string> & mounted_urns_);

    void add_mounted(const std::string & external_db_,
                     const std::string & mounted_urn_);

    const urn_info & add(const std::string & urn_,
                         const std::string & category_,
                         const std::string & description_ = "");

    void remove(const std::string & urn_);

    bool add_link(const std::string & urn_from_,
                  const std::string & urn_to_,
                  const std::string & forward_topic_,
                  std::string & errmsg_);

    void add_link(const std::string & urn_from_,
                  const std::string & urn_to_,
                  const std::string & forward_topic_);

    bool remove_link(const std::string & urn_from_,
                     const std::string & urn_to_,
                     std::string & errmsg_);

    void remove_link(const std::string & urn_from_,
                     const std::string & urn_to_);

    void remove_all_links(const std::string & urn_from_);

    bool is_linked_to(const std::string & urn_,
                      const std::string & other_urn_,
                      const std::string & topic_ = "") const;

    bool has_links(const std::string & urn_) const;

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

    const urn_info & get(const std::string &) const;

    std::size_t get_number_of_urn_records() const;

    enum urn_select_flag {
      SELECT_NOCLEAR   = bit_mask::bit00,
      SELECT_LOCAL     = bit_mask::bit01,
      SELECT_MOUNTED   = bit_mask::bit02,
      SELECT_REMOVABLE = bit_mask::bit03,
      SELECT_LINKED    = bit_mask::bit04
    };

    void build_list_of_urns(std::vector<std::string> & urns_,
                            const uint32_t flags_) const;

    bool has_backward_links(const std::string & urn_) const;

    bool is_removable(const std::string & urn_) const;

    bool is_locked() const;

    void lock();

    void unlock();

    void kernel_push(const std::string & name_ = "");

    void kernel_pop();

    bool is_kernel_pushed() const;

    struct dependency_graph_builder
    {
      dependency_graph_builder(const urn_db_service &, const logger::priority & = logger::PRIO_FATAL);
      void add_topic(const std::string & topic_);
      void make_deps(dependency_graph & deps_) const;
    private:
      void _process_node_components_(const urn_record & urec_,
                                     dependency_graph & deps_,
                                     std::set<std::string> & processed_) const;

    private:

      const urn_db_service & _db_;      
      logger::priority       _logging_; 
      std::set<std::string>  _topics_;  
    };

  private:

    urn_info & _grab_(const std::string &);

    void _init_();

    void _reset_();

    void _at_lock_();

    void _at_unlock_();

    void _add_backward_link_(const std::string & urn_to_,
                             const std::string & urn_from_);

    void _remove_backward_link_(const std::string & urn_to_,
                                const std::string & urn_from_);

    void _process_links_(const std::string & urn_from_);

  private:

    // Management:
    bool _initialized_ = false;
    bool _locked_      = false;

    // Configuration:
    std::set<std::string> _allowed_categories_;    
    std::set<std::string> _allowed_link_topics_;   
    bool                  _allow_mounted_ = false; 
    dependee_db_dict_type _dependee_dbs_;          

    // Private data:
    urn_record_dict_type     _urn_records_;    
    backward_links_dict_type _backward_links_; 

    DATATOOLS_SERVICE_REGISTRATION_INTERFACE(urn_db_service)

  };

} // end of namespace datatools

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

#endif // DATATOOLS_URN_DB_SERVICE_H

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