DetectorDescription/Identifier/Identifier/Range.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef IDENTIFIER_RANGE_H
#define IDENTIFIER_RANGE_H
 
#include <Identifier/ExpandedIdentifier.h>
#include "Identifier/IdentifierField.h"
#include <vector>
#include <cassert>
#include <stdexcept>
#include <bit>
#include <iosfwd>
 
class Range { 
public: 
 
  using element_type = ExpandedIdentifier::element_type ; 
  using size_type = ExpandedIdentifier::size_type ; 
  using field = IdentifierField ;
  using field_vector = std::vector<field>; 
 
 
  Range () = default; 
 
 
  Range (const Range& other, size_type start); 
 
  
 
  Range (const ExpandedIdentifier& root);
  
  explicit Range(const std::string & text);
 
  void build (const std::string& text);
 
  void build (const ExpandedIdentifier& root); 
 
 
  void clear (); 
 
  void add (); 
 
  void add (element_type value); 
 
  void add (element_type minimum, element_type maximum); 
 
  void add (const field& f); 
 
  void add (field&& f);
 
  void add (const Range& subrange); 
 
  void add (Range&& subrange); 
 
  int match (const ExpandedIdentifier& id) const; 
  
  const field& operator [] (size_type index) const; 
  size_type fields () const; 
  bool is_empty () const; 
 
  ExpandedIdentifier minimum () const; 
  ExpandedIdentifier maximum () const; 
 
  size_type cardinality () const;
  //  Up to a given id
  size_type cardinalityUpTo (const ExpandedIdentifier& id) const;
 
  bool overlaps_with (const Range& other) const; 
 
  void show () const; 
  void show (std::ostream& s) const; 
 
  operator std::string () const; 
 
  bool operator == (const Range& other) const; 
 
private: 
  field_vector m_fields; 
}; 
 
 
 
//----------------------------------------------- 
inline Range::size_type Range::fields () const { 
  return (m_fields.size ()); 
} 
 
 
 
//----------------------------------------------- 
inline bool Range::is_empty () const { 
  if (m_fields.size () == 0) return (true); 
  return (false); 
} 
 
 
std::ostream & 
operator << (std::ostream &out, const Range &r);
 
std::istream & 
operator >> (std::istream &in, Range &r);
 
 
#endif