Range Class Reference

A Range describes the possible ranges for the field values of an ExpandedIdentifier. More...

#include <Range.h>

Collaboration diagram for Range:

Classes
class	const_identifier_factory
class	field
	This is the individual specification for the range of one ExpandedIdentifier field. More...
class	identifier_factory
	This factory is able to generate all possible identifiers, from a fully bounded Range. More...

Public Types
typedef ExpandedIdentifier::element_type	element_type
typedef ExpandedIdentifier::size_type	size_type
typedef std::vector< field >	field_vector

Public Member Functions
	Range ()
	Constructors. More...
	Range (const Range &other)
	Range (Range &&other)
Range &	operator= (const Range &other)
	Assignment. More...
Range &	operator= (Range &&other)
	Range (const Range &other, size_type start)
	This is a sub-range copy constructor. More...
	Range (const ExpandedIdentifier &root)
	Constructor with setup from a textual description. More...
void	build (const std::string &text)
	Build a range from a textual description. More...
void	build (const ExpandedIdentifier &root)
	Build a range from a single ExpandedIdentifier (see similar constructor for comment) More...
void	clear ()
	Modifications. More...
void	add ()
	Add a wild card field. More...
void	add (element_type value)
	Add a required value. (ie. low = high = value) More...
void	add (element_type minimum, element_type maximum)
	Add a bounded value. More...
void	add_minimum (element_type minimum)
	Add a range bounded by a minimum. More...
void	add_maximum (element_type maximum)
	Add a range bounded by a maximum. More...
void	add (const field &f)
	Add a range specified using a field More...
void	add (field &&f)
	Add a range specified using a field, with move semantics. More...
void	add (const Range &subrange)
	Append a subrange. More...
void	add (Range &&subrange)
	Append a subrange, with move semantics. More...
int	match (const ExpandedIdentifier &id) const
	Match an identifier. More...
const field &	operator[] (size_type index) const
	Accessors. More...
size_type	fields () const
bool	is_empty () const
ExpandedIdentifier	minimum () const
	min and max ExpandedIdentifiers (if they exist, ie. More...
ExpandedIdentifier	maximum () const
size_type	cardinality () const
	Computes a possible cardinality : More...
size_type	cardinalityUpTo (const ExpandedIdentifier &id) const
	Get the cardinality from the beginning up to the given ExpandedIdentifier. More...
size_type	cardinalityUpTo (const int *id) const
	Get the cardinality from the beginning up to the given Identifier expanded into a int array. More...
identifier_factory	factory_begin ()
	Identifier_factory management. More...
const_identifier_factory	factory_begin () const
identifier_factory	factory_end ()
const_identifier_factory	factory_end () const
bool	overlaps_with (const Range &other) const
	Check if two Ranges overlap. More...
void	show () const
void	show (std::ostream &s) const
	operator std::string () const
	Produce a textual representation of the range using the input format. More...
bool	operator== (const Range &other) const
bool	operator!= (const Range &other) const

Private Attributes
field_vector	m_fields

Detailed Description

A Range describes the possible ranges for the field values of an ExpandedIdentifier.

Specifications can be : No bound * Low bound n: High bound :m Both bounds n:m Enumeration v1, v2, v3, ... , vn

Trailing * are implicit for all trailing fields

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

Member Typedef Documentation

element_type

typedef ExpandedIdentifier::element_type Range::element_type

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

field_vector

typedef std::vector<field> Range::field_vector

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

size_type

typedef ExpandedIdentifier::size_type Range::size_type

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

Constructor & Destructor Documentation

Range() [1/5]

Range::Range

(

)

Constructors.

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

{ 
} 

Range() [2/5]

Range::Range

(

const Range &

other

)

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

  : m_fields (other.m_fields)
{ 
} 

Range() [3/5]

Range::Range

(

Range &&

other

)

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

  : m_fields (std::move (other.m_fields))
{ 
} 

Range() [4/5]

Range::Range	(	const Range &	other,
		size_type	start
	)

This is a sub-range copy constructor.

It copies the portion of the other Range, starting from the
specified starting index up to its last field.

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

{ 
  if (start < other.fields ()) 
    { 
      field_vector::const_iterator it = other.m_fields.begin (); 
      it += start; 
 
      m_fields.insert (m_fields.end (), it, other.m_fields.end ()); 
    } 
} 

Range() [5/5]

Range::Range

(

const ExpandedIdentifier &

root

)

Constructor with setup from a textual description.

The syntax is :

range : <value-range> [ "/" <value-range> ... ]

value-range : "*" | <value> | ":" <max> | <min> ":" | <min> ":" <max> | <value> "," <value> "," ... "," <value> Construct from a simple ExpandedIdentifier. This implies that all fields will have their min=max=id[i]

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

{ 
  // Construct from a root (i.e. add wild card for below) 
  build (root); 
} 

Member Function Documentation

add() [1/7]

void Range::add

(

)

Add a wild card field.

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

{ 
  m_fields.push_back (field ()); 
} 

add() [2/7]

void Range::add

(

const field &

f

)

Add a range specified using a field

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

{
  m_fields.emplace_back (f); 
} 

add() [3/7]

void Range::add

(

const Range &

subrange

)

Append a subrange.

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

{ 
  for (size_t i = 0; i < subrange.fields (); ++i) 
    { 
      const field& f = subrange[i]; 
      m_fields.push_back (f); 
    } 
} 

add() [4/7]

void Range::add	(	element_type	minimum,
		element_type	maximum
	)

Add a bounded value.

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

{ 
  m_fields.push_back (field (minimum, maximum)); 
} 

add() [5/7]

void Range::add

(

element_type

value

)

Add a required value. (ie. low = high = value)

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

{ 
  m_fields.push_back (field (value)); 
} 

add() [6/7]

void Range::add

(

field &&

f

)

Add a range specified using a field, with move semantics.

Add a range specified using a field, using move semantics.

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

{
  m_fields.emplace_back (std::move(f));
} 

add() [7/7]

void Range::add

(

Range &&

subrange

)

Append a subrange, with move semantics.

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

{
  if (m_fields.empty())
    m_fields.swap (subrange.m_fields);
  else {
    size_t sz = subrange.m_fields.size();
    m_fields.reserve (m_fields.size() + sz);
    for (size_t i = 0; i < sz; ++i) 
    { 
      m_fields.emplace_back (std::move(subrange.m_fields[i]));
    }
  }
} 

add_maximum()

void Range::add_maximum

(

element_type

maximum

)

Add a range bounded by a maximum.

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

{ 
  field f; 
 
  f.set_maximum (maximum); 
  m_fields.push_back (f); 
} 

add_minimum()

void Range::add_minimum

(

element_type

minimum

)

Add a range bounded by a minimum.

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

{ 
  field f; 
   
  f.set_minimum (minimum); 
  m_fields.push_back (f); 
} 

build() [1/2]

void Range::build

(

const ExpandedIdentifier &

root

)

Build a range from a single ExpandedIdentifier (see similar constructor for comment)

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

{ 
    // Construct from a root  
  m_fields.clear (); 
 
  for (size_type i = 0; i < root.fields (); ++i) 
    { 
      m_fields.push_back (field (root[i])); 
    } 
} 

build() [2/2]

void Range::build

(

const std::string &

text

)

Build a range from a textual description.

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

{ 
  RangeParser parser; 
 
  parser.run (*this, text); 
} 

cardinality()

Range::size_type Range::cardinality

(

)

const

Computes a possible cardinality :

• all bounded fields are counted as they are
• unbounded fields are conted for one value.

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

{ 
  size_type result = 1; 
 
  const Range& me = *this; 
 
  for (size_type i = 0; i < fields (); ++i) 
    { 
      const field& f = me[i]; 
 
      result *= f.get_indices (); 
    } 
 
  return (result); 
} 

cardinalityUpTo() [1/2]

Range::size_type Range::cardinalityUpTo

(

const ExpandedIdentifier &

id

)

const

Get the cardinality from the beginning up to the given ExpandedIdentifier.

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

{ 
  size_type result = 0; 
 
//    std::cout << " Range::cardinality: id, fields " << (std::string) id 
//          << " " << id.fields() << " " << fields() << " "
//          << (std::string)(*this)  << std::endl;
 
  if (id.fields() != fields()) return (result);
 
  const Range& me = *this; 
 
  // Check if we are above or below this range
  if (id < minimum()) return 0;
  if (maximum() < id) return cardinality();
  
  // Collect the indices of a match
  std::vector<size_type> indices(id.fields (), 0);
  bool is_match = true;
  size_type level = 0;
  for (; level < id.fields (); ++level) {
 
      const field& f = me[level]; 
 
      // Require all fields to be bounded or enumerated
      if (!(f.get_mode() == Range::field::both_bounded ||
        f.get_mode() == Range::field::enumerated)) return 0;
      
      //int index = 0;  // Contains number of nodes below match
 
      if (f.get_mode() == Range::field::enumerated) {
      // Continue testing for a match
      size_type max = f.get_values().size() - 1;
      if (f.get_values()[max] < id[level]) {
          // above max
          is_match = false;
          indices[level] = max + 1;
      }
      else {
          for (size_type j = 0; j < f.get_values().size(); ++j) {
          if (id[level] <= f.get_values()[j]) {
              if (id[level] != f.get_values()[j]) {
              // between two values or below first one
              is_match = false;
              }
              indices[level] = j;
              break;
          }
          }
      }
      }
      else {
      if (f.get_maximum() < id[level]) {
          // above max
          is_match = false;
          indices[level] = f.get_maximum() - f.get_minimum() + 1;
      }
      else if (id[level] < f.get_minimum()) {
          // below min
          is_match = false;
          indices[level] = 0;
      }
      else {
          indices[level] = id[level] - f.get_minimum();
      }
      }
 
//        std::cout << " level, id, field, indices[[level], is enum, is_match " << level << " " 
//          << id[level] << " " << (std::string)f << " " 
//          << indices[level] << " " << (f.get_mode() == Range::field::enumerated) << " " 
//          << is_match << std::endl;
 
 
      if (!is_match) break;
  }
  
  // Calculate the cardinality
  if (level < id.fields ()) ++level;
  for (size_type j = 0; j < level; ++j) {
      size_type card = indices[j];
      for (size_type k = j + 1; k < id.fields(); ++k) {
 
      const field& f = me[k]; 
 
      card *= f.get_indices();
      }
      result += card;
 
//        std::cout << " j, indices, card " << j << " " 
//          << indices[j] << " " << card << std::endl;
  }
  
      
  return result;
  
} 

cardinalityUpTo() [2/2]

Range::size_type Range::cardinalityUpTo ( const int *  id ) const

inline

Get the cardinality from the beginning up to the given Identifier expanded into a int array.

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

{ 
  size_type result = 0; 
 
  const Range& me = *this; 
  size_type level = 0;
  for (; level < fields (); ++level) {
 
      const field& f = me[level]; 
 
      size_type card = f.get_value_index (id[level]);
      
      for (size_type k = level + 1; k < fields(); ++k) {
 
      const field& f = me[k]; 
 
      card *= f.get_indices();
      }
      result += card;
  }
  return result;
} 

clear()

void Range::clear

(

)

Modifications.

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

{ 
  m_fields.clear (); 
} 

factory_begin() [1/2]

Range::identifier_factory Range::factory_begin

(

)

Identifier_factory management.

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

{ 
  const Range& me = *this; 
 
  return (identifier_factory (me)); 
} 

factory_begin() [2/2]

Range::const_identifier_factory Range::factory_begin

(

)

const

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

{ 
  const Range& me = *this; 
 
  return (const_identifier_factory (me)); 
} 

factory_end() [1/2]

Range::identifier_factory Range::factory_end

(

)

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

{ 
  static const Range r; 
  static const identifier_factory factory (r); 
 
  return (factory); 
} 

factory_end() [2/2]

Range::const_identifier_factory Range::factory_end

(

)

const

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

{ 
  static const const_identifier_factory factory; 
 
  return (factory); 
} 

fields()

Range::size_type Range::fields ( ) const

inline

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

{ 
  return (m_fields.size ()); 
} 

is_empty()

bool Range::is_empty ( ) const

inline

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

{ 
  if (m_fields.size () == 0) return (true); 
  return (false); 
} 

match()

int Range::match

(

const ExpandedIdentifier &

id

)

const

Match an identifier.

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

{ 
  size_type my_fields = m_fields.size (); 
  const size_type id_fields = id.fields (); 
 
    // Remove trailing wild cards since they are meaningless. 
  while ((my_fields > 1) && 
         (!m_fields[my_fields-1].is_valued ())) 
    { 
      my_fields--; 
    } 
 
    // Ranges with only wild cards always match. 
  if (my_fields == 0) return (1); 
 
    // More fields in the range than in the identifier will never match. 
  //if (my_fields > id_fields) return (0); 
 
  // Allow match for id shorter than range - assume "wildcards" for
  // missing id fields
  size_type nfields =  (my_fields > id_fields) ? id_fields : my_fields;
 
    // Test fields one by one. 
  //for (size_type field_number = 0; field_number < my_fields; field_number++) 
  for (size_type field_number = 0; field_number < nfields; field_number++) 
    { 
      const field& f = m_fields[field_number]; 
 
      if (!f.match (id[field_number])) return (0); 
    } 
 
    // All conditions match. 
  return (1); 
} 

maximum()

ExpandedIdentifier Range::maximum

(

)

const

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

{ 
  size_type my_fields = m_fields.size (); 
  ExpandedIdentifier result; 
   
    // Remove all by the last trailing wild card, extra ones are 
    // meaningless. 
  while ((my_fields > 1) && 
         (!m_fields[my_fields-1].has_maximum ())) 
    { 
      my_fields--; 
    } 
 
    // Ranges with only wild cards: set first field of min to ExpandedIdentifier::max_value 
  if (my_fields == 0) {
    result << ExpandedIdentifier::max_value;
    return result; // Don't combine these two lines --- it inhibits RVO.
  }
 
    // Copy fields to result - look for wild cards 
  for (size_type field_number = 0; field_number < my_fields; field_number++)  
    { 
      const field& f = m_fields[field_number]; 
 
      if (!f.has_maximum ())  
        { 
            // Wilds card  
          if (field_number == 0) 
            { 
                // For 1st field set it to ExpandedIdentifier::max_value 
              result << ExpandedIdentifier::max_value; 
            } 
          else 
            { 
                // 
                // For subsequent fields, set do ++ for field-1 
                // This requires rebuilding the result 
                // 
              ExpandedIdentifier new_result; 
 
              for (size_type new_field_number = 0;  
                   new_field_number < (field_number - 1); 
                   ++new_field_number) 
                { 
                  new_result << result[new_field_number]; 
                } 
 
              element_type last = result[field_number - 1]; 
 
              new_result << ((ExpandedIdentifier::max_value == last) ? last : last + 1); 
              new_result << 0; 
 
              assert ( result.fields () == new_result.fields () ); 
 
              result = new_result; 
            } 
        } 
      else 
        { 
            // Normal field 
          result << f.get_maximum (); 
        } 
    } 
   
    return (result); 
} 

minimum()

ExpandedIdentifier Range::minimum

(

)

const

min and max ExpandedIdentifiers
(if they exist, ie.

for fully bounded Ranges) Question : what if the Range has wild cards ??

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

{ 
  size_type my_fields = m_fields.size (); 
  ExpandedIdentifier result; 
   
    // Remove trailing wild cards since they are meaningless. 
  while ((my_fields > 1) && 
         (!m_fields[my_fields-1].has_minimum ()))  
    { 
      my_fields--; 
    } 
   
    // Ranges with only wild cards: set first field of min to 0 
  if (my_fields == 0) {
    result << 0;
    return result; // Don't combine these two lines --- it inhibits RVO.
  }
   
    // Copy fields to result - look for wild cards 
  for (size_type field_number = 0; field_number < my_fields; field_number++)  
    { 
      const field& f = m_fields[field_number]; 
       
      if (!f.has_minimum ())  
        { 
            // Wilds card -> set field to 0 
          result << 0; 
        }        
      else  
        { 
            // Valued field 
          result << f.get_minimum (); 
        } 
    } 
   
  return (result); 
} 

operator std::string()

Range::operator std::string

(

)

const

Produce a textual representation of the range using the input format.

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

{ 
  std::string result; 
 
  size_type my_fields = m_fields.size (); 
 
    // Remove trailing wild cards since they are meaningless. 
  while ((my_fields > 1) && 
         (!m_fields[my_fields-1].is_valued ())) 
    { 
      my_fields--; 
    } 
 
  if (my_fields == 0) return (result); 
 
    // print fields one by one. 
  for (size_type field_number = 0; field_number < my_fields; field_number++) 
    { 
      const field& f = m_fields[field_number]; 
 
      if (field_number > 0) result += "/"; 
      result += (std::string) f; 
    } 
 
  return (result); 
} 

operator!=()

bool Range::operator!=

(

const Range &

other

)

const

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

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

operator=() [1/2]

Range & Range::operator=

(

const Range &

other

)

Assignment.

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

{ 
  if (this != &other)
    m_fields = other.m_fields; 
  return *this;
} 

operator=() [2/2]

Range & Range::operator=

(

Range &&

other

)

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

{ 
  if (this != &other)
    m_fields = std::move (other.m_fields);
  return *this;
} 

operator==()

bool Range::operator==

(

const Range &

other

)

const

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

{
    if (m_fields.size() != other.m_fields.size()) return false;
    field_vector::const_iterator it1  = m_fields.begin();
    field_vector::const_iterator it2  = other.m_fields.begin();
    field_vector::const_iterator last = m_fields.end();
    for (; it1 != last; ++it1, ++it2) {
    if ((*it1) != (*it2)) return false;
    }
    return (true);
}

operator[]()

const Range::field & Range::operator[] ( Range::size_type  index ) const

inline

Accessors.

Access the field elements

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

{ 
  if (index >= m_fields.size ()) 
    { 
      static const field f; 
 
      return (f); 
    } 
 
  return (m_fields[index]); 
} 

overlaps_with()

bool Range::overlaps_with

(

const Range &

other

)

const

Check if two Ranges overlap.

Check overlap between two Ranges :

As soon as one pair of corresponding fields do not match, the global overlap is empty.

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

{ 
  const Range& me = *this; 
 
  if ((fields () == 0) || (other.fields () == 0)) return (false); 
 
  for (size_type i = 0; i < std::min (fields (), other.fields ()); ++i) 
    { 
      const field& f1 = me[i]; 
      const field& f2 = other[i]; 
 
      if (!f1.overlaps_with (f2)) return (false); 
    } 
 
  return (true); 
} 

show() [1/2]

void Range::show

(

)

const

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

{
  show (std::cout);
}

show() [2/2]

void Range::show

(

std::ostream &

s

)

const

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

{ 
  const Range& me = *this; 
 
  s << (std::string) me << " (";
 
  int allbits = 0;
 
  for (size_type i = 0; i < fields (); ++i) 
    { 
      const field& f = me[i]; 
 
      if (i > 0) s << "+";
 
      size_type indices = f.get_indices ();
 
      int bits = 1;
      indices--;
      if (indices > 0)
        {
          bits = 0;
          while (indices > 0)
            {
              indices /= 2;
              bits++;
            }
        }
 
      allbits += bits;
 
      s << bits; 
    } 
 
  s << "=" << allbits << ") ";
} 

Member Data Documentation

m_fields

field_vector Range::m_fields

private

Definition at line 344 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