Range::field Class Reference

This is the individual specification for the range of one ExpandedIdentifier field. More...

#include <Range.h>

Collaboration diagram for Range::field:

Public Types
enum	mode {   unbounded, low_bounded, high_bounded, both_bounded,   enumerated }
	Characterizes the four possible modes of any field specification. More...
enum	continuation_mode {   none, has_next, has_previous, has_both,   has_wrap_around }
typedef std::vector< element_type >	element_vector
typedef std::vector< size_type >	index_vector

Public Member Functions
	field ()
	Create a wild-card value. More...
	field (const field &other)
	Create a field copy. More...
	field (field &&other)
	Move constructor. More...
	field (element_type value)
	Create a unique value (understood as : low bound = high bound = value) More...
	field (element_type minimum, element_type maximum)
	Create a full range specification (with explicit min and max) More...
bool	is_valued () const
	Some combined query functions on the specification mode. More...
bool	has_minimum () const
bool	has_maximum () const
bool	wrap_around () const
mode	get_mode () const
	Query the values. More...
element_type	get_minimum () const
element_type	get_maximum () const
const element_vector &	get_values () const
bool	get_previous (element_type current, element_type &previous) const
	Returns false if previous/next is at end of range, or not possible. More...
bool	get_next (element_type current, element_type &next) const
size_type	get_indices () const
index_vector	get_indexes () const
size_type	get_bits () const
element_type	get_value_at (size_type index) const
size_type	get_value_index (element_type value) const
bool	match_any () const
	Check if this is a pure wild card field. More...
bool	match (element_type value) const
	The basic match operation. More...
bool	overlaps_with (const field &other) const
	Check whether two fields overlap. More...
void	clear ()
	Set methods. More...
void	set (element_type minimum, element_type maximum)
void	set_minimum (element_type value)
void	set_maximum (element_type value)
void	add_value (element_type value)
void	set (const element_vector &values)
void	set (bool wraparound)
void	set_next (int next)
void	set_previous (int previous)
field &	operator= (const field &other)
void	operator|= (const field &other)
	operator std::string () const
bool	operator== (const field &other) const
bool	operator!= (const field &other) const
void	show () const
void	optimize ()
	Optimize - try to switch mode to both_bounded, set up lookup table for finding index from value. More...

Private Types
enum	max_values { max_indexes = 100 }

Private Member Functions
void	check_for_both_bounded ()
	Check mode - switch from enumerated to both_bounded if possible. More...
void	create_index_table ()
	Create index table from value table. More...
void	set_indices ()
	Set m_indices. More...

Private Attributes
element_type	m_minimum
element_type	m_maximum
element_vector	m_values
index_vector	m_indexes
size_type	m_indices
element_type	m_previous
element_type	m_next
mode	m_mode
continuation_mode	m_continuation_mode

Detailed Description

This is the individual specification for the range of one ExpandedIdentifier field.

Definition at line 36 of file DetectorDescription/Identifier/Identifier/Range.h.

Member Typedef Documentation

element_vector

typedef std::vector<element_type> Range::field::element_vector

Definition at line 61 of file DetectorDescription/Identifier/Identifier/Range.h.

index_vector

typedef std::vector<size_type> Range::field::index_vector

Definition at line 62 of file DetectorDescription/Identifier/Identifier/Range.h.

Member Enumeration Documentation

continuation_mode

enum Range::field::continuation_mode

Enumerator
none
has_next
has_previous
has_both
has_wrap_around

Definition at line 52 of file DetectorDescription/Identifier/Identifier/Range.h.

    { 
      none, 
      has_next, 
      has_previous, 
      has_both,
      has_wrap_around
    } continuation_mode; 

max_values

enum Range::field::max_values

private

Enumerator
max_indexes

Definition at line 133 of file DetectorDescription/Identifier/Identifier/Range.h.

    { 
      max_indexes = 100
    } max_values; 

mode

enum Range::field::mode

Characterizes the four possible modes of any field specification.

Enumerator
unbounded
low_bounded
high_bounded
both_bounded
enumerated

Definition at line 43 of file DetectorDescription/Identifier/Identifier/Range.h.

    { 
      unbounded, 
      low_bounded, 
      high_bounded, 
      both_bounded, 
      enumerated 
    } mode; 

Constructor & Destructor Documentation

field() [1/5]

Range::field::field

(

)

Create a wild-card value.

Definition at line 317 of file DetectorDescription/Identifier/src/Range.cxx.

    :
    m_minimum(0),
    m_maximum(0),
    m_indices(0),
    m_previous(0),
    m_next(0),
    m_mode(unbounded),
    m_continuation_mode(none)
{ 
} 

field() [2/5]

Range::field::field

(

const field &

other

)

Create a field copy.

Definition at line 330 of file DetectorDescription/Identifier/src/Range.cxx.

  : m_minimum (other.m_minimum),
    m_maximum (other.m_maximum),
    m_values (other.m_values),
    m_indexes (other.m_indexes),
    m_indices (other.m_indices),
    m_previous (other.m_previous),
    m_next (other.m_next),
    m_mode (other.m_mode),
    m_continuation_mode (other.m_continuation_mode)
{ 
} 

field() [3/5]

Range::field::field

(

field &&

other

)

Move constructor.

Definition at line 344 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  m_minimum  = other.m_minimum; 
  m_maximum  = other.m_maximum; 
  m_values.swap (other.m_values);
  m_indexes.swap (other.m_indexes);
  m_indices  = other.m_indices;
  m_previous = other.m_previous;
  m_next     = other.m_next;
  m_mode     = other.m_mode; 
  m_continuation_mode = other.m_continuation_mode;
 
} 

field() [4/5]

Range::field::field

(

element_type

value

)

Create a unique value (understood as : low bound = high bound = value)

Definition at line 359 of file DetectorDescription/Identifier/src/Range.cxx.

    :
    m_minimum(value),
    m_maximum(value),
    m_indices(0),
    m_previous(0),
    m_next(0),
    m_mode(both_bounded),
    m_continuation_mode(none)
{} 

field() [5/5]

Range::field::field	(	element_type	minimum,
		element_type	maximum
	)

Create a full range specification (with explicit min and max)

Definition at line 371 of file DetectorDescription/Identifier/src/Range.cxx.

   :
    m_indices(0),
    m_previous(0),
    m_next(0),
    m_mode(both_bounded),
    m_continuation_mode(none)
{ 
  set (minimum, maximum); 
  set_indices();    
} 

Member Function Documentation

add_value()

void Range::field::add_value

(

element_type

value

)

Definition at line 729 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  if (m_mode == low_bounded) 
    { 
      m_values.clear (); 
      m_values.push_back (m_minimum); 
      m_maximum = m_minimum; 
      m_mode = enumerated; 
    } 
  else if (m_mode != enumerated) 
    { 
      m_values.clear (); 
      m_mode = enumerated; 
    } 
 
  for (size_type i = 0; i < m_values.size (); ++i) 
    { 
      if (m_values[i] == value) return; 
    } 
 
  m_values.push_back (value); 
  std::sort (m_values.begin (), m_values.end()); 
 
  m_minimum = m_values[0]; 
  m_maximum = m_values[m_values.size () - 1]; 
 
  set_indices();
} 

check_for_both_bounded()

void Range::field::check_for_both_bounded ( )

private

Check mode - switch from enumerated to both_bounded if possible.

Definition at line 1119 of file DetectorDescription/Identifier/src/Range.cxx.

{
    if (m_mode == enumerated && !m_values.empty()) {
    element_type last = m_values[0];    
    for (size_type i = 1; i < m_values.size (); ++i) { 
        if (m_values[i] > last + 1) return;
        last = m_values[i];
        }
 
    // Is both bounded - swith mode
    m_minimum = m_values[0];
    m_maximum = m_values[m_values.size() - 1];
 
//      for (size_type i = 0; i < m_values.size (); ++i) { 
//          std::cout << m_values[i] << " ";
//          }
//      std::cout << " min/max " << m_minimum << " " << m_maximum << std::endl;
 
    m_mode = both_bounded; 
    m_values.clear (); 
    }
}

clear()

void Range::field::clear

(

)

Set methods.

Definition at line 653 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  m_minimum  = 0; 
  m_maximum  = 0; 
  m_previous = 0;
  m_next     = 0;
  m_continuation_mode = none;
  m_mode = unbounded; 
  m_values.clear (); 
} 

create_index_table()

void Range::field::create_index_table ( )

private

Create index table from value table.

Create index table from value table

Definition at line 1143 of file DetectorDescription/Identifier/src/Range.cxx.

{
    if (m_mode == enumerated && !m_values.empty()) {
    size_type size = m_maximum - m_minimum + 1;
    // return if we are over the maximum desired vector table size  
    if (size > max_indexes) {
        m_indexes.clear();
        return;
    }
    // Set up vectors for decoding
    m_indexes = std::vector<size_type>(size, 0);
    size_type index = 0;
    for (size_type i = 0; i < m_values.size(); ++i) {
        if ((m_values[i]- m_minimum) < (int)size) {
        m_indexes[m_values[i] - m_minimum] = index;
        index++;
        }
        else {
        std::cout << "size, value, index, i " 
              << size << " " << m_values[i] << " "
              << index << " " << i << "  min, max " 
              << m_minimum << " " 
              << m_maximum 
              << std::endl;
        }
    }
    }
}

get_bits()

ExpandedIdentifier::size_type Range::field::get_bits ( ) const

inline

Definition at line 560 of file DetectorDescription/Identifier/Identifier/Range.h.

{
  ExpandedIdentifier::size_type result = 1;
 
  size_t indices = get_indices ();
 
  indices--;
  if (indices > 0)
    {
      result = 0;
      while (indices > 0)
        {
          indices /= 2;
          result++;
        }
    }
 
  return (result);
}

get_indexes()

Range::field::index_vector Range::field::get_indexes ( ) const

inline

Definition at line 552 of file DetectorDescription/Identifier/Identifier/Range.h.

{
    return (m_indexes);
}

get_indices()

ExpandedIdentifier::size_type Range::field::get_indices ( ) const

inline

Definition at line 545 of file DetectorDescription/Identifier/Identifier/Range.h.

{ 
    return (m_indices);
}

get_maximum()

Range::element_type Range::field::get_maximum ( ) const

inline

Definition at line 531 of file DetectorDescription/Identifier/Identifier/Range.h.

{ 
  return (m_maximum); 
} 

get_minimum()

Range::element_type Range::field::get_minimum ( ) const

inline

Definition at line 524 of file DetectorDescription/Identifier/Identifier/Range.h.

{ 
  return (m_minimum); 
} 

get_mode()

Range::field::mode Range::field::get_mode ( ) const

inline

Query the values.

Definition at line 517 of file DetectorDescription/Identifier/Identifier/Range.h.

{ 
  return (m_mode); 
} 

get_next()

bool Range::field::get_next	(	element_type	current,
		element_type &	next
	)		const

Definition at line 479 of file DetectorDescription/Identifier/src/Range.cxx.

{
  switch (m_mode) 
    { 
    case unbounded: 
      next = current + 1; 
      if (current == std::numeric_limits<element_type>::max()) return (false);
      return (true); 
      break; 
    case low_bounded: 
      next = current + 1; 
      if (current == std::numeric_limits<element_type>::max()) return (false);
      return (true); 
      break; 
    case high_bounded: 
      if (current == m_maximum) {
      next = current;
      return (false);
      }
      next = current + 1; 
      return (true); 
      break; 
    case both_bounded: 
      if (current == m_maximum) {
      if (has_wrap_around == m_continuation_mode) {
          next = m_minimum;
          return (true); 
      }
      if (has_next == m_continuation_mode) {
          next = m_next;
          return (true); 
      }
      next = current;
      return (false);
      }
      next = current + 1; 
      return (true); 
      break; 
    case enumerated: 
      size_type index = get_value_index(current);
      if ((index == m_values.size() - 1) ||
      (index == 0 && current != m_values[0])) {
      if (has_wrap_around == m_continuation_mode) {
          next = m_values[0];
          return (true); 
      }
      if (has_next == m_continuation_mode) {
          next = m_next;
          return (true); 
      }
      next = current;
      return (false);
      }
      ++index;
      next = m_values[index];
      return (true);
      break; 
    } 
 
  return (false); 
}

get_previous()

bool Range::field::get_previous	(	element_type	current,
		element_type &	previous
	)		const

Returns false if previous/next is at end of range, or not possible.

Definition at line 414 of file DetectorDescription/Identifier/src/Range.cxx.

{
  switch (m_mode) 
    { 
    case unbounded: 
      previous = current - 1; 
      if (current == std::numeric_limits<element_type>::min()) return (false);
      return (true); 
      break; 
    case low_bounded: 
      if (current == m_minimum) {
      previous = current;
      return (false);
      }
      previous = current - 1; 
      return (true); 
      break; 
    case high_bounded: 
      previous = current - 1; 
      if (current == std::numeric_limits<element_type>::min()) return (false);
      return (true); 
      break; 
    case both_bounded: 
      if (current == m_minimum) {
      if (has_wrap_around == m_continuation_mode) {
          previous = m_maximum;
          return (true); 
      }
      if (has_previous == m_continuation_mode) {
          previous = m_previous;
          return (true); 
      }
      previous = current;
      return (false);
      }
      previous = current - 1; 
      return (true); 
      break; 
    case enumerated: 
      size_type index = get_value_index(current);
      if (index == 0) {
      if (has_wrap_around == m_continuation_mode && !m_values.empty()) {
          index = m_values.size() - 1;
          previous = m_values[index];
          return (true); 
      }
      if (has_previous == m_continuation_mode) {
          previous = m_previous;
          return (true); 
      }
      previous = current;
      return (false);
      }
      --index;
      previous = m_values[index];
      return (true);
      break; 
    } 
 
  return (false); 
}

get_value_at()

Range::element_type Range::field::get_value_at ( size_type  index ) const

inline

Definition at line 583 of file DetectorDescription/Identifier/Identifier/Range.h.

{ 
    // Only both_bounded and enumerated are valid to calculate the
    // value.
    // both_bounded if the more frequent case and so comes first.
 
    if (both_bounded == m_mode) {
        if (index >= (size_type) (m_maximum - m_minimum + 1)) {
          throw std::out_of_range("Range::field::get_value_at");
        }
    return (m_minimum + index); 
//      if (index >= (size_type) (m_maximum - m_minimum + 1)) return (0); 
//      else return (m_minimum + index); 
    }
    else if (enumerated == m_mode) {
        return (m_values.at(index)); 
//        if (index >= m_values.size ()) return (0); 
//        else return (m_values[index]); 
    }
 
    return (0); 
} 

get_value_index()

ExpandedIdentifier::size_type Range::field::get_value_index ( element_type  value ) const

inline

Definition at line 609 of file DetectorDescription/Identifier/Identifier/Range.h.

{
 
    // Only both_bounded and enumerated are valid to calculate the
    // index.
    // both_bounded if the more frequent case and so comes first.
 
    if (both_bounded == m_mode) {
//      if ((value >= m_minimum) &&
//          (value <= m_maximum)) {
        return (value - m_minimum); 
//      }
    }
    else if (enumerated == m_mode) {
//  if ((int)m_indexes.size() > ((int)value - (int)m_minimum)) {
    if (m_indexes.size()) {
        // Table has been created, do simple lookup
            assert (value >= m_minimum && value - m_minimum < (int)m_indexes.size());
        return (m_indexes.at(value - m_minimum));
    }
    else {
        for (size_type i = 0; i < m_values.size (); ++i) { 
        if (m_values[i] == value) return (i); 
        }
    }
    }
 
    return (0); 
}

get_values()

const Range::field::element_vector & Range::field::get_values ( ) const

inline

Definition at line 538 of file DetectorDescription/Identifier/Identifier/Range.h.

{ 
  return (m_values); 
} 

has_maximum()

bool Range::field::has_maximum

(

)

const

Definition at line 398 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  return ((m_mode == high_bounded) ||  
          (m_mode == both_bounded) ||  
          (m_mode == enumerated)); 
} 

has_minimum()

bool Range::field::has_minimum

(

)

const

Definition at line 390 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  return ((m_mode == low_bounded) ||  
          (m_mode == both_bounded) ||  
          (m_mode == enumerated)); 
} 

is_valued()

bool Range::field::is_valued

(

)

const

Some combined query functions on the specification mode.

Definition at line 384 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  return (m_mode != unbounded);  
} 

match()

bool Range::field::match ( element_type  value ) const

inline

The basic match operation.

Definition at line 641 of file DetectorDescription/Identifier/Identifier/Range.h.

{ 
    size_t i; 
 
    if (both_bounded == m_mode) {
    return ((value >= m_minimum) && 
        (value <= m_maximum)); 
    }
    else if (enumerated == m_mode) {
    for (i = 0; i < m_values.size (); ++i) { 
        if (value == m_values[i]) return (true); 
    } 
    return (false); 
    }
    else if (unbounded == m_mode) {
    return (true); 
    }
    else if (high_bounded == m_mode) {
    return (value <= m_maximum); 
    }
    else if (low_bounded == m_mode) {
    return (value >= m_minimum); 
    }
    return (false);
} 

match_any()

bool Range::field::match_any

(

)

const

Check if this is a pure wild card field.

Definition at line 542 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  if (m_mode == unbounded) return (true); 
   
  return (false); 
} 

operator std::string()

Range::field::operator std::string

(

)

const

Definition at line 959 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  std::string result; 
  char temp[20]; 
 
  if (!is_valued ()) 
    { 
      result += "*"; 
    } 
  else  
    { 
      element_type minimum = get_minimum (); 
      element_type maximum = get_maximum (); 
 
      if (!has_maximum ()) 
        { 
          sprintf (temp, "%d", minimum); 
          result += temp; 
          result += ":"; 
        } 
      else if (!has_minimum ()) 
        { 
          sprintf (temp, "%d", maximum); 
          result += ":"; 
          result += temp; 
        } 
      else if (minimum == maximum) 
        { 
          sprintf (temp, "%d", minimum); 
          result += temp; 
        } 
      else 
        { 
          if (get_mode () == field::enumerated) 
            { 
              for (size_type i = 0; i < get_indices (); ++i) 
                { 
                  if (i > 0) result += ","; 
                  sprintf (temp, "%d", get_value_at (i)); 
                  result += temp; 
                } 
            } 
          else 
            { 
              sprintf (temp, "%d", minimum); 
              result += temp; 
              sprintf (temp, "%d", maximum); 
              result += ":"; 
                  result += temp; 
            } 
        } 
    } 
 
  return (result); 
} 

operator!=()

bool Range::field::operator!=

(

const field &

other

)

const

Definition at line 1028 of file DetectorDescription/Identifier/src/Range.cxx.

{
    return (!((*this) == other));
}

operator=()

Range::field & Range::field::operator=

(

const field &

other

)

Definition at line 809 of file DetectorDescription/Identifier/src/Range.cxx.

{
  if (this != &other) {
    m_minimum  = other.m_minimum; 
    m_maximum  = other.m_maximum; 
    m_values   = other.m_values; 
    m_indexes  = other.m_indexes;
    m_indices  = other.m_indices;
    m_previous = other.m_previous;
    m_next     = other.m_next;
    m_mode     = other.m_mode; 
    m_continuation_mode = other.m_continuation_mode;
  }
 
  return (*this);
}

operator==()

bool Range::field::operator==

(

const field &

other

)

const

Definition at line 1017 of file DetectorDescription/Identifier/src/Range.cxx.

{
    if (m_mode != other.m_mode)     return false;
    if (m_minimum != other.m_minimum)   return false;
    if (m_maximum != other.m_maximum)   return false;
    if (m_values  != other.m_values)    return false;
    return (true);
}

operator|=()

void Range::field::operator|=

(

const field &

other

)

If there is no overlap we should build a multi-segment specification. The current algorithm is only correct if the overlap in not empty !! A multi-segment specification might also be implemented as an expanded enumerated set (not very optimized !!)

If there is no overlap we should build a multi-segment specification. The current algorithm is only correct if the overlap in not empty !!

(in addition, the expanded solution - to enumerated - is not possible due to the unbounded nature of this mode)

If there is no overlap we should build a multi-segment specification. The current algorithm is only correct if the overlap in not empty !!

(in addition, the expanded solution - to enumerated - is not possible due to the unbounded nature of this mode)

Definition at line 827 of file DetectorDescription/Identifier/src/Range.cxx.

{
  mode other_mode = other.get_mode ();
 
  if (m_mode == other_mode)
    {
        /*
          x . . . .
          . x . . .
          . . x . .
          . . . x .
          . . . . x
        */
      switch (m_mode) 
        { 
          case unbounded: 
            break; 
          case high_bounded: 
            if (other.get_maximum () > m_maximum) m_maximum = other.get_maximum ();
            break; 
          case low_bounded: 
            if (other.get_minimum () < m_minimum) m_minimum = other.get_minimum ();
            break; 
          case enumerated:
          {
            const element_vector& ev = other.get_values ();
 
            for (size_t i = 0; i < ev.size (); ++i) 
              { 
                add_value (ev[i]);
              } 
          }
            break; 
          default:  // both_bounded 
            if (other.get_maximum () > m_maximum) m_maximum = other.get_maximum ();
            if (other.get_minimum () < m_minimum) m_minimum = other.get_minimum ();
 
            break; 
        } 
    }
  else if ((m_mode == unbounded) || (other_mode == unbounded))
    {
        /*
          o x x x x
          x o . . .
          x . o . .
          x . . o .
          x . . . o
         */
      clear ();
    }
  else if ((m_mode == low_bounded) && (other_mode == high_bounded))
    {
        /*
          o o o o o
          o o x . .
          o . o . .
          o . . o .
          o . . . o
        */
      clear ();
    }
  else if ((m_mode == high_bounded) && (other_mode == low_bounded))
    {
        /*
          o o o o o
          o o o . .
          o x o . .
          o . . o .
          o . . . o
         */
      clear ();
    }
  else
    {
        // all other cases...
 
      if (has_minimum () && other.has_minimum ())
        {
            /*
              o o o o o
              o o o x x
              o o o . .
              o x . o x
              o x . x o
            */
 
          if (other.get_minimum () < m_minimum) set_minimum (other.get_minimum ());
        }
 
      if (has_maximum () && other.has_maximum ())
        {
            /*
              o o o o o
              o o o . .
              o o o x x
              o . x o x
              o . x x o
            */
 
          if (other.get_maximum () > m_maximum) set_maximum (other.get_maximum ());
        }
    }
 
  set_indices();
}

optimize()

void Range::field::optimize

(

)

Optimize - try to switch mode to both_bounded, set up lookup table for finding index from value.

Check mode - switch from enumerated to both_bounded if possible

Create index table from value table

Definition at line 1094 of file DetectorDescription/Identifier/src/Range.cxx.

{
 
    check_for_both_bounded();
 
    create_index_table();
 
}

overlaps_with()

bool Range::field::overlaps_with

(

const field &

other

)

const

Check whether two fields overlap.

Definition at line 551 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  typedef enum  
    { 
      done,  
      min_max,  
      max_min,  
      both, 
      both_and_enum, 
      enum_and_both, 
      all_values 
    } check_type; 
 
  static const check_type check_needed[5][5] = 
  { 
    {done, done,    done,    done,          done}, 
    {done, done,    min_max, min_max,       min_max}, 
    {done, max_min, done,    max_min,       max_min}, 
    {done, max_min, min_max, both,          both_and_enum}, 
    {done, max_min, min_max, enum_and_both, all_values} 
  }; 
 
  mode other_mode = other.get_mode (); 
 
  switch (check_needed [m_mode][other_mode]) 
    { 
    case done: 
      return (true); 
    case min_max: 
      if (m_minimum <= other.get_maximum ()) return (true); 
      break; 
    case max_min: 
      if (m_maximum >= other.get_minimum ()) return (true); 
      break; 
    case both: 
      if ((m_minimum <= other.get_maximum ()) && 
          (m_maximum >= other.get_minimum ()))  
        { 
          return (true); 
        } 
      break; 
    case both_and_enum: // this is both_bounded while other is enumerated 
      if ((m_minimum <= other.get_maximum ()) && 
          (m_maximum >= other.get_minimum ()))  
        { 
          // Check if this(bb) is entirely within other(enum). 
          if ((m_minimum > other.get_minimum ()) && 
              (m_maximum < other.get_maximum ())) 
            { 
              const element_vector& ev = other.get_values (); 
              for (size_t i = 0; i < ev.size (); ++i) 
                { 
                  element_type v = ev[i]; 
                  if ((v < m_minimum) || (v > m_maximum)) return (false); 
                } 
            } 
 
          return (true); 
        } 
      break; 
    case enum_and_both: // this is enumerated while other is both_bounded 
      if ((m_minimum <= other.get_maximum ()) && 
          (m_maximum >= other.get_minimum ()))  
        { 
          // Check if other(bb) is entirely within this(enum). 
          if ((other.get_minimum () > m_minimum) && 
              (other.get_maximum () < m_maximum)) 
            { 
              const element_vector& ev = get_values (); 
              for (size_t i = 0; i < ev.size (); ++i) 
                { 
                  element_type v = ev[i]; 
                  if ((v < other.get_minimum ()) || (v > other.get_maximum ())) return (false); 
                } 
            } 
 
          return (true); 
        } 
      break; 
    case all_values: 
      // Both fields are enumerated only if there is possibility of overlap 
      if ((m_minimum <= other.get_maximum ()) && 
          (m_maximum >= other.get_minimum ()))  
        { 
          const element_vector& ev = other.get_values (); 
          for (size_t i = 0; i < m_values.size (); ++i) 
            { 
              element_type v = m_values[i]; 
              for (size_t j = 0; j < ev.size (); ++j) 
                { 
                  if (v == ev[j]) return (true); 
                } 
            } 
        } 
      break; 
    } 
 
  return (false); 
} 

set() [1/3]

void Range::field::set

(

bool

wraparound

)

Definition at line 776 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
    if (wraparound) {
    m_continuation_mode = has_wrap_around;
    }
} 

set() [2/3]

void Range::field::set

(

const element_vector &

values

)

set() [3/3]

void Range::field::set	(	element_type	minimum,
		element_type	maximum
	)

Definition at line 665 of file DetectorDescription/Identifier/src/Range.cxx.

{
  m_values.clear ();
 
  if (minimum == maximum)
    {
      add_value (minimum);
    }
  else
    {
      m_minimum = (minimum <= maximum) ? minimum : maximum; 
      m_maximum = (maximum >= minimum) ? maximum : minimum; 
 
      m_mode = both_bounded; 
    }
 
  set_indices();
} 

set_indices()

void Range::field::set_indices ( )

private

Set m_indices.

Set the number of indices

Definition at line 1106 of file DetectorDescription/Identifier/src/Range.cxx.

{
    m_indices = 1;
    if (m_mode == both_bounded) { 
    m_indices = m_maximum - m_minimum + 1; 
    } 
    else if (m_mode == enumerated) { 
    m_indices = m_values.size (); 
    } 
} 

set_maximum()

void Range::field::set_maximum

(

element_type

value

)

Definition at line 707 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  if (m_mode == unbounded)  
    { 
      m_mode = high_bounded; 
      m_maximum = value; 
    } 
  else if ((m_mode == low_bounded) ||  
           (m_mode == both_bounded) || 
           (m_mode == enumerated)) 
    { 
      set (get_minimum (), value); 
    } 
  else 
    { 
      m_maximum = value; 
    } 
 
  set_indices();
} 

set_minimum()

void Range::field::set_minimum

(

element_type

value

)

Definition at line 685 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  if (m_mode == unbounded)  
    { 
      m_mode = low_bounded; 
      m_minimum = value; 
    } 
  else if ((m_mode == high_bounded) ||  
           (m_mode == both_bounded) ||  
           (m_mode == enumerated)) 
    { 
      set (value, get_maximum ()); 
    } 
  else 
    { 
      m_minimum = value; 
    } 
 
  set_indices();
} 

set_next()

void Range::field::set_next

(

int

next

)

Definition at line 784 of file DetectorDescription/Identifier/src/Range.cxx.

{
    if (has_previous == m_continuation_mode) {
    m_continuation_mode = has_both;
    }
    else {
    m_continuation_mode = has_next;
    }
    m_next = next;
}

set_previous()

void Range::field::set_previous

(

int

previous

)

Definition at line 797 of file DetectorDescription/Identifier/src/Range.cxx.

{
    if (has_next == m_continuation_mode) {
    m_continuation_mode = has_both;
    }
    else {
    m_continuation_mode = has_previous;
    }
    m_previous = previous;
}

show()

void Range::field::show

(

)

const

Definition at line 1035 of file DetectorDescription/Identifier/src/Range.cxx.

{
    
  std::cout << "min/max " << m_minimum << " " << m_maximum << " "; 
  std::cout << "values  ";
  for (size_type i = 0; i < m_values.size(); ++i) {
      std::cout << m_values[i] << " ";
  }
  std::cout << "indexes  ";
  for (size_type i = 0; i < m_indexes.size(); ++i) {
      std::cout << m_indexes[i] << " ";
  }
  std::cout << "indices  " << m_indices << " ";
  std::cout << "prev  " << m_previous << " ";
  std::cout << "next  " << m_next << " ";
 
  std::cout << "mode  ";
  switch (m_mode) { 
  case Range::field::unbounded: 
      std::cout << "unbounded  ";
      break; 
  case Range::field::low_bounded: 
      std::cout << "low_bounded  ";
      break; 
  case Range::field::high_bounded: 
      std::cout << "high_bounded  ";
      break; 
  case Range::field::both_bounded: 
      std::cout << "both_bounded  ";
      break; 
  case Range::field::enumerated: 
      std::cout << "enumerated  ";
      break; 
  } 
 
  std::cout << "cont mode  ";
  switch (m_continuation_mode) { 
  case Range::field::none: 
      std::cout << "none  ";
      break; 
  case Range::field::has_next: 
      std::cout << "has_next  ";
      break; 
  case Range::field::has_previous: 
      std::cout << "has_previous  ";
      break; 
  case Range::field::has_both:
      std::cout << "has_both  ";
      break; 
  case Range::field::has_wrap_around:
      std::cout << "has_wrap_around  ";
      break; 
  }
  std::cout << std::endl;
}

wrap_around()

bool Range::field::wrap_around

(

)

const

Definition at line 406 of file DetectorDescription/Identifier/src/Range.cxx.

{ 
  return (has_wrap_around == m_continuation_mode);
} 

Member Data Documentation

m_continuation_mode

continuation_mode Range::field::m_continuation_mode

private

Definition at line 155 of file DetectorDescription/Identifier/Identifier/Range.h.

m_indexes

index_vector Range::field::m_indexes

private

Definition at line 150 of file DetectorDescription/Identifier/Identifier/Range.h.

m_indices

size_type Range::field::m_indices

private

Definition at line 151 of file DetectorDescription/Identifier/Identifier/Range.h.

m_maximum

element_type Range::field::m_maximum

private

Definition at line 148 of file DetectorDescription/Identifier/Identifier/Range.h.

m_minimum

element_type Range::field::m_minimum

private

Definition at line 147 of file DetectorDescription/Identifier/Identifier/Range.h.

m_mode

mode Range::field::m_mode

private

Definition at line 154 of file DetectorDescription/Identifier/Identifier/Range.h.

m_next

element_type Range::field::m_next

private

Definition at line 153 of file DetectorDescription/Identifier/Identifier/Range.h.

m_previous

element_type Range::field::m_previous

private

Definition at line 152 of file DetectorDescription/Identifier/Identifier/Range.h.

m_values

element_vector Range::field::m_values

private

Definition at line 149 of file DetectorDescription/Identifier/Identifier/Range.h.

---

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

• DetectorDescription/Identifier/Identifier/Range.h
• DetectorDescription/Identifier/src/Range.cxx