IdDictDictionaryRef Class Reference

#include <IdDictDefs.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 656 of file IdDictDefs.h.

Constructor & Destructor Documentation

IdDictDictionaryRef()

IdDictDictionaryRef::IdDictDictionaryRef

(

)

Definition at line 3289 of file IdDictMgr.cxx.

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

~IdDictDictionaryRef()

IdDictDictionaryRef::~IdDictDictionaryRef

(

)

Definition at line 3298 of file IdDictMgr.cxx.

{ 
} 

Member Function Documentation

build_range()

Range IdDictDictionaryRef::build_range ( ) const

virtual

Implements IdDictRegionEntry.

Definition at line 3436 of file IdDictMgr.cxx.

{ 
  Range result; 
 
//  std::cout << "IdDictDictionaryRef::build_range> []" << std::endl; 
 
  return (result); 
} 

clear()

void IdDictRegionEntry::clear ( )

virtualinherited

Definition at line 2913 of file IdDictMgr.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 3316 of file IdDictMgr.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); 
            }
        }
        
 
 
//          std::cout << "nreg " << m_dictionary->m_all_regions.size() << " "
//                << m_dictionary->m_regions.size() << " " 
//                << m_dictionary->m_entries.size() << " " << std::endl;
        
 
        // 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 3423 of file IdDictMgr.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 3302 of file IdDictMgr.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 3431 of file IdDictMgr.cxx.

{ 
  return (true); 
} 

Member Data Documentation

m_dictionary

IdDictDictionary* IdDictDictionaryRef::m_dictionary

Definition at line 675 of file IdDictDefs.h.

m_dictionary_name

std::string IdDictDictionaryRef::m_dictionary_name

Definition at line 674 of file IdDictDefs.h.

m_generated_implementation

bool IdDictDictionaryRef::m_generated_implementation

private

Definition at line 681 of file IdDictDefs.h.

m_propagated_information

bool IdDictDictionaryRef::m_propagated_information

private

Definition at line 682 of file IdDictDefs.h.

m_resolved_references

bool IdDictDictionaryRef::m_resolved_references

private

Definition at line 680 of file IdDictDefs.h.

---

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

• IdDictDefs.h
• IdDictMgr.cxx