IdDictDictionaryRef Class Reference

#include <IdDictDictionaryRef.h>

Inheritance diagram for IdDictDictionaryRef:

Collaboration diagram for IdDictDictionaryRef:

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

Private Attributes
std::string	m_dictionary_name
IdDictDictionary *	m_dictionary {}
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() [1/2]

IdDictDictionaryRef::IdDictDictionaryRef

(

const std::string &

dictionary_name

)

Definition at line 15 of file IdDictDictionaryRef.cxx.

  :
  m_dictionary_name(dictionary_name),
  m_dictionary(nullptr),
  m_resolved_references(false),
  m_generated_implementation(false),
  m_propagated_information(false) {
}

IdDictDictionaryRef() [2/2]

IdDictDictionaryRef::IdDictDictionaryRef

(

IdDictDictionary *

dictionary

)

Definition at line 24 of file IdDictDictionaryRef.cxx.

  :
  m_dictionary(dictionary),
  m_resolved_references(true),
  m_generated_implementation(false),
  m_propagated_information(false) {
}

~IdDictDictionaryRef()

IdDictDictionaryRef::~IdDictDictionaryRef ( )

virtual

Definition at line 32 of file IdDictDictionaryRef.cxx.

                                           {
}

Member Function Documentation

build_range()

Range IdDictDictionaryRef::build_range ( ) const

overridevirtual

Implements IdDictRegionEntry.

Definition at line 144 of file IdDictDictionaryRef.cxx.

                                             {
  Range result;
 
  return(result);
}

clear()

void IdDictRegionEntry::clear ( )

virtualinherited

Definition at line 29 of file IdDictRegionEntry.cxx.

                              {
}

dictionary_name()

const std::string & IdDictDictionaryRef::dictionary_name ( ) const

inline

Definition at line 68 of file IdDictDictionaryRef.h.

{
    return m_dictionary_name;
}

generate_implementation()

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

overridevirtual

Reimplemented from IdDictRegionEntry.

Definition at line 48 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;
        for (const std::unique_ptr<IdDictRegionEntry>& entry : region.entries()) {
          if (this == entry.get()) 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.get());
          if (range) {
            prepend_entries.insert(prepend_entries.begin(), entry.get());
          }
        }
 
 
 
 
        // Now prepend list to each region and generate each region
        for (IdDictRegion* region2 : m_dictionary->all_regions()) {
          for (IdDictRegionEntry* entry : prepend_entries) {
            IdDictRange* range = dynamic_cast<IdDictRange*> (entry);
            if (range) {
              region2->prepend_entry(std::make_unique<IdDictRangeRef> (*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->all_regions().back();
          size_t region_number = region2.index() + 1;
 
          // Loop over all regions of current dict, add to ref dict (m_dictionary)
          for (IdDictRegion* region3 : dictionary.all_regions()) {
            auto new_region = std::make_unique<IdDictRegion> ("dummy", "dummy", "");
 
            new_region->set_index (region_number++);
 
            // Now add in only the ranges
            size_t i = 0;
            for (const std::unique_ptr<IdDictRegionEntry>& entry : region3->entries()) {
              if (i++ >= prepend_entries.size()) continue;
 
              IdDictRange* range = dynamic_cast<IdDictRange*> (entry.get());
              if (range) {
                new_region->add_entry(std::make_unique<IdDictRangeRef> (*range));
              }
            }
 
            // to all region vectors
            m_dictionary->add_region(new_region.get());
            // to the entries of the dictionary
            m_dictionary->add_dictentry(std::move(new_region));
          }
        }
        m_propagated_information = true;
      }
      m_dictionary->generate_implementation(idd, tag);
      m_generated_implementation = true;
    } else {
      std::cout <<
        "IdDictDictionaryRef::generate_implementation: - WARNING no dictionary named " << m_dictionary_name << " found, cannot generate implementation "
       << std::endl;
    }
  }
}

reset_implementation()

void IdDictDictionaryRef::reset_implementation ( )

overridevirtual

Reimplemented from IdDictRegionEntry.

Definition at line 133 of file IdDictDictionaryRef.cxx.

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

resolve_references()

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

overridevirtual

Reimplemented from IdDictRegionEntry.

Definition at line 35 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->set_parent_dict (&dictionary);
    }
    m_resolved_references = true;
  }
}

verify()

bool IdDictDictionaryRef::verify ( ) const

overridevirtual

Reimplemented from IdDictRegionEntry.

Definition at line 140 of file IdDictDictionaryRef.cxx.

                                       {
  return(true);
}

Member Data Documentation

m_dictionary

IdDictDictionary* IdDictDictionaryRef::m_dictionary {}

private

Definition at line 57 of file IdDictDictionaryRef.h.

{}; 

m_dictionary_name

std::string IdDictDictionaryRef::m_dictionary_name

private

Definition at line 56 of file IdDictDictionaryRef.h.

m_generated_implementation

bool IdDictDictionaryRef::m_generated_implementation {}

private

Definition at line 62 of file IdDictDictionaryRef.h.

{};

m_propagated_information

bool IdDictDictionaryRef::m_propagated_information {}

private

Definition at line 63 of file IdDictDictionaryRef.h.

{};

m_resolved_references

bool IdDictDictionaryRef::m_resolved_references {}

private

Definition at line 61 of file IdDictDictionaryRef.h.

{};

---

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

• IdDictDictionaryRef.h
• IdDictDictionaryRef.cxx