IdDictGroup.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef IDDICT_IdDictGroup_H
#define IDDICT_IdDictGroup_H
 
#include <string>
#include <vector>
#include <variant>
#include <utility>
#include <memory>
 
class IdDictDictEntry;
class IdDictRegion;
class IdDictMgr;
class IdDictDictionary;
class IdDictFieldImplementation;
class Identifier;
class ExpandedIdentifier;
class MultiRange;
 
 
 
class IdDictGroup{ 
public: 
    // ==================================
    //** @name Constructor/destructor
    // @{
 
    IdDictGroup (); 
    IdDictGroup (const std::string& name); 
    ~IdDictGroup (); 
 
    IdDictGroup (const IdDictGroup&) = delete;
    IdDictGroup& operator= (const IdDictGroup&) = delete;
 

    // ==================================
    //** @name Simple accessors.
    // @{
 
    const std::string&  name() const;
    size_t n_regions() const;
    const IdDictRegion&  region(size_t index) const;
 

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

    const std::vector<IdDictRegion*>&    regions();

    MultiRange build_multirange () const; 
 
    void add_dictentry (std::unique_ptr<IdDictDictEntry> entry);
 
    void resolve_references (IdDictMgr& idd,
                             IdDictDictionary& dictionary,
                             size_t& index);  
    void generate_implementation (const IdDictMgr& idd,  
                                  IdDictDictionary& dictionary, 
                                  const std::string& tag = "");
    void reset_implementation ();  
    bool verify () const;
    void sort   ();  
    void clear  (); 
 

    int unpack (const Identifier& id,
                const ExpandedIdentifier& prefix,
                size_t index2,
                ExpandedIdentifier& unpackedId,
                std::vector<const IdDictFieldImplementation*>* impls = nullptr) const;

    void build_region_tree();
 

    void dump() const;
 

    void dump_regions() const;
 

    void dump_tree() const;
 
 
private:
    void add_tree_field (const IdDictRegion& re, unsigned ifield, unsigned inode);
 
    std::string                   m_name;  
    std::vector<std::unique_ptr<IdDictDictEntry> > m_entries;  // just the RegionEntries
    std::vector<IdDictRegion*>    m_regions;  // regions derived from entries
    bool m_generated_implementation;
 

    struct IdDictRegionTreeNode {
      IdDictRegionTreeNode (const IdDictFieldImplementation& impl);
      void optimize();

      const IdDictFieldImplementation& m_impl;

      std::unique_ptr<std::vector<const IdDictFieldImplementation*> > m_other_impls;

      using ChildPair = std::pair<size_t, unsigned>;
      std::variant<std::vector<unsigned>, ChildPair> m_children;

      // of an identifier.
      static constexpr unsigned END = static_cast<unsigned> (-1);
    };

    std::vector<IdDictRegionTreeNode> m_region_tree;
}; 
 
 
inline
const std::string& IdDictGroup::name() const {
    return m_name;
}
 
 
inline
size_t IdDictGroup::n_regions() const
{
    return m_regions.size();
}
 
 
inline
const IdDictRegion& IdDictGroup::region(size_t index) const
{
    return *m_regions.at(index);
}
 
 
#endif