IdDictGroup Class Reference

#include <IdDictGroup.h>

Collaboration diagram for IdDictGroup:

Public Member Functions
	IdDictGroup ()
	IdDictGroup (const std::string &name)
	~IdDictGroup ()
const std::string &	name ()
const std::vector< IdDictDictEntry * > &	entries ()
const std::vector< IdDictRegion * > &	regions ()
MultiRange	build_multirange () const
	Get MultiRange for this group. More...
void	add_dictentry (IdDictDictEntry *entry)
void	resolve_references (const 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: More...
void	clear ()

Private Attributes
std::string	m_name
std::vector< IdDictDictEntry * >	m_entries
std::vector< IdDictRegion * >	m_regions
bool	m_generated_implementation

Detailed Description

Definition at line 19 of file IdDictGroup.h.

Constructor & Destructor Documentation

IdDictGroup() [1/2]

IdDictGroup::IdDictGroup

(

)

Definition at line 20 of file IdDictGroup.cxx.

  :
  m_generated_implementation(false) {
}

IdDictGroup() [2/2]

IdDictGroup::IdDictGroup

(

const std::string &

name

)

Definition at line 25 of file IdDictGroup.cxx.

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

~IdDictGroup()

IdDictGroup::~IdDictGroup

(

)

Definition at line 31 of file IdDictGroup.cxx.

                           {
}

Member Function Documentation

add_dictentry()

void IdDictGroup::add_dictentry

(

IdDictDictEntry *

entry

)

Definition at line 72 of file IdDictGroup.cxx.

                                                  {
  m_entries.push_back(region);
}

build_multirange()

MultiRange IdDictGroup::build_multirange

(

)

const

Get MultiRange for this group.

Definition at line 49 of file IdDictGroup.cxx.

                                    {
  MultiRange result;
 
  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;
 
    Range r = region.build_range();
    result.add(std::move(r));
  }
 
  return(result);
}

clear()

void IdDictGroup::clear

(

)

Definition at line 185 of file IdDictGroup.cxx.

                   {
  IdDictDictionary::entries_it it;
 
  for (it = m_entries.begin(); it != m_entries.end(); ++it) {
    IdDictDictEntry* region = *it;
    region->clear();
    delete region;
  }
 
  m_entries.clear();
}

entries()

const std::vector< IdDictDictEntry * > & IdDictGroup::entries

(

)

Definition at line 39 of file IdDictGroup.cxx.

                     {
  return(m_entries);
}

generate_implementation()

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

Definition at line 90 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)
    IdDictDictionary::entries_it it;
    for (it = m_entries.begin(); it != m_entries.end(); ++it) {
      (*it)->generate_implementation(idd, dictionary, tag);
      // Get region and save in m_regions
      IdDictRegion* region = dynamic_cast<IdDictRegion*> (*it);
      if (region) {
        m_regions.push_back(region);
      } else {
        IdDictAltRegions* altregions = dynamic_cast<IdDictAltRegions*> (*it);
        if (altregions) {
          m_regions.push_back(altregions->m_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;
  }
}

name()

const std::string & IdDictGroup::name

(

)

Definition at line 34 of file IdDictGroup.cxx.

                                   {
  return(m_name);
}

regions()

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

(

)

Definition at line 44 of file IdDictGroup.cxx.

                     {
  return(m_regions);
}

reset_implementation()

void IdDictGroup::reset_implementation

(

)

Definition at line 126 of file IdDictGroup.cxx.

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

resolve_references()

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

Definition at line 77 of file IdDictGroup.cxx.

                                               {
  IdDictDictionary::entries_it it;
  for (it = m_entries.begin(); it != m_entries.end(); ++it) {
    (*it)->set_index(index);
    index++;
 
    (*it)->resolve_references(idd, dictionary);
  }
}

sort()

void IdDictGroup::sort

(

)

Sort:

Loop over regions and sort according to their first identifier

Definition at line 152 of file IdDictGroup.cxx.

                       {
  std::map< ExpandedIdentifier, IdDictDictEntry* > regions;
 
  IdDictDictionary::regions_it it;
 
  for (it = m_regions.begin(); it != m_regions.end(); ++it) {
    const IdDictRegion& region = *(*it);
    Range range = region.build_range();
    RangeIterator itr(range);
    auto first = itr.begin();
    auto last = itr.end();
    if (first != last) {
      regions[*first] = *it;
    } else {
      std::cout << "IdDictDictionary::sort - WARNING empty region cannot sort "
                << std::endl;
    }
  }
  if (regions.size() == m_regions.size()) {
    // Reorder the regions
    std::map< ExpandedIdentifier, IdDictDictEntry* >::iterator mapIt = regions.begin();
    std::vector<IdDictRegion*>::size_type vecIt = 0;
    for (; mapIt != regions.end(); ++mapIt, ++vecIt) {
      m_entries[vecIt] = (*mapIt).second;
    }
  } else {
    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;
  }
}

verify()

bool IdDictGroup::verify

(

)

const

Definition at line 138 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<IdDictDictEntry*> IdDictGroup::m_entries

private

Definition at line 48 of file IdDictGroup.h.

m_generated_implementation

bool IdDictGroup::m_generated_implementation

private

Definition at line 50 of file IdDictGroup.h.

m_name

std::string IdDictGroup::m_name

private

Definition at line 47 of file IdDictGroup.h.

m_regions

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

private

Definition at line 49 of file IdDictGroup.h.

---

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

• IdDictGroup.h
• IdDictGroup.cxx