IdDictDictionary Class Reference

#include <IdDictDefs.h>

Collaboration diagram for IdDictDictionary:

Public Types
typedef Identifier::value_type	value_type
typedef Identifier::size_type	size_type
typedef std::vector< IdDictDictEntry * >	entries_type
typedef entries_type::iterator	entries_it
typedef entries_type::const_iterator	entries_const_it
typedef std::vector< IdDictRegion * >	regions_type
typedef regions_type::iterator	regions_it
typedef regions_type::const_iterator	regions_const_it
typedef std::vector< IdDictGroup * >	groups_type
typedef groups_type::iterator	groups_it
typedef groups_type::const_iterator	groups_const_it

Public Member Functions
	IdDictDictionary ()
	~IdDictDictionary ()
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
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
IdDictGroup *	find_group (const std::string &group_name) const
void	add_field (IdDictField *field)
void	add_subregion (IdDictSubRegion *subregion)
void	add_dictentry (IdDictDictEntry *entry)
void	add_subdictionary_name (const std::string &name)
void	resolve_references (const IdDictMgr &idd)
void	generate_implementation (const IdDictMgr &idd, const std::string &tag="")
void	reset_implementation ()
bool	verify () const
	Here, we verify global constraints : (this must only be applied after the resolve_references and generate_implementation operations) More...
void	sort ()
	Sort: More...
void	clear ()
int	find_region (const ExpandedIdentifier &id, size_type &index) const
	Find first region that matches id. More...
IdDictRegion *	find_region (const ExpandedIdentifier &id) const
IdDictRegion *	find_region (const ExpandedIdentifier &id, const std::string &group_name) const
void	integrate_bits ()
	Set up integral of bits for efficient unpacking. More...
MultiRange	build_multirange () const
	Get MultiRange for full dictionary. More...
MultiRange	build_multirange (const ExpandedIdentifier &region_id, const Range &prefix=Range(), const std::string &last_field="") const
	Get MultiRange for a specific region_id up to and including 'last_field' If last_field == "", all fields are taken. More...
MultiRange	build_multirange (const ExpandedIdentifier &region_id, const std::string &group_name, const Range &prefix=Range(), const std::string &last_field="") const
	Get MultiRange for a specific region_id, constrained to be within a specific named group. More...
int	pack32 (const ExpandedIdentifier &id, size_t index1, size_t index2, Identifier &packedId) const
	Pack to 32bits the subset of id between (inclusive) index1 and index2 - this is generic, i.e. More...
int	pack32 (const int *fields, size_t index1, size_t index2, size_t region_index, Identifier &packedId, size_t first_field_index=0) const
	Pack to 32bits the subset of id between (inclusive) index1 and index2. More...
int	reset (size_t index1, size_t index2, size_t region_index, Identifier &packedId) const
	Reset fields from index1 to index2. More...
int	unpack (const Identifier &id, const ExpandedIdentifier &prefix, size_t index2, ExpandedIdentifier &unpackedId) 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. More...
int	unpack (const Identifier &id, const ExpandedIdentifier &prefix, size_t index2, const std::string &sep, std::string &unpackedId) const
	Unpack the value_type id to a string, considering the provided prefix (result will include the prefix) and up to index2 - (index1 is assumed to be 0, i.e. More...
int	unpack (const Identifier &id, size_t first_field_index, size_t field_index, size_t region_index, int &field) const
	Unpack a single field of the value_type id. More...
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
	Copy a number of fields of the value_type id into another value_type id. More...
bool	do_checks (void) const
	Checks are performed by default in debug compilation and NOT in optimized compilation. More...
void	set_do_checks (bool do_checks)
bool	do_neighbours (void) const
	Neighbour initialization is performed by default One can switch or query this mode for any idHelper with the following methods: More...
void	set_do_neighbours (bool do_neighbours)
std::string	file_name (void) const
	Access to file name. More...
std::string	dict_tag (void) const
	Access to the dictionary tag. More...
void	set_file_name (const std::string &name)
	Set file name. More...
void	set_dict_tag (const std::string &tag)
	Set the dictionary tag. More...

Public Attributes
std::string	m_name
std::string	m_version
std::string	m_date
std::string	m_author
std::map< std::string, IdDictField * >	m_fields
std::map< std::string, IdDictSubRegion * >	m_subregions
std::vector< IdDictRegion * >	m_regions
std::vector< IdDictRegion * >	m_all_regions
std::vector< IdDictGroup * >	m_groups
std::vector< std::string >	m_subdictionary_names
IdDictDictionary *	m_parent_dict

Private Attributes
std::string	m_file_name
std::string	m_dict_tag
bool	m_generated_implementation
bool	m_do_checks
bool	m_do_neighbours

Detailed Description

Definition at line 96 of file IdDictDefs.h.

Member Typedef Documentation

entries_const_it

typedef entries_type::const_iterator IdDictDictionary::entries_const_it

Definition at line 290 of file IdDictDefs.h.

entries_it

typedef entries_type::iterator IdDictDictionary::entries_it

Definition at line 289 of file IdDictDefs.h.

entries_type

typedef std::vector<IdDictDictEntry*> IdDictDictionary::entries_type

Definition at line 288 of file IdDictDefs.h.

groups_const_it

typedef groups_type::const_iterator IdDictDictionary::groups_const_it

Definition at line 298 of file IdDictDefs.h.

groups_it

typedef groups_type::iterator IdDictDictionary::groups_it

Definition at line 297 of file IdDictDefs.h.

groups_type

typedef std::vector<IdDictGroup*> IdDictDictionary::groups_type

Definition at line 296 of file IdDictDefs.h.

regions_const_it

typedef regions_type::const_iterator IdDictDictionary::regions_const_it

Definition at line 294 of file IdDictDefs.h.

regions_it

typedef regions_type::iterator IdDictDictionary::regions_it

Definition at line 293 of file IdDictDefs.h.

regions_type

typedef std::vector<IdDictRegion*> IdDictDictionary::regions_type

Definition at line 292 of file IdDictDefs.h.

size_type

typedef Identifier::size_type IdDictDictionary::size_type

Definition at line 100 of file IdDictDefs.h.

value_type

typedef Identifier::value_type IdDictDictionary::value_type

Definition at line 99 of file IdDictDefs.h.

Constructor & Destructor Documentation

IdDictDictionary()

IdDictDictionary::IdDictDictionary

(

)

Definition at line 296 of file IdDictMgr.cxx.

    : 
    m_parent_dict(0),
    //m_resolved_references(false),
    m_generated_implementation(false),
    m_do_checks(false),
    m_do_neighbours(true)
{} 

~IdDictDictionary()

IdDictDictionary::~IdDictDictionary

(

)

Definition at line 305 of file IdDictMgr.cxx.

{ 
} 

Member Function Documentation

add_dictentry()

void IdDictDictionary::add_dictentry

(

IdDictDictEntry *

entry

)

Definition at line 410 of file IdDictMgr.cxx.

{ 
    // Add region to corresponding group
    IdDictGroup* group = find_group(region->group_name());
    if (0 == group) {
    group = new IdDictGroup(region->group_name());
    m_groups.push_back(group);
    }
    group->add_dictentry (region);
} 

add_field()

void IdDictDictionary::add_field

(

IdDictField *

field

)

Definition at line 346 of file IdDictMgr.cxx.

{ 
  if (field == 0) return;  
  
  std::string& name = field->m_name;  
  
  m_fields[name] = field;  
} 

add_subdictionary_name()

void IdDictDictionary::add_subdictionary_name

(

const std::string &

name

)

Definition at line 403 of file IdDictMgr.cxx.

{
    m_subdictionary_names.push_back(name);
}

add_subregion()

void IdDictDictionary::add_subregion

(

IdDictSubRegion *

subregion

)

Definition at line 394 of file IdDictMgr.cxx.

{ 
  if (subregion == 0) return;  
  
  std::string& name = subregion->m_name;  
  
  m_subregions[name] = subregion;  
} 

build_multirange() [1/3]

MultiRange IdDictDictionary::build_multirange

(

)

const

Get MultiRange for full dictionary.

Definition at line 1048 of file IdDictMgr.cxx.

{ 
  MultiRange result; 
 
  IdDictDictionary::groups_const_it it; 
 
  for (it = m_groups.begin (); it != m_groups.end (); ++it) 
    { 
      const IdDictGroup& group = *(*it);
 
      MultiRange group_mr = group.build_multirange();
 
      for (unsigned int i = 0; i < group_mr.size(); ++i) {
      const Range& range = group_mr[i];
      result.add (range);
      }
    } 
 
//    IdDictDictionary::regions_const_it it; 
 
//    for (it = m_regions.begin (); it != m_regions.end (); ++it) 
//      { 
//        const IdDictRegion& region = *(*it);
 
//        // skip regions created from parents
//        if("dummy" == region.m_name) continue;
 
//        // skip empty regions - may arise from alternate_regions
//        // where a tag selects an empty region
//        if(region.m_is_empty) continue;
 
//        result.add (region.build_range ()); 
 
//      } 
 
  return (result); 
} 

build_multirange() [2/3]

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

Get MultiRange for a specific region_id up to and including 'last_field' If last_field == "", all fields are taken.

Prepend prefix if provided.

Definition at line 1086 of file IdDictMgr.cxx.

{
    MultiRange result; 
 
    IdDictDictionary::regions_const_it it; 
    if ("" == last_field) {
    // Take all fields
    for (it = m_regions.begin (); it != m_regions.end (); ++it) { 
 
        const IdDictRegion& region = *(*it);
 
        // skip regions created from parents
        if("dummy" == region.m_name) continue;
 
        // skip empty regions - may arise from alternate_regions
        // where a tag selects an empty region
        if(region.m_is_empty) continue;
 
        Range range(region.build_range ()); 
        // Check region selection
        if (range.match(region_id))result.add (std::move(range));
    } 
    }
    else {
    // Not all fields required
    for (it = m_regions.begin (); it != m_regions.end (); ++it) { 
        const IdDictRegion& region = *(*it);
        
        // skip regions created from parents
        if("dummy" == region.m_name) continue;
 
        // skip empty regions - may arise from alternate_regions
        // where a tag selects an empty region
        if(region.m_is_empty) continue;
 
        Range range(region.build_range ()); 
        // Check region selection
        if (range.match(region_id)) {
        // Build new range up to last_field and add it to result -
        // remove duplicate ranges with addRangeToMR
        Range new_range(prefix); // Prepend with prefix
 
        std::vector <IdDictFieldImplementation>::const_iterator fit; 
        for (fit = region.m_implementation.begin ();  
             fit != region.m_implementation.end (); 
             ++fit) { 
            const IdDictFieldImplementation& impl = *fit; 
 
//              new_range.add(impl.m_field);
            new_range.add(impl.range()->build_range());
 
            if (last_field == impl.range()->m_field->m_name) {
            break;
            }
        } 
        result.add(std::move(new_range));
        }
    } 
    }
  
    return (result); 
}

build_multirange() [3/3]

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

Get MultiRange for a specific region_id, constrained to be within a specific named group.

The depth of the multirange is up to and including 'last_field' If last_field == "", all fields are taken. Prepend prefix if provided.

Definition at line 1152 of file IdDictMgr.cxx.

{
    MultiRange result; 
 
    IdDictDictionary::regions_const_it it; 
    if ("" == last_field) {
    // Take all fields
    for (it = m_regions.begin (); it != m_regions.end (); ++it) { 
 
        const IdDictRegion& region = *(*it);
 
        // skip regions created from parents
        if("dummy" == region.m_name) continue;
 
        // skip empty regions - may arise from alternate_regions
        // where a tag selects an empty region
        if(region.m_is_empty) continue;
 
        Range range(region.build_range ()); 
        // Check region selection
        if (range.match(region_id) && region.group_name() == group_name)result.add (std::move(range));
    } 
    }
    else {
    // Not all fields required
    for (it = m_regions.begin (); it != m_regions.end (); ++it) { 
        const IdDictRegion& region = *(*it);
        
        // skip regions created from parents
        if("dummy" == region.m_name) continue;
 
        // skip empty regions - may arise from alternate_regions
        // where a tag selects an empty region
        if(region.m_is_empty) continue;
 
        Range range(region.build_range ()); 
        // Check region selection
        if (range.match(region_id) && region.group_name() == group_name) {
        // Build new range up to last_field and add it to result -
        // remove duplicate ranges with addRangeToMR
        Range new_range(prefix); // Prepend with prefix
 
        std::vector <IdDictFieldImplementation>::const_iterator fit; 
        for (fit = region.m_implementation.begin ();  
             fit != region.m_implementation.end (); 
             ++fit) { 
            const IdDictFieldImplementation& impl = *fit; 
 
//              new_range.add(impl.m_field);
            new_range.add(impl.range()->build_range());
 
            if (last_field == impl.range()->m_field->m_name) {
            break;
            }
        } 
        result.add(std::move(new_range));
        }
    } 
    }
  
    return (result); 
}

clear()

void IdDictDictionary::clear

(

)

Definition at line 1006 of file IdDictMgr.cxx.

{ 
  {  
    std::map<std::string, IdDictSubRegion*>::iterator it;  
    
    for (it = m_subregions.begin (); it != m_subregions.end (); ++it)  
      {  
        IdDictSubRegion* subregion = (*it).second;  
        subregion->clear ();  
        delete subregion; 
      }  
 
    m_subregions.clear (); 
  }  
 
  {  
    std::map<std::string, IdDictField*>::iterator it;  
  
    for (it = m_fields.begin (); it != m_fields.end (); ++it)  
      {  
        IdDictField* field = (*it).second;  
        field->clear ();  
        delete field; 
      }  
 
    m_fields.clear (); 
  }  
 
  {  
    IdDictDictionary::groups_it it; 
  
    for (it = m_groups.begin (); it != m_groups.end (); ++it) {
 
    IdDictGroup* group = *it;
        group->clear ();  
        delete group; 
      }  
 
    m_groups.clear (); 
  }  
} 

copy()

int IdDictDictionary::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

Copy a number of fields of the value_type id into another value_type id.

Copy a number of fields of the bits32 id into another bits32 id.

One specifies the begin and end (inclusive) field indexes desired and passes in the region index to be used for decoding. The region index is obtained from find_region. The first_field_index is normally 0. It is non-zero when fields 0 to first_field_index -1 are missing from the compact

One specifies the begin and end (inclusive) field indexes desired and passes in the region index to be used for decoding. The region index is obtained from find_region. The first_field_index is normally 0. It is non-zero when fields 0 to first_field_index -1 are missing from the compact. In this case, idout is shift by the number of missing bits, if possible.

Definition at line 1998 of file IdDictMgr.cxx.

{
 
    idout = Identifier();
    if (region_index >= m_regions.size()) {
    std::cout << "IdDictDictionary::copy - region index too large. Index, nregions " 
          << region_index << " " << m_regions.size() << std::endl;
    return (1);
    }
    
    const IdDictRegion& region = *m_regions[region_index];
 
    if (first_field_index >= region.m_implementation.size() ||
    begin_field_index >= region.m_implementation.size() ||
    end_field_index   >= region.m_implementation.size()) {
    std::cout << "IdDictDictionary::copy - field index too large. Indexes first, begin, end, nfields " 
          << first_field_index << " " 
          << begin_field_index << " " 
          << end_field_index << " " 
          << region.m_implementation.size() 
          << std::endl;
    return (1);
    }
 
    size_t missing_offset = 0;
    if (first_field_index) {
    if (first_field_index > begin_field_index) {
        std::cout << "IdDictDictionary::copy - first_field_index > begin_field_index. Indexes " 
              << first_field_index << " " << begin_field_index << std::endl;
        return (1);
    }
    // One or more fields missing from prefix, get the offset
    missing_offset = region.m_implementation[first_field_index].bits_offset();
    }
    
    size_t prefix_offset = 0;
    if (begin_field_index) {
    if (begin_field_index > end_field_index) {
        std::cout << "IdDictDictionary::copy - begin_field_index > end_field_index. Indexes " 
              << begin_field_index << " " << end_field_index << std::endl;
        return (1);
    }
    // One or more fields missing from prefix, get the offset
    prefix_offset = region.m_implementation[begin_field_index].bits_offset();
    }
    
    const IdDictFieldImplementation& impl = region.m_implementation[end_field_index]; 
    size_t suffix_offset = impl.bits() + impl.bits_offset();
 
    size_t position = Identifier::NBITS; // overall bit position
 
    if (position < prefix_offset - missing_offset) {
    std::cout << "IdDictDictionary::copy - position < prefix + missing. " 
              << prefix_offset << " " << missing_offset << std::endl;
    return (1);
    }
    
    
    if (position < suffix_offset + missing_offset) {
    std::cout << "IdDictDictionary::copy - position < suffix + missing. " 
              << suffix_offset << " " << missing_offset << std::endl;
    return (1);
    }
 
 
    // prepare the mask for copying
 
    Identifier::value_type mask = Identifier::ALL_BITS;
 
    Identifier::value_type prefix_mask = prefix_offset ? (static_cast<Identifier::value_type>(1) << (position - prefix_offset + missing_offset)) - 1 : 0;
    
    Identifier::value_type suffix_mask = (static_cast<Identifier::value_type>(1) << (position - suffix_offset + missing_offset)) - 1;
 
    mask -= prefix_mask + suffix_mask;
    
    idout = idin.mask_shift(mask, missing_offset);
 
//      std::cout << hex << "pre, suff, in, out " << prefix_mask << " " 
//            << suffix_mask << " " 
//            << idin << " " 
//            << idout << " "
//            << missing_offset << " " 
//            << prefix_offset << " " 
//            << suffix_offset << " "
//            << std::endl;
    
 
    return (0);
}

dict_tag()

std::string IdDictDictionary::dict_tag ( void  ) const

inline

Access to the dictionary tag.

Definition at line 700 of file IdDictDefs.h.

{
    return (m_dict_tag);
}

do_checks()

bool IdDictDictionary::do_checks

(

void

)

const

Checks are performed by default in debug compilation and NOT in optimized compilation.

One can switch or query this mode for any idHelper with the following methods:

Definition at line 2096 of file IdDictMgr.cxx.

{
    return (m_do_checks);
}

do_neighbours()

bool IdDictDictionary::do_neighbours

(

void

)

const

Neighbour initialization is performed by default One can switch or query this mode for any idHelper with the following methods:

Definition at line 2108 of file IdDictMgr.cxx.

{
    return (m_do_neighbours);
}

file_name()

std::string IdDictDictionary::file_name ( void  ) const

inline

Access to file name.

Definition at line 692 of file IdDictDefs.h.

{
    return (m_file_name);
}

find_field()

IdDictField * IdDictDictionary::find_field

(

const std::string &

name

)

const

Definition at line 309 of file IdDictMgr.cxx.

{ 
  std::map <std::string, IdDictField*>::const_iterator it;  
  
  it = m_fields.find (name);  
  
  if (it == m_fields.end ()) {
      // If parent exists, look for field there
      if(m_parent_dict) {
      it = m_parent_dict->m_fields.find (name);  
      if (it == m_parent_dict->m_fields.end ()) {
          return (0);  
      }
      }
      else {
      return (0);  
      }
  }
  
  return ((*it).second);  
} 

find_group()

IdDictGroup * IdDictDictionary::find_group

(

const std::string &

group_name

)

const

Definition at line 383 of file IdDictMgr.cxx.

{ 
  for (size_t i = 0; i < m_groups.size (); ++i) 
    { 
      IdDictGroup* group = m_groups[i]; 
      if ((group != 0) && (group->name() == group_name)) return (group); 
    } 
 
  return (0); 
} 

find_label()

IdDictLabel * IdDictDictionary::find_label	(	const std::string &	field,
		const std::string &	label
	)		const

Definition at line 331 of file IdDictMgr.cxx.

{
    IdDictField* idField = find_field(field);
    if (!idField) return (0);
    return (idField->find_label(label));
}

find_region() [1/5]

IdDictRegion * IdDictDictionary::find_region

(

const ExpandedIdentifier &

id

)

const

Definition at line 886 of file IdDictMgr.cxx.

{
  return find_region (id, "");
}

find_region() [2/5]

IdDictRegion * IdDictDictionary::find_region	(	const ExpandedIdentifier &	id,
		const std::string &	group_name
	)		const

Definition at line 891 of file IdDictMgr.cxx.

{
    // Find first region that matches id
 
  IdDictRegion* pRegion = 0; 
    IdDictDictionary::regions_const_it it; 
 
    for (it = m_regions.begin (); it != m_regions.end (); ++it) { 
    IdDictRegion& region = *(*it);
        if ( (group_name!= "") && (region.group_name() != group_name) ) continue;
 
    Range range = region.build_range();  
 
    if (range.match(id) && range.fields() >= id.fields()) {
        pRegion = &region;  
    }
    }  
 
    return (pRegion);
}

find_region() [3/5]

int IdDictDictionary::find_region	(	const ExpandedIdentifier &	id,
		size_type &	index
	)		const

Find first region that matches id.

Definition at line 863 of file IdDictMgr.cxx.

{
 
    // Find first region that matches id
 
    IdDictDictionary::regions_const_it it; 
 
    size_type i = 0;
    for (it = m_regions.begin (); it != m_regions.end (); ++it, ++i) { 
    const IdDictRegion& region = *(*it);
 
    Range range = region.build_range();  
 
    if (range.match(id) && range.fields() >= id.fields()) {
        index = i;  
        return (0);
    }
    }  
 
    return (1);
}

find_region() [4/5]

IdDictRegion * IdDictDictionary::find_region

(

const std::string &

region_name

)

const

Definition at line 366 of file IdDictMgr.cxx.

{
  return find_region (region_name, "");
}

find_region() [5/5]

IdDictRegion * IdDictDictionary::find_region	(	const std::string &	region_name,
		const std::string &	group_name
	)		const

Definition at line 371 of file IdDictMgr.cxx.

{ 
  for (size_t i = 0; i < m_regions.size (); ++i) 
    { 
      IdDictRegion* region = m_regions[i]; 
      if ( (group_name!= "") && (region->group_name() != group_name) ) continue;
      if ((region != 0) && (region_name == region->m_name)) return (region); 
    } 
 
  return (0); 
} 

find_subregion()

IdDictSubRegion * IdDictDictionary::find_subregion

(

const std::string &

subregion_name

)

const

Definition at line 355 of file IdDictMgr.cxx.

{ 
  std::map <std::string, IdDictSubRegion*>::const_iterator it;  
  
  it = m_subregions.find (name);  
  
  if (it == m_subregions.end ()) return (0);  
  
  return ((*it).second);  
} 

generate_implementation()

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

Definition at line 787 of file IdDictMgr.cxx.

{ 
 
  if (Debugger::debug ()) 
    { 
      std::cout << "IdDictDictionary::generate_implementation>" << std::endl; 
    } 
  
  if (!m_generated_implementation) {
      
      // Propagate to each region and copy their generation into the
      // dict's vector.
      IdDictDictionary::groups_it it; 
      for (it = m_groups.begin (); it != m_groups.end (); ++it) { 
      (*it)->generate_implementation (idd, *this, tag);  
      // Get regions from group and save in m_regions
      const regions_type& regions = (*it)->regions();
      IdDictDictionary::regions_const_it it1; 
      for (it1 = regions.begin(); it1 != regions.end(); ++it1) {
          m_regions.push_back(*it1);
      }
      }  
 
      // Loop again over groups and set the bit-packing - starting at
      // level 0
      for (it = m_groups.begin (); it != m_groups.end (); ++it) { 
      // Copy to temporary vector all regions in the group. And
      // look for regions in local m_regions vector for any
      // regions "dummy", which come from reference
      // dictionaries.
 
//          std::cout << "Group: " << (*it)->name() << std::endl;
      
//        IdDictDictionary::regions_type regions((*it)->regions());
//        IdDictDictionary::regions_const_it it1; 
//        for (it1 = m_regions.begin (); it1 != m_regions.end (); ++it1) { 
//            if ("dummy" == (*it1)->m_name) {
//            regions.push_back(*it1);
//            std::cout << "adding " << (*it1)->m_index << std::endl;
//            }
//        }
 
      // Skip special group
      if ("dummy" == (*it)->name()) continue;
      
      get_bits (m_regions, 0, (*it)->name()); 
//    get_bits (regions, 0, (*it)->name()); 
      }
 
      // Set integral over the number of bits
      integrate_bits ();
 
      // Set neighbours for regions
      IdDictDictionary::regions_it itr; 
      for (itr = m_regions.begin (); itr != m_regions.end (); ++itr) { 
      (*itr)->find_neighbours(*this);  
      }
      
      m_generated_implementation = true;
  } 
} 

get_label_value()

int IdDictDictionary::get_label_value	(	const std::string &	field,
		const std::string &	label,
		int &	value
	)		const

Definition at line 338 of file IdDictMgr.cxx.

{
    IdDictLabel* idLabel = find_label(field, label);
    if (!idLabel || !idLabel->m_valued) return (1);
    value = idLabel->m_value;
    return (0);
}

integrate_bits()

void IdDictDictionary::integrate_bits

(

)

Set up integral of bits for efficient unpacking.

Definition at line 913 of file IdDictMgr.cxx.

{
    // For each region, loop over its levels and set the bit offset
    // for each FieldImplementation
 
    for (IdDictRegion* region : m_regions) {
    size_t bits_offset = 0; 
 
        for (IdDictFieldImplementation& impl : region->m_implementation) {
        impl.optimize(); // optimize for decoding
        impl.set_bits_offset(bits_offset);
        bits_offset += impl.bits();
 
        // Set whether or not to decode index
        Range::field field = impl.ored_field();
        if (Range::field::both_bounded != field.get_mode() ||
        0 != field.get_minimum())
            {
        impl.set_decode_index(true); 
        }
    }
    }
}

pack32() [1/2]

int IdDictDictionary::pack32	(	const ExpandedIdentifier &	id,
		size_t	index1,
		size_t	index2,
		Identifier &	packedId
	)		const

Pack to 32bits the subset of id between (inclusive) index1 and index2 - this is generic, i.e.

not the most efficient

Assumptions:

• packedId is initialized to 0
• the expanded id begins at index = 0
• index1,2 correspond to the level/field number, this is thus the same as the index into the expanded id due to the previous assumption.

First we need to check whether the specified identifier really matches the Dictionary specifications.

However, we stop the search in the set of regions at the first matching region. Should we request that only one region matches ????

Definition at line 1234 of file IdDictMgr.cxx.

{ 
    packedId  = 0;
 
//    std::cout << "IdDictDictionary::pack32: index1,2, fields " 
//          << index1 << " " << index2 << " " << id.fields() 
//          << " " << (std::string)id << std::endl; 
      
    // Preconditions... 
 
    if (index2 < index1) { 
        // bad parameters. 
        return (1); 
    } 
 
    if (index1 >= id.fields ()) { 
        // nothing very useful !! 
        return (1); 
    } 
 
    if (index2 >= id.fields ()) { 
        // bad parameter... 
        return (1); 
    } 
 
    for (size_t k = 0; k < m_regions.size (); ++k) { 
        bool selected = true; 
 
        const IdDictRegion& region = *m_regions[k];
 
        // Must skip empty regions - can arise when a tag selects an
        // empty region
        if (region.m_is_empty) continue;
 
        for (size_t i = 0; i < region.m_implementation.size (); ++i) { 
            if (i >= id.fields ()) break; 
 
            const IdDictFieldImplementation& impl = region.m_implementation[i]; 
 
            if (!impl.field().match (id[i]))  { 
//                std::cout << "Region #" << region.m_index << 
//            " field " << impl.range()->m_field_name << 
//            " #" << i << " (" << (std::string) impl.field() << ") does not match " << 
//            id[i] << std::endl; 
 
                selected = false; 
                break; 
            } 
        } 
 
        if (selected) { 
            size_t position = Identifier::NBITS;
 
//            std::cout << "Region #" << region.m_index << " selected" << std::endl; 
 
            // We have the proper region. 
            for (size_t i = index1; i <= index2; ++i) { 
                const IdDictFieldImplementation& impl = region.m_implementation[i]; 
 
                Identifier::value_type index = impl.ored_field().get_value_index (id[i]);
 
                if (0 == position && impl.bits() > 0) {
                    return(1);
                }
          
                position -= impl.bits(); 
                packedId |= (index << position); 
 
//                std::cout << "  pack " << id[i] << " using field " << 
//                    impl.range()->m_field_name << 
//            " #" << i << " (" << (std::string) impl.ored_field() << ")" << 
//            " -> index=" << index << 
//            " @bit" << position << 
//            std::endl; 
 
            } 
            break; 
        } 
    } 
 
//    std::cout << "  packed " << hex << packedId << dec << std::endl; 
 
    return (0); 
} 

pack32() [2/2]

int IdDictDictionary::pack32	(	const int *	fields,
		size_t	index1,
		size_t	index2,
		size_t	region_index,
		Identifier &	packedId,
		size_t	first_field_index = 0
	)		const

Pack to 32bits the subset of id between (inclusive) index1 and index2.

Here one must provide the region index, which can be found with find_region. This is more efficient than the above pack32.

Assumptions: (different than the previous pack32)

• packedId is NOT initialized to 0 - allows to just overwrite the specified fields
• the field array begins at index1, i.e. NOT the first field
• the field array field array has a length of index2-index1+1
• index1,2 correspond to the level/field number
• first_field_index defines the offset for packing. Normally, this is this is 0. But this may be a field > 0, but of course <= index1

Definition at line 1334 of file IdDictMgr.cxx.

{ 
 
//    std::cout << "IdDictDictionary::pack32: index1,2, fields " 
//          << index1 << " " << index2 << " " << id.fields() 
//          << " " << (std::string)id << std::endl; 
      
    // Preconditions... 
 
    if (m_do_checks) {
    
    if (index2 < index1) { 
        // bad parameters. 
        std::cout << "IdDictDictionary::pack32 - index2 < index1 - 1,2"
              << index1 << " " << index2 << std::endl;
        return (1); 
    } 
 
    if (region_index >= m_regions.size()) {
        // bad parameters. 
        std::cout << "IdDictDictionary::pack32 - region index incorrect - index,size"
              << region_index << " " << m_regions.size() << std::endl;
        return (1); 
    }
    }
    
 
    // Get the region
    const IdDictRegion& region = *m_regions[region_index];
 
    if (m_do_checks) {
    if (region.m_is_empty) {
        std::cout << "IdDictDictionary::pack32 - region id empty" << std::endl;
        // bad parameters. 
        return (1); 
    }
    if(index1 < first_field_index) {
        std::cout << "IdDictDictionary::pack32 - first_field_index > index1 " 
              << first_field_index << " " << index1 <<  std::endl;
        return (1); 
    }
    }
    
    // Set the starting position
    size_t position = Identifier::NBITS;
    if(!first_field_index) {
    const IdDictFieldImplementation& impl = region.m_implementation[index1]; 
    position -= impl.bits_offset(); 
    }
    
    size_t field_index = 0;
    for (size_t i = index1; i <= index2; ++i, ++field_index) { 
 
    const IdDictFieldImplementation& impl = region.m_implementation[i]; 
 
    if (m_do_checks) {
 
        // Field should be within allowed range
        if (!impl.ored_field().match(fields[field_index])) {
        std::cout << "IdDictDictionary::pack32 - field does NOT match: value, allowed values " 
              << fields[field_index] << " " << (std::string)impl.ored_field()
              << std::endl;
        // bad parameters. 
        return (1); 
        }
 
        // Check that we don't try to go below 0
        if (0 == position && impl.bits() > 0) {
        std::cout << "IdDictDictionary::pack32 - going past 0" << std::endl;
        return(1);
        }
    }
 
        Identifier::value_type index;
    if (impl.decode_index()) {
        index = impl.ored_field().get_value_index (fields[field_index]); 
    }
    else {
            index = (Identifier::value_type)fields[field_index];
    }
    
    position -= impl.bits(); 
    packedId |= (index << position); 
 
 
//                std::cout << "  pack " << id[field_index] << " using field " << 
//                    impl.range()->m_field_name << 
//            " #" << i << " (" << (std::string) impl.ored_field() << ")" << 
//            " -> index=" << index << 
//            " @bit" << position << 
//            std::endl; 
 
    } 
 
    //std::cout << "  packed " << std::hex << packedId << std::dec << std::endl; 
 
    return (0); 
} 

reset()

int IdDictDictionary::reset	(	size_t	index1,
		size_t	index2,
		size_t	region_index,
		Identifier &	packedId
	)		const

Reset fields from index1 to index2.

Definition at line 1441 of file IdDictMgr.cxx.

{
 
    // Preconditions... 
 
    if (m_do_checks) {
    
    if (index2 < index1) { 
        // bad parameters. 
        std::cout << "IdDictDictionary::pack32 - index2 < index1 - 1,2"
              << index1 << " " << index2 << std::endl;
        return (1); 
    } 
 
    if (region_index >= m_regions.size()) {
        // bad parameters. 
        std::cout << "IdDictDictionary::pack32 - region index incorrect - index,size"
              << region_index << " " << m_regions.size() << std::endl;
        return (1); 
    }
    }
    
 
    // Get the region
    const IdDictRegion& region = *m_regions[region_index];
 
    if (m_do_checks) {
    if (region.m_is_empty) {
        std::cout << "IdDictDictionary::pack32 - region id empty" << std::endl;
        // bad parameters. 
        return (1); 
    }
    }
    
    size_t field_index = 0;
    for (size_t i = index1; i <= index2; ++i, ++field_index) { 
 
    const IdDictFieldImplementation& impl = region.m_implementation[i]; 
 
    size_t position = Identifier::NBITS - impl.bits_offset() - impl.bits(); 
 
    Identifier::value_type mask = (((Identifier::value_type)1 << impl.bits()) - 1) << position;
 
    mask ^= Identifier::ALL_BITS;
 
    packedId &= (mask);
 
    } 
    return (0); 
}

reset_implementation()

void IdDictDictionary::reset_implementation

(

)

Definition at line 850 of file IdDictMgr.cxx.

{ 
  if (m_generated_implementation) {
      m_regions.clear();
      IdDictDictionary::groups_it it; 
      for (it = m_groups.begin (); it != m_groups.end (); ++it) { 
      (*it)->reset_implementation();  
      }  
      m_generated_implementation = false;
  } 
} 

resolve_references()

void IdDictDictionary::resolve_references

(

const IdDictMgr &

idd

)

Definition at line 421 of file IdDictMgr.cxx.

{ 
  {  
    std::map<std::string, IdDictField*>::iterator it;  
  
    for (it = m_fields.begin (); it != m_fields.end (); ++it)  
      {  
        IdDictField* field = (*it).second;  
        field->resolve_references (idd);  
      }  
  }  
  {  
    std::map<std::string, IdDictSubRegion*>::iterator it;  
  
    for (it = m_subregions.begin (); it != m_subregions.end (); ++it)  
      {  
        IdDictSubRegion* subregion = (*it).second;  
        subregion->resolve_references (idd, *this);  
      }  
  }  
  {  
    size_t index = 0; 
 
    IdDictDictionary::groups_it it; 
    for (it = m_groups.begin (); it != m_groups.end (); ++it)  
      {  
        (*it)->resolve_references (idd, *this, index);  
      }  
  }  
} 

set_dict_tag()

void IdDictDictionary::set_dict_tag ( const std::string &  tag )

inline

Set the dictionary tag.

Definition at line 716 of file IdDictDefs.h.

{
    m_dict_tag = tag;
}

set_do_checks()

void IdDictDictionary::set_do_checks

(

bool

do_checks

)

Definition at line 2102 of file IdDictMgr.cxx.

{
    m_do_checks = do_checks;
}

set_do_neighbours()

void IdDictDictionary::set_do_neighbours

(

bool

do_neighbours

)

Definition at line 2114 of file IdDictMgr.cxx.

{
    m_do_neighbours = do_neighbours;
}

set_file_name()

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

inline

Set file name.

Definition at line 708 of file IdDictDefs.h.

{
    m_file_name = name;
}

sort()

void IdDictDictionary::sort

(

)

Sort:

Prerequisite: first verify the dictionary - no overlaps

Then loop over regions and sort according to their first identifier

Definition at line 986 of file IdDictMgr.cxx.

{ 
    // verify
    if (verify()) {
 
    std::map< ExpandedIdentifier, IdDictDictEntry* > regions;
      
    IdDictDictionary::groups_it it; 
 
    for (it = m_groups.begin (); it != m_groups.end (); ++it) { 
 
        (*it)->sort();
    }
    }
    else {
    std::cout << "IdDictDictionary::sort - WARNING verify is FALSE - cannot sort "
          << std::endl; 
    }
} 

unpack() [1/3]

int IdDictDictionary::unpack	(	const Identifier &	id,
		const ExpandedIdentifier &	prefix,
		size_t	index2,
		const std::string &	sep,
		std::string &	unpackedId
	)		const

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

Unpack the bits32 id to a string, considering the provided prefix (result will include the prefix) and up to index2 - (index1 is assumed to be 0, i.e.

part of prefix).

First we need to check whether the specified identifier prefix really matches the Dictionary specifications.

ok we require that the region is at least as large as the prefix.

We have one region that matches the prefix. Let's now try to expand the bits32 from the fields of the region that are beyond the prefix.

this index extracted from the bits32 does not seem to match this field in the region... Let's try another region

this index extracted from the bits32 does not match this field in the region... Let's try another region

Definition at line 1671 of file IdDictMgr.cxx.

{ 
 
    ExpandedIdentifier localPrefix (prefix);
    //unpackedId.clear ();
    //if (0 < localPrefix.fields ()) unpackedId = localPrefix;
 
    size_t index1   = 0;  // field index
    size_t position = Identifier::NBITS; // overall bit position - used for debugging only
 
    for (size_t k = 0; k < m_regions.size (); ++k) { 
    bool selected = false; 
 
    const IdDictRegion& region = *m_regions[k];
 
    // Must skip empty regions - can arise when a tag selects an
    // empty region
    if (region.m_is_empty) continue;
 
//      for (size_t i = index1; i < region.m_implementation.size (); ++i) 
    for (size_t i = 0; i < region.m_implementation.size (); ++i) { 
        if (i >= localPrefix.fields ()) { 
        selected = true; 
        index1 = i; 
        break; 
        } 
 
        const IdDictFieldImplementation& impl = region.m_implementation[i]; 
 
        if (!impl.field().match (localPrefix[i])) { 
//                std::cout << "Region #" << region.m_index << 
//                    " field " << impl.range()->m_field_name << 
//                    " #" << i << " (" << (std::string) impl.field() << ") does not match " << 
//                    localPrefix[i] << std::endl; 
 
        break; 
        } 
    } 
 
    if (selected) { 
//               bits32 temp = id; 
 
//        std::cout << "Region #" << region.m_index << " selected" << std::endl; 
 
        for (size_t i = index1; i < region.m_implementation.size (); ++i) { 
        const IdDictFieldImplementation& impl = region.m_implementation[i]; 
 
        if (impl.bits() == 0) continue; 
 
        Identifier::value_type mask = (static_cast<Identifier::value_type>(1) << impl.bits()) - 1; 
 
        if (position < impl.bits()) break;  // Nothing more to get
        size_t index = id.extract(position - impl.bits(), mask);
          
//            std::cout << "Region #" << region.m_index << 
//            " field " << impl.range()->m_field_name << 
//            " #" << i << " (" << (std::string) impl.field() << ") index " << 
//            index << " bits " << impl.bits() << " mask " << hex << mask << " id " << 
//            id << dec << std::endl; 
 
//                size_t index = temp & mask; 
//                temp >>= impl.bits(); 
 
        if (index >= impl.ored_field().get_indices ()) { 
//                    std::cout << "  unpack " << index << " using field " << 
//                        impl.range()->m_field_name <<  
//                        " #" << i << " (" << (std::string) impl.ored_field() << ")" <<  
//                        " -> mismatch" <<  
//                        " @bit" << position <<  
//                        std::endl;  
            selected = false; 
            break; 
        } 
 
        ExpandedIdentifier::element_type value = impl.ored_field().get_value_at (index); 
 
        if (!impl.field().match (value)) { 
//                std::cout << "Region #" << region.m_index << 
//                " field " << impl.range()->m_field_name << 
//                " #" << i << " (" << (std::string) impl.field() << ") does not match " << 
//                value << std::endl; 
            selected = false; 
            break; 
        }   
          
//                std::cout << "Region #" << region.m_index << " sel " << selected <<
//            "  unpack " << index << " using field " << 
//                    impl.range()->m_field_name << 
//                    " #" << i << " (" << (std::string) impl.ored_field() << ")" << 
//                    " -> value=" << value << 
//                    " @bit" << position << " nbits " << impl.bits() <<
//                    std::endl; 
 
        // Found value
 
        // Add value to string
 
        std::string str_value("nil");
        char temp[20];
 
        // The policy below is:
        //   - if a value is a character string or name, just add this name
        //   - if a value is a number, then prefix it with the
        //     name of the field
        //
        // NOTE: min/max is a number, but for value/label we
        // distinguish between number and name by looking for an IdDictLabel
        const IdDictRange*  range = impl.range(); 
        IdDictLabel* label = range->m_field->find_label(range->m_label);  
        switch (range->m_specification) { 
        case IdDictRange::by_minvalue: 
        case IdDictRange::by_maxvalue: 
        case IdDictRange::by_minmax: 
            // For a range of values (numbers), add in the field name
            str_value = range->m_field->m_name + ' ';
            sprintf (temp, "%d", value);
            str_value += temp;
            break; 
        case IdDictRange::by_value: 
        case IdDictRange::by_label: 
            str_value = "";
            if (!label) {
            // Is a number, add in field name
            str_value += range->m_field->m_name + ' ';
            }
            str_value += range->m_label;
            break; 
        case IdDictRange::by_values: 
        case IdDictRange::by_labels: 
            str_value = "";
            // Is a name
            if (label) {
            // Found label with "find_label" on the field
            if (label->m_valued) {
                str_value += range->m_label;
            }
            }
            else {
            // If not found with the "find" above, we must
            // get the value and name from the range
            // itself.
 
            unsigned int index1 = 0;
            for (; index1 < range->m_values.size(); ++index1) {
                if (value == range->m_values[index1]) {
                break;
                }
            }
 
            // In some cases we 
            if (index1 < range->m_labels.size()) {
                if (isNumber(range->m_labels[index1])) {
                str_value += range->m_field->m_name + ' ';
                }
                str_value += range->m_labels[index1];
            }
            else {
                std::cout << "IdDictDictionary::unpack - Could not find value." << std::endl;
                std::cout << "value " << value << std::endl;
                std::cout << "field values " << std::endl;
                for (unsigned int i=0; i < range->m_values.size(); ++i) {
                std::cout << range->m_values[i] << " ";
                }
                std::cout << std::endl;
            }
            }
            break; 
        case IdDictRange::unknown: 
 
            std::cout << "unknown" << std::endl;
            
            break; 
        }
        
 
        if (index1)unpackedId += sep;
        unpackedId += str_value;
        localPrefix.add (value);
 
        position -= impl.bits(); // overall bit position
 
//            id = temp; // set id to shifted value
 
 
        index1++;  // next field
 
        if (index1 > index2) break; // quit at index2
        }
        if (selected) break; 
    } 
  } 
 
  return (0); 
} 

unpack() [2/3]

int IdDictDictionary::unpack	(	const Identifier &	id,
		const ExpandedIdentifier &	prefix,
		size_t	index2,
		ExpandedIdentifier &	unpackedId
	)		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.

Unpack the bits32 id to an expanded Identifier, considering the
provided prefix (result will include the prefix)

part of prefix).

First we need to check whether the specified identifier prefix really matches the Dictionary specifications.

ok we require that the region is at least as large as the prefix.

We have one region that matches the prefix. Let's now try to expand the bits32 from the fields of the region that are beyond the prefix.

this index extracted from the bits32 does not seem to match this field in the region... Let's try another region

this index extracted from the bits32 does not match this field in the region... Let's try another region

Definition at line 1510 of file IdDictMgr.cxx.

{ 
 
  ExpandedIdentifier localPrefix (prefix);
  unpackedId.clear ();
  if (0 < localPrefix.fields ()) unpackedId = localPrefix;
 
  size_t index1   = 0;  // field index
  size_t position = Identifier::NBITS; // overall bit position - used for debugging only
 
  for (size_t k = 0; k < m_regions.size (); ++k) 
    { 
      bool selected = false; 
 
      const IdDictRegion& region = *m_regions[k];
 
      // Must skip empty regions - can arise when a tag selects an
      // empty region
      if (region.m_is_empty) continue;
 
//      for (size_t i = index1; i < region.m_implementation.size (); ++i) 
      for (size_t i = 0; i < region.m_implementation.size (); ++i) 
        { 
          if (i >= localPrefix.fields ()) 
            { 
              selected = true; 
              index1 = i; 
              break; 
            } 
 
          const IdDictFieldImplementation& impl = region.m_implementation[i]; 
 
          if (!impl.field().match (localPrefix[i]))  
            { 
//                std::cout << "Region #" << region.m_index << 
//                    " field " << impl.range()->m_field_name << 
//                    " #" << i << " (" << (std::string) impl.field() << ") does not match " << 
//                    localPrefix[i] << std::endl; 
 
              break; 
            } 
        } 
 
      if (selected) 
        { 
//            bits32 temp = id; 
 
//        std::cout << "Region #" << region.m_index << " selected" << std::endl; 
 
          for (size_t i = index1; i < region.m_implementation.size (); ++i) 
            { 
              const IdDictFieldImplementation& impl = region.m_implementation[i]; 
 
              if (impl.bits() == 0) continue; 
 
              Identifier::value_type mask = (static_cast<Identifier::value_type>(1) << impl.bits()) - 1; 
 
          if (position < impl.bits()) break;  // Nothing more to get
              size_t index = id.extract(position - impl.bits(), mask);
          
//            std::cout << "Region #" << region.m_index << 
//            " field " << impl.range()->m_field_name << 
//            " #" << i << " (" << (std::string) impl.field() << ") index " << 
//            index << " bits " << impl.bits() << " mask " << hex << mask << " id " << 
//            id << dec << std::endl; 
 
//                size_t index = temp & mask; 
//                temp >>= impl.bits(); 
 
              if (index >= impl.ored_field().get_indices ()) 
                { 
//                    std::cout << "  unpack " << index << " using field " << 
//                        impl.range()->m_field_name <<  
//                        " #" << i << " (" << (std::string) impl.ored_field() << ")" <<  
//                        " -> mismatch" <<  
//                        " @bit" << position <<  
//                        std::endl;  
 
                  selected = false; 
                  break; 
                } 
 
              ExpandedIdentifier::element_type value = impl.ored_field().get_value_at (index); 
 
          if (!impl.field().match (value))  
          { 
//                std::cout << "Region #" << region.m_index << 
//                " field " << impl.range()->m_field_name << 
//                " #" << i << " (" << (std::string) impl.field() << ") does not match " << 
//                value << std::endl; 
 
              selected = false; 
              break; 
          } 
 
//                std::cout << "Region #" << region.m_index << " sel " << selected <<
//            "  unpack " << index << " using field " << 
//                    impl.range()->m_field_name << 
//                    " #" << i << " (" << (std::string) impl.ored_field() << ")" << 
//                    " -> value=" << value << 
//                    " @bit" << position << " nbits " << impl.bits() <<
//                    std::endl; 
 
          // Found value
 
              unpackedId.add (value); 
          localPrefix.add (value);
 
              position -= impl.bits(); // overall bit position
 
//            id = temp; // set id to shifted value
 
 
          index1++;  // next field
 
          if (index1 > index2) break; // quit at index2
            } 
 
          if (selected) break; 
        } 
    } 
 
  return (0); 
} 

unpack() [3/3]

int IdDictDictionary::unpack	(	const Identifier &	id,
		size_t	first_field_index,
		size_t	field_index,
		size_t	region_index,
		int &	field
	)		const

Unpack a single field of the value_type id.

Unpack a single field of the bits32 id.

One specifies the field index desired and passes in the region index to be used for decoding. The region index is obtained from find_region. The first_field_index is normally 0. It is non-zero when fields 0 to first_field_index -1 are missing from the compact

Definition at line 1907 of file IdDictMgr.cxx.

{
    field = 0; 
 
    if (m_do_checks) {
    
    // Check regions
    if (region_index >= m_regions.size()) {
        std::cout << "IdDictDictionary::unpack - region index too large. Index, nregions " 
              << region_index << " " << m_regions.size() << std::endl;
        return (1);
    }
    }
 
    const IdDictRegion& region = *m_regions.at(region_index);
 
    if (m_do_checks) {
    
    // check number of fields
    if (field_index >= region.m_implementation.size()) {
        std::cout << "IdDictDictionary::unpack - field index too large. Index, nfields " 
              << field_index << " " << region.m_implementation.size() 
              << std::endl;
        return (1);
    }
    
    }
    
    const IdDictFieldImplementation& impl = region.m_implementation.at(field_index); 
    size_t prefix_offset = 0;
 
    size_t position = Identifier::NBITS; // overall bit position
 
    // One or more fields missing from prefix, get the offset
    if (first_field_index) {
    if (m_do_checks) {
        if (first_field_index >= region.m_implementation.size()) {
        std::cout << "IdDictDictionary::unpack - first_field_index too large. Index, nfields " 
              << first_field_index << " " << region.m_implementation.size() 
              << std::endl;
        return (1);
        }
    }
    
    // One or more fields missing from prefix, get the offset
    prefix_offset = region.m_implementation[first_field_index].bits_offset();
 
    if (m_do_checks) {
        // Should have a non-zero number of bits
        if (impl.bits() == 0) {
        std::cout << "IdDictDictionary::unpack - no bits for this field. Region, field indexes " 
              << region_index << " " << field_index << std::endl;
        return (1);
        }
 
        // Check the shift value
        if (impl.bits() + impl.bits_offset() - prefix_offset > position) {
        std::cout << "IdDictDictionary::unpack - bits + offset too large. Region, field indexes, bits, offset " 
              << region_index << " " << field_index << " "
              << impl.bits() << " " << impl.bits_offset()  << " " << prefix_offset
              << std::endl;
        return (1);
        }
    }
    }
 
    Identifier::value_type mask = (static_cast<Identifier::value_type>(1) << impl.bits()) - 1; 
 
    size_t index = id.extract(position -= impl.bits() + impl.bits_offset() - prefix_offset, mask);
 
    field = index;
    if (impl.decode_index()) field = impl.ored_field().get_value_at (index); 
 
 
    return (0);
}

verify()

bool IdDictDictionary::verify

(

)

const

Here, we verify global constraints : (this must only be applied after the resolve_references and
generate_implementation operations)

a) There should be no overlap between any region duet.

b) In a dictionary, a given field (ie. with a given name) must always be referenced at the same depth across all regions and subregions.

c) When a region specifies a reference to a sub-dictionary :

• the reference must be the last entry in the region
• the first region entries of all regions should not overlap (regardless of the definition of the sub-dictionary). IE the first fields in
  these regions must be sufficient to unambiguously select the
  sub-dictionary.

d) Within a dictionary, a given field must always be described either through an enumeration, or through its bounds. However, the various usages of a
given field may specify different tag set (for enumerations) or bounds (for a bounded field).

Definition at line 962 of file IdDictMgr.cxx.

{ 
    // check #1 
 
  MultiRange mr = build_multirange (); 
  if (mr.has_overlap ()) return (false); 
 
    // check #2 
    // check #3 
    // check #4 
 
  return (true); 
} 

Member Data Documentation

m_all_regions

std::vector<IdDictRegion*> IdDictDictionary::m_all_regions

Definition at line 303 of file IdDictDefs.h.

m_author

std::string IdDictDictionary::m_author

Definition at line 286 of file IdDictDefs.h.

m_date

std::string IdDictDictionary::m_date

Definition at line 285 of file IdDictDefs.h.

m_dict_tag

std::string IdDictDictionary::m_dict_tag

private

Definition at line 310 of file IdDictDefs.h.

m_do_checks

bool IdDictDictionary::m_do_checks

private

Definition at line 313 of file IdDictDefs.h.

m_do_neighbours

bool IdDictDictionary::m_do_neighbours

private

Definition at line 314 of file IdDictDefs.h.

m_fields

std::map<std::string, IdDictField*> IdDictDictionary::m_fields

Definition at line 300 of file IdDictDefs.h.

m_file_name

std::string IdDictDictionary::m_file_name

private

Definition at line 309 of file IdDictDefs.h.

m_generated_implementation

bool IdDictDictionary::m_generated_implementation

private

Definition at line 312 of file IdDictDefs.h.

m_groups

std::vector<IdDictGroup*> IdDictDictionary::m_groups

Definition at line 304 of file IdDictDefs.h.

m_name

std::string IdDictDictionary::m_name

Definition at line 283 of file IdDictDefs.h.

m_parent_dict

IdDictDictionary* IdDictDictionary::m_parent_dict

Definition at line 306 of file IdDictDefs.h.

m_regions

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

Definition at line 302 of file IdDictDefs.h.

m_subdictionary_names

std::vector<std::string> IdDictDictionary::m_subdictionary_names

Definition at line 305 of file IdDictDefs.h.

m_subregions

std::map<std::string, IdDictSubRegion*> IdDictDictionary::m_subregions

Definition at line 301 of file IdDictDefs.h.

m_version

std::string IdDictDictionary::m_version

Definition at line 284 of file IdDictDefs.h.

---

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

• IdDictDefs.h
• IdDictMgr.cxx