IdDictGroup Class Reference

#include <IdDictGroup.h>

Collaboration diagram for IdDictGroup:

Classes
struct	IdDictRegionTreeNode
	Tree structure for fast unpacking. More...

Public Member Functions
	IdDictGroup ()
	IdDictGroup (const std::string &name)
	~IdDictGroup ()
	IdDictGroup (const IdDictGroup &)=delete
IdDictGroup &	operator= (const IdDictGroup &)=delete
const std::string &	name () const
size_t	n_regions () const
const IdDictRegion &	region (size_t index) const
const std::vector< IdDictRegion * > &	regions ()
	Non-const access to regions.
MultiRange	build_multirange () const
	Get MultiRange for this group.
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 ()
	Sort:
void	clear ()
int	unpack (const Identifier &id, const ExpandedIdentifier &prefix, size_t index2, ExpandedIdentifier &unpackedId, std::vector< const IdDictFieldImplementation * > *impls=nullptr) const
	Unpack the value_type id to an expanded Identifier, considering the provided prefix (result will include the prefix) and up to index2 - (index1 is assumed to be 0, i.e.
void	build_region_tree ()
	Take the list of regions and build a tree structure for fast unpacking.
void	dump () const
	Dump regions and tree for this group.
void	dump_regions () const
	Dump the list of regions for this group.
void	dump_tree () const
	Dump the tree structure built from the regions for fast unpacking.

Private Member Functions
void	add_tree_field (const IdDictRegion &re, unsigned ifield, unsigned inode)
	Recursively add new nodes to the tree structure.

Private Attributes
std::string	m_name
std::vector< std::unique_ptr< IdDictDictEntry > >	m_entries
std::vector< IdDictRegion * >	m_regions
bool	m_generated_implementation
std::vector< IdDictRegionTreeNode >	m_region_tree
	The list of region nodes.

Detailed Description

Definition at line 25 of file IdDictGroup.h.

Constructor & Destructor Documentation

IdDictGroup() [1/3]

IdDictGroup::IdDictGroup

(

)

Definition at line 22 of file IdDictGroup.cxx.

  :
  m_generated_implementation(false) {
}

IdDictGroup() [2/3]

IdDictGroup::IdDictGroup

(

const std::string &

name

)

Definition at line 27 of file IdDictGroup.cxx.

  :
  m_name(name),
  m_generated_implementation(false) {
}

~IdDictGroup()

IdDictGroup::~IdDictGroup

(

)

Definition at line 33 of file IdDictGroup.cxx.

                           {
}

IdDictGroup() [3/3]

IdDictGroup::IdDictGroup ( const IdDictGroup & )

delete

Member Function Documentation

add_dictentry()

void IdDictGroup::add_dictentry

(

std::unique_ptr< IdDictDictEntry >

entry

)

Definition at line 62 of file IdDictGroup.cxx.

                                                                {
  m_entries.push_back(std::move(region));
}

add_tree_field()

void IdDictGroup::add_tree_field ( const IdDictRegion & re, unsigned ifield, unsigned inode )

private

Recursively add new nodes to the tree structure.

Parameters

re	The region we're processing.
ifield	The index of the next field to add.
inode	The index of the node to which to add.

Definition at line 326 of file IdDictGroup.cxx.

{
  using element_type   = IdentifierField::element_type;
  using element_vector = IdentifierField::element_vector;
  using size_type      = IdentifierField::size_type;
  using index_vector   = IdentifierField::index_vector;
 
  // Helper to retrieve the indices that may actually be used by a field.
  // n is the node we're looking for.  We use the ored_field referenced there
  // to know what can actually be stored in the field.
  // impl gives the field that we're trying to match.
  // So we return the indices for the ored_field corresponding
  // to valid values for impl.
  auto get_field_indices = [] (const IdDictRegionTreeNode& n,
                               const IdDictFieldImplementation& impl)
  {
    index_vector indices;
    const Range::field& ored_field = n.m_impl.ored_field();
    if (impl.field().isEnumerated()) {
      const element_vector& vals = impl.field().get_values();
      indices.reserve (vals.size());
      for (element_type v : vals) {
        indices.push_back (ored_field.get_value_index (v));
      }
    }
    else if (impl.field().isBounded()) {
      auto [minval, maxval] = impl.field().get_minmax();
      size_type minidx = ored_field.get_value_index (minval);
      size_type maxidx = ored_field.get_value_index (maxval);
      indices.resize (maxidx - minidx + 1);
      std::iota (indices.begin(), indices.end(), minidx);
    }
    else {
      std::abort();
    }
    return indices;
  };
 
  // This will be the field we're matching.
  const IdDictFieldImplementation& prev_impl = re.implementation(ifield-1);
 
  {
    // Get the children for the current node.
    IdDictRegionTreeNode& n = m_region_tree.at(inode);
    auto& children = std::get<0> (n.m_children);
 
    // If we're looking at the last field, fill in the node pointersj
    // with END; then we're done.
    if (ifield == re.n_implementation()) {
      index_vector indices = get_field_indices (n, prev_impl);
      for (size_t idx : indices) {
        children.at (idx) = IdDictRegionTreeNode::END;
      }
      return;
    }
 
    // Verify consistency of the field with what's stored in the node.
    if (prev_impl.bits() != n.m_impl.bits() ||
        prev_impl.bits_offset() != n.m_impl.bits_offset() ||
        prev_impl.ored_field() != n.m_impl.ored_field())
    {
      dump();
      std::abort();
    }
 
    // If this implementation has a field that is not equivalent with what
    // we saved in the node, then save it in m_other_impls.
    if (n.m_impl.field() != prev_impl.field()) {
      if (!n.m_other_impls) {
        n.m_other_impls = std::make_unique<std::vector<const IdDictFieldImplementation*> > (1, &prev_impl);
      }
      else {
        if (std::ranges::find_if (*n.m_other_impls,
                                  [&](const IdDictFieldImplementation* a)
                                  { return a->field() == prev_impl.field(); })
            == n.m_other_impls->end())
        {
          n.m_other_impls->push_back (&prev_impl);
        }
      }
    }
  }
 
  // Indices we want to store.
  index_vector indices = get_field_indices (m_region_tree[inode], prev_impl);
  const IdDictFieldImplementation& impl = re.implementation(ifield);
 
  // Children for the node.
  auto children = [&]() -> std::vector<unsigned>& { return std::get<0> (m_region_tree[inode].m_children); };
 
  unsigned new_node = 0;
  std::vector<unsigned> nodes_seen;
 
  // Loop over indices that we want to add.
  for (size_t idx : indices) {
 
    // If we've already recorded this index as END, fail.
    unsigned next_node = children().at (idx);
    if (next_node == IdDictRegionTreeNode::END) {
      dump();
      std::abort();
    }
 
    if (next_node != 0) {
      // There is an existing node.  Process it recursively; but we only
      // need to this once for each unique node.
      if (std::ranges::find (nodes_seen, next_node) == nodes_seen.end()) {
        add_tree_field (re, ifield+1, next_node);
        nodes_seen.push_back (next_node);
      }
    }
    else {
      // No node had been recorded for this index.
      if (new_node != 0) {
        // We've already made a new node.  So just record it.
        children().at(idx) = new_node;
      }
      else {
        // Need to make a new node.
        new_node = m_region_tree.size();
        if (new_node == IdDictRegionTreeNode::END) {
          std::abort();
        }
        // Careful --- this will invalidate references to nodes.
        m_region_tree.emplace_back (impl);
        children().at(idx) = new_node;
        add_tree_field (re, ifield+1, new_node);
      }
    }
  }
}

build_multirange()

MultiRange IdDictGroup::build_multirange

(

)

const

Get MultiRange for this group.

Definition at line 42 of file IdDictGroup.cxx.

                                    {
  MultiRange result;
 
  for (const IdDictRegion* region : m_regions) {
 
    // skip regions created from parents
    if ("dummy" == region->name()) continue;
 
    // skip empty regions - may arise from alternate_regions
    // where a tag selects an empty region
    if (region->is_empty()) continue;
 
    Range r = region->build_range();
    result.add(std::move(r));
  }
 
  return(result);
}

build_region_tree()

void IdDictGroup::build_region_tree

(

)

Take the list of regions and build a tree structure for fast unpacking.

Definition at line 465 of file IdDictGroup.cxx.

{
  // Loop through regions.
  [[maybe_unused]] unsigned iregion = 0; // Region index, really only for debugging.
  for (const IdDictRegion* re : m_regions) {
    // Skip dummy/empty regions.
    if (re->fieldSize() == 0 || re->name() == "dummy") {
      ++iregion;
      continue;
    }
 
    // Add an initial node if we haven't done so already.
    if (m_region_tree.empty()) {
      m_region_tree.emplace_back (re->implementation(0));
    }
 
    // Add nodes for the current region, starting at field 1.
    add_tree_field (*re, 1, 0);
 
    ++iregion;
  }
 
  // Compress child vectors if possible.
  for (IdDictRegionTreeNode& n : m_region_tree) {
    n.optimize();
  }
}

clear()

void IdDictGroup::clear

(

)

Definition at line 168 of file IdDictGroup.cxx.

                   {
  m_entries.clear();
  m_regions.clear();
  m_region_tree.clear();
}

dump()

void IdDictGroup::dump

(

)

const

Dump regions and tree for this group.

Definition at line 497 of file IdDictGroup.cxx.

{
  std::cout << "===== IdDictGroup " << m_name << "\n";
  dump_regions();
  dump_tree();
}

dump_regions()

void IdDictGroup::dump_regions

(

)

const

Dump the list of regions for this group.

Definition at line 508 of file IdDictGroup.cxx.

{
  std::cout << "Regions:\n";
  for (unsigned iregion = 0; const IdDictRegion* re : m_regions) {
    std::cout << "  " << iregion++ << " " << re->name() << " " << re->group_name() << " " << re->tag() << "\n";
    size_t nimpl = re->n_implementation();
    bool first = true;
    for (size_t i = 0; i < nimpl; ++i) {
      const IdDictFieldImplementation& impl = re->implementation(i);
      std::cout << (first ? "    " : "; ") << impl.field() << " " << impl.ored_field() << " " << impl.bits() << "/" << impl.bits_offset();
      first = false;
    }
    std::cout << "\n";
  }
}

dump_tree()

void IdDictGroup::dump_tree

(

)

const

Dump the tree structure built from the regions for fast unpacking.

Definition at line 528 of file IdDictGroup.cxx.

{
  size_t sz = 0;
  for (const auto& n : m_region_tree) {
    if (n.m_children.index() == 0) {
      sz += std::get<0>(n.m_children).size();
    }
  }
  std::cout << "Region Tree totsize " << sz << "\n";
  for (unsigned inode = 0; const auto& n : m_region_tree) {
    std::cout << "  " << inode++ << " " << n.m_impl.field()
              << " " << n.m_impl.ored_field() << " -- ";
 
    if (n.m_children.index() == 0) {
      const auto& children = std::get<0> (n.m_children);
      unsigned istart = 0;
      unsigned ichild = 0;
      bool first = true;
      for (size_t i = 0; uint64_t c : children) {
        if (c != ichild) {
          if (ichild != 0) {
            if (!first) std::cout << " ";
            first = false;
            if (istart != i-1) {
              std::cout << istart << "-";
            }
            std::cout << i-1 << ":";
            if (ichild == IdDictRegionTreeNode::END) {
              std::cout << "END";
            }
            else {
              std::cout << ichild;
            }
          }
          ichild = c;
          istart = i;
        }
        ++i;
      }
      if (ichild != 0) {
        if (!first) std::cout << " ";
        if (istart != children.size()-1) {
          std::cout << istart << "-";
        }
        std::cout << children.size()-1 << ":";
        if (ichild == IdDictRegionTreeNode::END) {
          std::cout << "END";
        }
        else {
          std::cout << ichild;
        }
      }
    }
    else {
      const auto& children = std::get<1> (n.m_children);
      if (children.first == 1) {
        std::cout << "0:";
      }
      else {
        std::cout << "0-" << children.first-1 << ":";
      }
      if (children.second == IdDictRegionTreeNode::END) {
        std::cout << "END";
      }
      else {
        std::cout << children.second;
      }
    }
    if (n.m_other_impls) {
      std::cout << " [";
      bool first = true;
      for (const IdDictFieldImplementation* ii : *n.m_other_impls) {
        if (!first)
          std::cout << "; ";
        else
          first = false;
        std::cout << ii->field();
      }
      std::cout << "]";
    }
    std::cout << "\n";
  }
  std::cout.flush();
}

generate_implementation()

void IdDictGroup::generate_implementation	(	const IdDictMgr &	idd,
		IdDictDictionary &	dictionary,
		const std::string &	tag = "" )

Definition at line 79 of file IdDictGroup.cxx.

                                                           {
  if (Debugger::debug()) {
    std::cout << "IdDictGroup::generate_implementation>" << std::endl;
  }
 
  if (!m_generated_implementation) {
    // Loop over entries and fill regions vec with selected region
    // (AltRegions have a selection)
    for (auto& ent : m_entries) {
      ent->generate_implementation(idd, dictionary, tag);
      // Get region and save in m_regions
      IdDictRegion* region = dynamic_cast<IdDictRegion*> (ent.get());
      if (region) {
        m_regions.push_back(region);
      } else {
        IdDictAltRegions* altregions = dynamic_cast<IdDictAltRegions*> (ent.get());
        if (altregions) {
          m_regions.push_back(altregions->selected_region());
        }
      }
    }
 
    if (m_regions.size() != m_entries.size()) {
      std::cout << "IdDictGroup::generate_implementation - mismatch of sizes: regions/entries "
                << m_regions.size() << " " << m_entries.size()
                << std::endl;
    }
 
    m_generated_implementation = true;
  }
}

n_regions()

size_t IdDictGroup::n_regions ( ) const

inline

Definition at line 231 of file IdDictGroup.h.

{
    return m_regions.size();
}

name()

const std::string & IdDictGroup::name ( ) const

inline

Definition at line 225 of file IdDictGroup.h.

                                         {
    return m_name;
}

operator=()

IdDictGroup & IdDictGroup::operator= ( const IdDictGroup & )

delete

region()

const IdDictRegion & IdDictGroup::region ( size_t index ) const

inline

Definition at line 238 of file IdDictGroup.h.

{
    return *m_regions.at(index);
}

regions()

const std::vector< IdDictRegion * > & IdDictGroup::regions

(

)

Non-const access to regions.

Definition at line 37 of file IdDictGroup.cxx.

                     {
  return(m_regions);
}

reset_implementation()

void IdDictGroup::reset_implementation

(

)

Definition at line 114 of file IdDictGroup.cxx.

                                  {
  if (m_generated_implementation) {
    m_regions.clear();
    for (auto& ent : m_entries) {
      ent->reset_implementation();
    }
    m_generated_implementation = false;
  }
}

resolve_references()

void IdDictGroup::resolve_references	(	IdDictMgr &	idd,
		IdDictDictionary &	dictionary,
		size_t &	index )

Definition at line 67 of file IdDictGroup.cxx.

                                               {
  for (auto& ent : m_entries) {
    ent->set_index(index);
    index++;
 
    ent->resolve_references(idd, dictionary);
  }
}

sort()

void IdDictGroup::sort

(

)

Sort:

Loop over regions and sort according to their first identifier

Definition at line 139 of file IdDictGroup.cxx.

                       {
  std::map< ExpandedIdentifier, std::unique_ptr<IdDictDictEntry> > regions;
 
  assert (m_regions.size() == m_entries.size());
  for (size_t ientry = 0; IdDictRegion* region : m_regions) {
    Range range = region->build_range();
    RangeIterator itr(range);
    auto first = itr.begin();
    auto last = itr.end();
    if (first != last) {
      regions[*first] = std::move(m_entries[ientry++]);
    } else {
      std::cout << "IdDictDictionary::sort - WARNING empty region cannot sort "
                << std::endl;
    }
  }
  if (regions.size() != m_regions.size()) {
    std::cout << "IdDictGroup::sort - WARNING region map size is NOT the same as the vector size. Map size "
              << regions.size() << " vector size " << m_regions.size()
              << std::endl;
  }
  // Reorder the regions
  m_entries.resize (regions.size());
  for (size_t vecIt = 0; auto& p : regions) {
    m_entries[vecIt++] = std::move(p.second);
  }
}

unpack()

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

Unpack the value_type id to an expanded Identifier, considering the provided prefix (result will include the prefix) and up to index2 - (index1 is assumed to be 0, i.e.

part of prefix). If impls is provided, then fill it with pointers to the implementations for each unpacked field.

Returns 0 on success, nonzero on error.

Definition at line 217 of file IdDictGroup.cxx.

{
  using element_type = ExpandedIdentifier::element_type;
  using size_type = IdentifierField::size_type;
 
  // Give up if the tree representation hasn't been built.
  if (m_region_tree.empty()) std::abort();
 
  // Clear output.
  unpackedId.clear();
  if (impls) {
    impls->clear();
    impls->reserve (12);
  }
 
  // Start at the first node, and assume success.
  unsigned inode = 0;
  int ret = 0;
 
  // Loop over fields.
  for (size_t index = 0; index <= index2; ++index) {
 
    // Fetch the node.
    const IdDictRegionTreeNode& n = m_region_tree.at(inode);
 
    // Find the index+value for this field.  If we're looking at a prefix,
    // get it from there; otherwise, unpack from the input identifier.
    element_type val;
    size_type validx;
    if (index < prefix.fields()) {
      val = prefix[index];
      validx = n.m_impl.ored_field().get_value_index (val);
    }
    else {
      validx = n.m_impl.unpackToIndex (id);
      try {
        val = n.m_impl.ored_field().get_value_at (validx);
      } catch (const std::out_of_range&) {
        ret = 1;
        break;
      }
    }
 
    // Find the next node.
    if (n.m_children.index() == 0) {
      // Children stored as a vector.
      const auto& children = std::get<0> (n.m_children);
      if (validx < children.size()) {
        inode = children[validx];
      }
      else {
        inode = 0;
      }
    }
    else {
      // Children stored as a size,node-number field.
      const auto& children = std::get<1> (n.m_children);
      if (validx < children.first) {
        inode = children.second;
      }
      else {
        inode = 0;
      }
    }
 
    // Give up if no regions match the identifier.
    if (!inode) {
      break;
    }
 
    // Record this field in the output.
    unpackedId.add (val);
 
    // Also return the implementation, if requested.
    // But we need to be sure that we return an implementation that actually
    // matches the field value.
    if (impls) {
      if (n.m_impl.field().match (val)) {
        impls->push_back (&n.m_impl);
      }
      else if (n.m_other_impls) {
        for (const IdDictFieldImplementation* ii : *n.m_other_impls) {
          if (ii->field().match (val)) {
            impls->push_back (ii);
            break;
          }
        }
      }
      if (unpackedId.fields() != impls->size()) std::abort();
    }
 
    // Stop if we've reached the end of the identifier.
    if (inode == IdDictRegionTreeNode::END) break;
  }
 
  return ret;
}

verify()

bool IdDictGroup::verify

(

)

const

Definition at line 125 of file IdDictGroup.cxx.

                          {
  // Should check that all regions have the same number of levels,
  // which is part of the definition of a group
  return(true);
}

Member Data Documentation

m_entries

std::vector<std::unique_ptr<IdDictDictEntry> > IdDictGroup::m_entries

private

Definition at line 123 of file IdDictGroup.h.

m_generated_implementation

bool IdDictGroup::m_generated_implementation

private

Definition at line 125 of file IdDictGroup.h.

m_name

std::string IdDictGroup::m_name

private

Definition at line 122 of file IdDictGroup.h.

m_region_tree

std::vector<IdDictRegionTreeNode> IdDictGroup::m_region_tree

private

The list of region nodes.

Definition at line 220 of file IdDictGroup.h.

m_regions

std::vector<IdDictRegion*> IdDictGroup::m_regions

private

Definition at line 124 of file IdDictGroup.h.

---

The documentation for this class was generated from the following files:

• IdDictGroup.h
• IdDictGroup.cxx