IdDictDictionary.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef IDDICT_IdDictDictionary_H
#define IDDICT_IdDictDictionary_H
 
 
#include "Identifier/Identifier.h" //typedef
#include "Identifier/Range.h" //member
#include "Identifier/ExpandedIdentifier.h"
 
#include <vector>
#include <string>
#include <string_view>
#include <memory>
#include <map>
 
 
class IdDictField;
class IdDictLabel;
class IdDictSubRegion;
class IdDictRegion;
class IdDictGroup;
class IdDictMgr;
 
class MultiRange;
class ExpandedIdentifier;
class IdDictDictEntry;
 
 
 
class IdDictDictionary  {  
public:  
    using value_type = Identifier::value_type;
    using size_type  = Identifier::size_type;
 
    // ==================================
    //** @name Constructor/destructor
    // @{
 
    IdDictDictionary ();  
    IdDictDictionary (const std::string& name,
                      const std::string& version = "",
                      const std::string& date = "",
                      const std::string& author = "");
    ~IdDictDictionary ();
 

    // ==================================
    //** @name Simple accessors.
    // @{

    const std::string& name() const;

    const std::string& version() const;

    size_t n_regions() const;

    const IdDictRegion& region(size_t i) const;

    const std::string&  file_name() const;

    const std::string&  dict_tag() const;
 

    // ==================================
    //** @name Search for field/label/region by name.
    // @{
 
    const IdDictField* find_field (const std::string& name) const;
          IdDictField* find_field (const std::string& name);
    const IdDictLabel* find_label (const std::string& field, const std::string& label) const;
    int get_label_value (const std::string& field, const std::string& label, int& value) const;  // > 0 == error
    IdDictSubRegion* find_subregion (const std::string& subregion_name);
    const IdDictRegion* find_region (const std::string& region_name) const;
          IdDictRegion* find_region (const std::string& region_name, const std::string& group_name);
    const IdDictRegion* find_region (const std::string& region_name, const std::string& group_name) const;
    IdDictGroup* find_group (const std::string& group_name);
    const IdDictGroup* find_group (const std::string& group_name) const;
 

    // ==================================
    //** @name Find first region that matches id
    // @{
 
    int find_region(const ExpandedIdentifier& id, size_type& index) const;
    const IdDictRegion* find_region(const ExpandedIdentifier& id) const;
    const IdDictRegion* find_region(const ExpandedIdentifier& id,const std::string& group_name) const;
 

    // ==================================
    //** @name Methods used to initialize the object.
    // @{

    const std::vector<IdDictRegion*>& all_regions();
 
    IdDictField* add_field (std::unique_ptr<IdDictField> field);
    IdDictSubRegion*  add_subregion (std::unique_ptr<IdDictSubRegion> subregion);
    void add_dictentry (std::unique_ptr<IdDictDictEntry> entry);
    void add_region (IdDictRegion* region);
    void add_subdictionary_name (const std::string& name);  
    void set_parent_dict (IdDictDictionary* parent_dict);

    void                set_file_name    (const std::string& name);

    void                set_dict_tag     (const std::string& tag);
 
    void resolve_references (IdDictMgr& idd);
    void generate_implementation (const IdDictMgr& idd, std::string_view tag = "");  
    void reset_implementation ();  
    bool verify   () const;
    void sort     ();
    void clear    ();

    void integrate_bits ();
 

    // ==================================
    //** @name Range building
    // @{

    MultiRange build_multirange () const; 

    MultiRange build_multirange (const ExpandedIdentifier& region_id,
                                 const Range& prefix = Range(),
                                 const std::string& last_field = "") const; 

 
    MultiRange build_multirange (const ExpandedIdentifier& region_id,
                                 const std::string& group_name,
                                 const Range& prefix = Range(),
                                 const std::string& last_field = "") const; 
 

    // ==================================
    //** @name Packing and unpacking
    // @{

    int pack32 (const ExpandedIdentifier& id, 
                size_t index1, 
                size_t index2,
                Identifier& packedId) const; 
 
    int pack32 (const int* fields, 
                size_t index1, 
                size_t index2,
                size_t region_index,
                Identifier& packedId,
                size_t first_field_index=0) const; 
 
    int reset (size_t index1, 
               size_t index2,
               size_t region_index,
               Identifier& packedId) const; 
 
 

    int unpack (const std::string& group,
                const Identifier& id,
                const ExpandedIdentifier& prefix,
                size_t index2,
                ExpandedIdentifier& unpackedId) const;
   
    int unpack (const std::string& group,
                const Identifier& id,
                const ExpandedIdentifier& prefix,
                size_t index2,
                const std::string& sep,
                std::string& unpackedId) const; 
   
    int unpack (const Identifier& id, 
                size_t first_field_index, 
                size_t field_index,
                size_t region_index,
                int& field) const; 
 
   
    int copy (const Identifier& idin, 
              size_t first_field_index, 
              size_t begin_field_index,
              size_t end_field_index,
              size_t region_index,
              Identifier& idout) const; 
 

    // ==================================
    //** @name Configuration and diagnostics
    // @{

    bool                do_checks       () const;
    void                set_do_checks   (bool do_checks);

    bool                do_neighbours           () const;
    void                set_do_neighbours       (bool do_neighbours);

    void dump() const;
 

 
private:
    std::string m_name{};
    std::string m_version{};  
    std::string m_date{};  
    std::string m_author{};  
  
    using entries_type = std::vector<IdDictDictEntry*>;
    using entries_it   = entries_type::iterator;
    using entries_const_it = entries_type::const_iterator;
 
    using regions_type = std::vector<IdDictRegion*>;
    using regions_it = regions_type::iterator;
    using regions_const_it = regions_type::const_iterator;
 
    using groups_type = std::vector<IdDictGroup*>;
    using groups_it = groups_type::iterator;
    using groups_const_it = groups_type::const_iterator;
 
    std::map<std::string, std::unique_ptr<IdDictField> >   m_fields;
    std::map<std::string, std::unique_ptr<IdDictSubRegion> > m_subregions;
    std::vector<IdDictRegion*>            m_regions;  // corresponding regions for REs
    std::vector<IdDictRegion*>            m_all_regions;  // all regions
    std::vector<std::unique_ptr<IdDictGroup> > m_groups;
    std::vector<std::string>              m_subdictionary_names; 
    IdDictDictionary*                     m_parent_dict{nullptr};
 
    std::string m_file_name{};  
    std::string m_dict_tag{};  
    bool m_generated_implementation{false};
    bool  m_do_checks{false};
    bool  m_do_neighbours{true};
};
 
//-------------------
// inline definitions
//-------------------
 
// Dictionary name.
inline
const std::string&
IdDictDictionary::name() const
{
    return m_name;
}
 
 
// Dictionary version.
inline
const std::string&
IdDictDictionary::version() const
{
    return m_version;
}
 
 
// Access region by index.
inline
const IdDictRegion&
IdDictDictionary::region(size_t i) const
{
    return *m_regions.at(i);
}
 
 
// Number of regions
inline
size_t
IdDictDictionary::n_regions() const
{
    return m_regions.size();
}
 
 
// Access to file name
inline const std::string&
IdDictDictionary::file_name() const{
    return m_file_name;
}
 
    
inline const std::string&
IdDictDictionary::dict_tag( ) const{
    return m_dict_tag;
}
 

inline void                
IdDictDictionary::set_file_name(const std::string& name){
    m_file_name = name;
}
 
   
inline void                
IdDictDictionary::set_dict_tag(const std::string& tag){
    m_dict_tag = tag;
}
 

inline
const std::vector<IdDictRegion*>& IdDictDictionary::all_regions()
{
    return m_all_regions;
}
 
 
#endif