IdDictRange Class Reference

#include <IdDictRange.h>

Inheritance diagram for IdDictRange:

Collaboration diagram for IdDictRange:

Public Types
enum	specification_type {   unknown, by_value, by_values, by_label,   by_labels, by_minmax }
enum	continuation_mode {   none, has_next, has_previous, has_both,   wrap_around }

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

Public Attributes
std::string	m_field_name
IdDictField *	m_field {}
specification_type	m_specification {unknown}
std::string	m_tag
std::string	m_label
int	m_value {}
int	m_minvalue {}
int	m_maxvalue {}
int	m_prev_value {}
int	m_next_value {}
continuation_mode	m_continuation_mode {none}
std::vector< std::string >	m_labels
std::vector< int >	m_values

Private Attributes
bool	m_resolved_references {}

Detailed Description

Definition at line 18 of file IdDictRange.h.

Member Enumeration Documentation

continuation_mode

enum IdDictRange::continuation_mode

Enumerator
none
has_next
has_previous
has_both
wrap_around

Definition at line 43 of file IdDictRange.h.

                          { 
        none, 
        has_next, 
        has_previous, 
        has_both,
        wrap_around
    }; 

specification_type

enum IdDictRange::specification_type

Enumerator
unknown
by_value
by_values
by_label
by_labels
by_minmax

Definition at line 34 of file IdDictRange.h.

                           { 
        unknown, 
        by_value, 
        by_values, 
        by_label, 
        by_labels,
        by_minmax 
    } ; 

Constructor & Destructor Documentation

IdDictRange()

IdDictRange::IdDictRange ( )

default

~IdDictRange()

IdDictRange::~IdDictRange ( )

default

Member Function Documentation

build_range()

Range IdDictRange::build_range ( ) const

virtual

Implements IdDictRegionEntry.

Definition at line 124 of file IdDictRange.cxx.

                               {
  Range result;
 
  Range::field field;
  switch (m_specification) {
  case by_value:
  case by_label: {
    field.set(m_value, m_value);
    break;
  }
 
  case by_values:
  case by_labels: {
    field.set(m_values);
    break;
  }
 
  case by_minmax: {
    field.set(m_minvalue, m_maxvalue);
    break;
  }
 
  case unknown: {
    break;
  }
  }
  if (wrap_around == m_continuation_mode) {
    field.set(true);
  } else if (has_previous == m_continuation_mode) {
    field.set_previous(m_prev_value);
  } else if (has_next == m_continuation_mode) {
    field.set_next(m_next_value);
  } else if (has_both == m_continuation_mode) {
    field.set_previous(m_prev_value);
    field.set_next(m_next_value);
  }
  result.add(std::move(field));
  return(result);
}

clear()

void IdDictRegionEntry::clear ( )

virtualinherited

Definition at line 29 of file IdDictRegionEntry.cxx.

                              {
}

generate_implementation()

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

virtual

Reimplemented from IdDictRegionEntry.

Definition at line 63 of file IdDictRange.cxx.

                                                                                                             {
  // Add IdDictFieldImplementation to this region
 
  // NOTE: we DO NOT protect this method with
  // m_generated_implementation because the same object may be
  // called more than once because there are IdDictRangeRef's which
  // point to the same IdDictRange's.
 
  if (Debugger::debug()) {
    std::cout << "IdDictRange::generate_implementation>" << std::endl;
  }
 
  region.m_implementation.resize(region.m_implementation.size() + 1);
  IdDictFieldImplementation& impl = region.m_implementation.back();
  impl.set_range(this);
  if (m_field->m_index == 0) {
    m_field->m_index = region.fieldSize() - 1;
  } else if (m_field->m_index != (region.fieldSize() - 1)) {
    std::cout << "Bad field index for " << m_field_name
              << " index " << m_field->m_index
              << " in dictionary " << dictionary.m_name
              << " region #" << region.m_index
              << " group " << region.m_group
              << " tag " << region.m_tag
              << " size " << (region.m_implementation.size() - 1)
              << std::endl;
  }
 
  size_t index = region.m_implementation.size() - 1;
  if (region.m_implementation.size() <= index) {
    std::cout << "IdDictRange::generate_implementation: index >= impl size - "
              << index << " " << region.fieldSize()
              << std::endl;
    return;
  }
 
  Range::field field;
  switch (m_specification) {
  case by_value:
  case by_label: {
    impl.set_field(Range::field(m_value, m_value));
    break;
  }
 
  case by_values:
  case by_labels: {
    impl.set_field(Range::field(m_values));
  }
  break;
 
  case by_minmax:
    impl.set_field(Range::field(m_minvalue, m_maxvalue));
    break;
 
  case unknown:
    break;
  }
}

reset_implementation()

void IdDictRegionEntry::reset_implementation ( )

virtualinherited

Reimplemented in IdDictRangeRef, IdDictReference, and IdDictDictionaryRef.

Definition at line 22 of file IdDictRegionEntry.cxx.

                                             {
}

resolve_references()

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

virtual

The range values were unspecified in the range element.

Therefore, the set of values must be obtained from the field definition (if it exists!!).

If the field is undefined, then too bad, this range will be dummy.

Reimplemented from IdDictRegionEntry.

Definition at line 16 of file IdDictRange.cxx.

                                                                               {
  if (!m_resolved_references) {
    m_field = dictionary.find_field(m_field_name);
    if (m_field == nullptr) {
      m_field = new IdDictField;
      m_field->m_name = m_field_name;
      dictionary.add_field(m_field);
    }
 
    if (m_specification == unknown) {
      unsigned int labels = m_field->get_label_number();
      if (labels == 1) {
        m_specification = by_label;
        m_label = m_field->get_label(0);
      } else if (labels > 1) {
        m_specification = by_labels;
        for (size_t i = 0; i < labels; ++i) {
          m_labels.push_back(m_field->get_label(i));
        }
      }
    }
 
    if (m_specification == by_label) {
      m_value = m_field->get_label_value(m_label);
    } else if (m_specification == by_labels) {
      m_values.clear();
      for (size_t i = 0; i < m_labels.size(); ++i) {
        const std::string& label = m_labels[i];
        int value = m_field->get_label_value(label);
        m_values.push_back(value);
      }
    }
    m_resolved_references = true;
  }
}

verify()

bool IdDictRegionEntry::verify ( ) const

virtualinherited

Reimplemented in IdDictRangeRef, IdDictReference, and IdDictDictionaryRef.

Definition at line 25 of file IdDictRegionEntry.cxx.

                                     {
  return(true);
}

Member Data Documentation

m_continuation_mode

continuation_mode IdDictRange::m_continuation_mode {none}

Definition at line 58 of file IdDictRange.h.

m_field

IdDictField* IdDictRange::m_field {}

Definition at line 32 of file IdDictRange.h.

m_field_name

std::string IdDictRange::m_field_name

Definition at line 31 of file IdDictRange.h.

m_label

std::string IdDictRange::m_label

Definition at line 52 of file IdDictRange.h.

m_labels

std::vector<std::string> IdDictRange::m_labels

Definition at line 59 of file IdDictRange.h.

m_maxvalue

int IdDictRange::m_maxvalue {}

Definition at line 55 of file IdDictRange.h.

m_minvalue

int IdDictRange::m_minvalue {}

Definition at line 54 of file IdDictRange.h.

m_next_value

int IdDictRange::m_next_value {}

Definition at line 57 of file IdDictRange.h.

m_prev_value

int IdDictRange::m_prev_value {}

Definition at line 56 of file IdDictRange.h.

m_resolved_references

bool IdDictRange::m_resolved_references {}

private

Definition at line 63 of file IdDictRange.h.

m_specification

specification_type IdDictRange::m_specification {unknown}

Definition at line 50 of file IdDictRange.h.

m_tag

std::string IdDictRange::m_tag

Definition at line 51 of file IdDictRange.h.

m_value

int IdDictRange::m_value {}

Definition at line 53 of file IdDictRange.h.

m_values

std::vector<int> IdDictRange::m_values

Definition at line 60 of file IdDictRange.h.

---

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

• IdDictRange.h
• IdDictRange.cxx