id_mgr.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-03-14
 * Last modified: 2016-07-04
 *
 * License:
 *
 * Description:
 *
 *   Geometry ID manager
 *
 */

#ifndef GEOMTOOLS_ID_MGR_H
#define GEOMTOOLS_ID_MGR_H 1

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

// Third party:
// - Bayeux/datatools:
#include <datatools/utils.h>
#include <datatools/logger.h>
#include <datatools/multi_properties.h>

// This project:
#include <geomtools/geom_id.h>

namespace geomtools {

  class id_mgr
    : public datatools::i_tree_dumpable
  {

  public:

    static const std::string & category_key_label();
    static const std::string & type_meta_label();
    static const std::string & default_world_category();
    static const std::string & default_plain_category();
    static const std::string & plain_item_address();
    static const uint32_t WORD_TYPE  = 0;
    static const uint32_t PLAIN_TYPE = 1;

    class category_info
      : public datatools::i_tree_dumpable
    {

    public:

      bool has_subaddress(const std::string & a_label, int a_count = 1) const;

      int get_subaddress_index(const std::string & a_label, int a_count = 1) const;

      bool is_valid() const;

      // Check if the category is final (cannot be inherited)
      bool is_final_category() const;

      // Set the final category flag
      void set_final_category(bool);

      // Set the category name
      void set_category(const std::string & cat_);

      const std::string & get_category() const;

      bool has_ancestor(const std::string & cat_) const;

      void add_ancestor(const std::string & cat_);

      void add_address(const std::string & address_);

      void add_extends_by(const std::string & by_);

      bool has_group() const;

      void set_group(const std::string &);

      const std::string & get_group() const;

      void set_type(uint32_t);

      uint32_t get_type() const;

      const std::string & get_inherits() const;

      void set_inherits(const std::string &);

      bool is_inherited() const;

      bool is_extension() const;

      void set_extends(const std::string &);

      const std::string & get_extends() const;

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

      const std::vector<std::string> & get_ancestors() const;

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

      const std::vector<std::string> & get_extends_by() const;

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

      const std::vector<std::string> & get_addresses() const;

      category_info();

      virtual ~category_info();

      size_t get_depth() const;

      size_t get_by_depth() const;

      void create(geom_id & id_) const;

      void dump(std::ostream & = std::clog) const;

      virtual void print_tree(std::ostream & out_ = std::clog,
                              const boost::property_tree::ptree & options_ = datatools::i_tree_dumpable::empty_options()) const;

      bool is_locked() const;

      void lock();

      void reset();

    private:
      bool        _locked_;                  
      std::string _category_;                
      uint32_t    _type_;                    
      std::string _group_;                   
      std::string _inherits_;                
      std::string _extends_;                 
      bool        _final_category_;          
      std::vector<std::string> _ancestors_;  
      std::vector<std::string> _extends_by_; 
      std::vector<std::string> _addresses_;  
      std::vector<int>         _nbits_;      

    };

    /***************************************/

    typedef std::map<std::string, category_info> categories_by_name_col_type;
    typedef std::map<int, const category_info *> categories_by_type_col_type;

  public:

    bool is_debug() const;

    void set_debug(bool);

    const categories_by_type_col_type & categories_by_type() const;

    const categories_by_name_col_type & categories_by_name() const;

    id_mgr();

    virtual ~id_mgr();

    void set_force_world(bool);

    bool is_force_world() const;

    void set_force_plain(bool);

    bool is_force_plain() const;

    void set_world_category(const std::string & n_);

    const std::string & get_world_category() const;

    void set_plain_category(const std::string & n_);

    const std::string & get_plain_category() const;

    void init_from(const datatools::multi_properties & mp_);

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

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

    virtual void print_tree(std::ostream & out_ = std::clog,
                            const boost::property_tree::ptree & options_ = datatools::i_tree_dumpable::empty_options()) const;

    bool has_category_info(int type_) const;

    bool has_category_info(const std::string &) const;

    const category_info & get_category_info(int type_) const;

    const category_info & get_category_info(const std::string &) const;

    bool is_category(const geom_id & id_, const std::string & category_) const;

    bool inherits(const geom_id & id_, const std::string & category_) const;

    bool has(const geom_id &, const std::string & what_) const;

    const std::string & get_category(const geom_id &) const;

    uint32_t get_category_type(const std::string & a_category) const;

    int get(const geom_id &, const std::string & what_) const;

    void set(geom_id &, const std::string & what_, uint32_t value_) const;

    bool check_inheritance(const geom_id & mother_id_,
                           const geom_id & id_) const;

    void extract(const geom_id & child_id_, geom_id & mother_id_) const;

    bool validate_id(const geom_id & id_) const;

    void id_to_human_readable_format_string(const geom_id & id_, std::string &) const;

    std::string id_to_human_readable_format_string(const geom_id & id_) const;

    void make_id(geom_id & id_,
                 uint32_t address_) const;

    void make_id(const std::string & category_, geom_id & id_) const;

    int print_list_of_categories(const std::string & command_,
                                 const std::vector<std::string> & argv_,
                                 std::ostream & out_ = std::clog) const;

    /*
      void make_extended(const geom_id & mother_id_,
      geom_id & id_,
      uint32_t address_) const;
    */

    int compute_id_from_info(geom_id                     & id_,
                             const geom_id               & mother_id_,
                             const std::string           & id_info_,
                             const std::vector<uint32_t> & items_index_) const;

    int compute_id_from_info(geom_id           & id_,
                             const geom_id     & mother_id_,
                             const std::string & id_info_,
                             uint32_t nitem0_ = geom_id::INVALID_ADDRESS,
                             uint32_t nitem1_ = geom_id::INVALID_ADDRESS,
                             uint32_t nitem2_ = geom_id::INVALID_ADDRESS) const;

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

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

    bool is_initialized() const;

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

    void reset();

  protected:

    virtual void _at_initialize();

  private:

    // Management;
    datatools::logger::priority _logging_priority_;    
    bool                        _initialized_;         

    // Configuration:
    bool                        _force_world_;         
    bool                        _force_plain_;         
    std::string                 _world_category_;      
    std::string                 _plain_category_;      
    std::vector<std::string>    _categories_lists_;    

    // Working data:
    categories_by_name_col_type _categories_by_name_;  
    categories_by_type_col_type _categories_by_type_;  

  };

} // end of namespace geomtools

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

#endif // GEOMTOOLS_ID_MGR_H

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