IdDictDictionaryRef Class Reference

#include <IdDictDictionaryRef.h>

Inheritance diagram for IdDictDictionaryRef:

Collaboration diagram for IdDictDictionaryRef:

Public Member Functions
	IdDictDictionaryRef ()
	~IdDictDictionaryRef ()
void	resolve_references (const IdDictMgr &idd, IdDictDictionary &dictionary, IdDictRegion &region)
void	generate_implementation (const IdDictMgr &idd, IdDictDictionary &dictionary, IdDictRegion &region, const std::string &tag="")
void	reset_implementation ()
bool	verify () const
Range	build_range () const
virtual void	clear ()

Public Attributes
std::string	m_dictionary_name
IdDictDictionary *	m_dictionary {}

Private Attributes
bool	m_resolved_references {}
bool	m_generated_implementation {}
bool	m_propagated_information {}

Detailed Description

Definition at line 16 of file IdDictDictionaryRef.h.

Constructor & Destructor Documentation

IdDictDictionaryRef()

IdDictDictionaryRef::IdDictDictionaryRef

(

)

Definition at line 15 of file IdDictDictionaryRef.cxx.

  :
  m_dictionary(0),
  m_resolved_references(false),
  m_generated_implementation(false),
  m_propagated_information(false) {
}

~IdDictDictionaryRef()

IdDictDictionaryRef::~IdDictDictionaryRef

(

)

Definition at line 23 of file IdDictDictionaryRef.cxx.

                                           {
}

Member Function Documentation

build_range()

Range IdDictDictionaryRef::build_range ( ) const

virtual

Implements IdDictRegionEntry.

Definition at line 150 of file IdDictDictionaryRef.cxx.

                                             {
  Range result;
 
  return(result);
}

clear()

void IdDictRegionEntry::clear ( )

virtualinherited

Definition at line 29 of file IdDictRegionEntry.cxx.

                              {
}

generate_implementation()

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

virtual

Reimplemented from IdDictRegionEntry.

Definition at line 39 of file IdDictDictionaryRef.cxx.

                                                                        {
  if (!m_generated_implementation) {
    if (m_dictionary) {
      if (!m_propagated_information) {
        // Propagate information to referenced dictionary:
        //
        // 1) Loop over ranges in this region and add them to the
        // referenced dictionary, then propagate the generate
        // implementation
 
        // 2) Duplicate the regions of the current dictionary in
        // referenced dictionary. Only the top level range(s) need
        // to be propagated to correctly calculate the bits of the
        // upper levels.
 
        // Save a vector of entries to prepend, inverting their order
        std::vector<IdDictRegionEntry*> prepend_entries;
        std::vector<IdDictRegionEntry*>::iterator it;
        for (it = region.m_entries.begin(); it != region.m_entries.end(); ++it) {
          IdDictRegionEntry* entry = *it;
          if (this == entry) break; // end when we get to the dictionary (this)
          // If this is a range entry, add a duplicate to all
          // regions in the subdictionary
          IdDictRange* range = dynamic_cast<IdDictRange*> (entry);
          if (range) {
            prepend_entries.insert(prepend_entries.begin(), entry);
          }
        }
 
 
 
 
        // Now prepend list to each region and generate each region
        IdDictDictionary::regions_it it2;
        for (it2 = m_dictionary->m_all_regions.begin(); it2 != m_dictionary->m_all_regions.end(); ++it2) {
          IdDictRegion& region2 = *(*it2);
          for (it = prepend_entries.begin(); it != prepend_entries.end(); ++it) {
            IdDictRegionEntry* entry = *it;
            IdDictRange* range = dynamic_cast<IdDictRange*> (entry);
            if (range) {
              IdDictRangeRef* new_range = new IdDictRangeRef;
              new_range->m_range = range;
              region2.m_entries.insert(region2.m_entries.begin(), new_range);
            }
          }
        }
 
        // Now copy all prefixes into new regions in the
        // referenced dictionary
        if (prepend_entries.size() > 0) {
          // Save region number
          const IdDictRegion& region2 = *m_dictionary->m_all_regions.back();
          size_t region_number = region2.m_index + 1;
 
          IdDictDictionary::regions_it it;
 
          // Loop over all regions of current dict, add to ref dict (m_dictionary)
          for (it = dictionary.m_all_regions.begin(); it != dictionary.m_all_regions.end(); ++it, ++region_number) {
            IdDictRegion& region3 = *(*it);
            IdDictRegion* new_region = new IdDictRegion;
            new_region->m_name = "dummy";
            new_region->m_group = "dummy";
            new_region->m_index = region_number;
 
            // to all region vectors
            m_dictionary->m_all_regions.push_back(new_region);
            // to the entries of the dictionary
            m_dictionary->add_dictentry(new_region);
 
            // Now add in only the ranges
            std::vector<IdDictRegionEntry*>::iterator it;
            size_t i = 0;
            for (it = region3.m_entries.begin(); it != region3.m_entries.end(); ++it, ++i) {
              if (i >= prepend_entries.size()) continue;
 
              IdDictRegionEntry* entry = *it;
              IdDictRange* range = dynamic_cast<IdDictRange*> (entry);
              if (range) {
                IdDictRangeRef* new_range = new IdDictRangeRef;
                new_range->m_range = range;
                new_region->m_entries.push_back(new_range);
              }
            }
          }
        }
        m_propagated_information = true;
      }
      m_dictionary->generate_implementation(idd, tag);
      m_generated_implementation = true;
    } else {
      std::cout <<
      "IdDictDictionaryRef::generate_implementation: - WARNING no dictionary found, cannot generate implementation "
                << std::endl;
    }
  }
}

reset_implementation()

void IdDictDictionaryRef::reset_implementation ( )

virtual

Reimplemented from IdDictRegionEntry.

Definition at line 139 of file IdDictDictionaryRef.cxx.

                                               {
  if (m_generated_implementation) {
    m_dictionary->reset_implementation();
    m_generated_implementation = false;
  }
}

resolve_references()

void IdDictDictionaryRef::resolve_references ( const IdDictMgr &  idd, IdDictDictionary &  dictionary, IdDictRegion &  region  )

virtual

Reimplemented from IdDictRegionEntry.

Definition at line 26 of file IdDictDictionaryRef.cxx.

                                                              {
  if (!m_resolved_references) {
    m_dictionary = idd.find_dictionary(m_dictionary_name);
    if (m_dictionary) {
      m_dictionary->resolve_references(idd);
      m_dictionary->m_parent_dict = &dictionary;
    }
    m_resolved_references = true;
  }
}

verify()

bool IdDictDictionaryRef::verify ( ) const

virtual

Reimplemented from IdDictRegionEntry.

Definition at line 146 of file IdDictDictionaryRef.cxx.

                                       {
  return(true);
}

Member Data Documentation

m_dictionary

IdDictDictionary* IdDictDictionaryRef::m_dictionary {}

Definition at line 32 of file IdDictDictionaryRef.h.

m_dictionary_name

std::string IdDictDictionaryRef::m_dictionary_name

Definition at line 31 of file IdDictDictionaryRef.h.

m_generated_implementation

bool IdDictDictionaryRef::m_generated_implementation {}

private

Definition at line 38 of file IdDictDictionaryRef.h.

m_propagated_information

bool IdDictDictionaryRef::m_propagated_information {}

private

Definition at line 39 of file IdDictDictionaryRef.h.

m_resolved_references

bool IdDictDictionaryRef::m_resolved_references {}

private

Definition at line 37 of file IdDictDictionaryRef.h.

---

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

• IdDictDictionaryRef.h
• IdDictDictionaryRef.cxx