Range Class Reference

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

#include <Range.h>

Collaboration diagram for Range:

Public Types
using	element_type = ExpandedIdentifier::element_type
using	size_type = ExpandedIdentifier::size_type
using	field = IdentifierField
using	field_vector = std::vector< field >

Public Member Functions
	Range ()=default
	Range (const Range &other, size_type start)
	This is a sub-range copy constructor. More...
	Range (const ExpandedIdentifier &root)
	Construct from a simple ExpandedIdentifier. More...
	Range (const std::string &text)
void	build (const std::string &text)
	Build 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 (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
	Access the field elements. 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...
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

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 29 of file DetectorDescription/Identifier/Identifier/Range.h.

Member Typedef Documentation

element_type

using Range::element_type = ExpandedIdentifier::element_type

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

field

using Range::field = IdentifierField

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

field_vector

using Range::field_vector = std::vector<field>

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

size_type

using Range::size_type = ExpandedIdentifier::size_type

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

Constructor & Destructor Documentation

Range() [1/4]

Range::Range ( )

default

Range() [2/4]

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 37 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() [3/4]

Range::Range

(

const ExpandedIdentifier &

root

)

Construct from a simple ExpandedIdentifier.

This implies that all fields will have their min=max=id[i]

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

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

Range() [4/4]

Range::Range ( const std::string &  text )

explicit

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

                                  :Range(){
   if (text.empty()) return;
   std::istringstream in(text);
   in>>*this;
}

Member Function Documentation

add() [1/7]

void Range::add

(

)

Add a wild card field.

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

                 { 
  m_fields.emplace_back(); 
} 

add() [2/7]

void Range::add

(

const field &

f

)

Add a range specified using a field

Definition at line 92 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 102 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 85 of file DetectorDescription/Identifier/src/Range.cxx.

                                                           { 
  m_fields.emplace_back (minimum, maximum); 
} 

add() [5/7]

void Range::add

(

element_type

value

)

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

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

                                   { 
  m_fields.emplace_back (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 97 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 109 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]));
    }
  }
} 

build() [1/2]

void Range::build

(

const ExpandedIdentifier &

root

)

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

Definition at line 65 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.emplace_back(root[i]); 
  } 
} 

build() [2/2]

void Range::build

(

const std::string &

text

)

Build Range from a textual description.

The syntax is :

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

value-range : "*" | <value> | ":" <max> | <min> ":" | <min> ":" <max> | <value> "," <value> "," ... "," <value>

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

                                        { 
  if (text.empty()) return;
  std::istringstream in(text);
  in>>*this;
} 

cardinality()

Range::size_type Range::cardinality

(

)

const

Computes a possible cardinality :

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

Definition at line 239 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()

Range::size_type Range::cardinalityUpTo

(

const ExpandedIdentifier &

id

)

const

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

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

                                                                         { 
  size_type result = 0; 
  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.empty()) return 0;
    if (f.isEnumerated()) {
      // 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();
      }
    }
    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;
  }
  return result;
} 

clear()

void Range::clear

(

)

Modifications.

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

                   { 
  m_fields.clear (); 
} 

fields()

Range::size_type Range::fields ( ) const

inline

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

                                           { 
  return (m_fields.size ()); 
} 

is_empty()

bool Range::is_empty ( ) const

inline

Definition at line 158 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 130 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].empty())){ 
      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 < 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 187 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].empty())) { 
      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.empty()) { 
            // 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 158 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].empty())){ 
      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.empty()){ 
            // 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 363 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].empty()))  { 
      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 383 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

Access the field elements.

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

                                                                { 
  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 323 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 335 of file DetectorDescription/Identifier/src/Range.cxx.

                        {
  show (std::cout);
}

show() [2/2]

void Range::show

(

std::ostream &

s

)

const

Definition at line 339 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 145 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