ExpandedIdentifier.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
//-----------------------------------------------
inline ExpandedIdentifier::ExpandedIdentifier(const ExpandedIdentifier& other,
                                              size_type start)
{
  if (start < other.fields()) {
    element_vector::const_iterator it = other.m_fields.begin();
    it += start;
 
    m_fields.insert(m_fields.end(), it, other.m_fields.end());
  }
}
 
// Modifications
//-----------------------------------------------
inline void
ExpandedIdentifier::add(element_type value)
{
  // Max size of id levels should be < 12
  m_fields.push_back(value);
}
 
//-----------------------------------------------
inline ExpandedIdentifier&
ExpandedIdentifier::operator<<(element_type value)
{
  // Max size of id levels should be < 12
  m_fields.push_back(value);
  return (*this);
}
 
//-----------------------------------------------
inline ExpandedIdentifier::element_type& ExpandedIdentifier::operator[](
  size_type index)
{
  // Raises an exception if index is out-of-bounds.
  return m_fields.at(index);
}
 
//-----------------------------------------------
inline void
ExpandedIdentifier::clear()
{
  m_fields.clear();
}
 
// Accessors
//-----------------------------------------------
inline ExpandedIdentifier::element_type ExpandedIdentifier::operator[](
  size_type index) const
{
  // Raises an exception if index is out-of-bounds.
  return m_fields.at(index);
}
 
//-----------------------------------------------
inline ExpandedIdentifier::size_type
ExpandedIdentifier::fields() const
{
  return (m_fields.size());
}
 
// Comparison operators
 
//----------------------------------------------------------------
inline int
ExpandedIdentifier::operator==(const ExpandedIdentifier& other) const
{
  const ExpandedIdentifier& me = *this;
  const size_type my_fields = fields();
  const size_type other_fields = other.fields();
 
  if (my_fields != other_fields)
    return (0);
 
  size_type field = 0;
  for (; field < my_fields; ++field) {
    if (me[field] != other[field])
      return (0);
  }
 
  return (1);
}
 
//----------------------------------------------------------------
inline int
ExpandedIdentifier::operator!=(const ExpandedIdentifier& other) const
{
  const ExpandedIdentifier& me = *this;
 
  return (!(me == other));
}
 
//-----------------------------------------------
inline int
ExpandedIdentifier::operator<(const ExpandedIdentifier& other) const
{
  const ExpandedIdentifier& me = *this;
  const size_type my_fields = fields();
  const size_type other_fields = other.fields();
 
  size_type field = 0;
  for (;;) {
    if ((field == my_fields) || (field == other_fields)) {
      // Someone has run out of fields. And up to now my_id ==
      // other_id. If the lengths are different, the following
      // then defines the "shorter" one to be "less than". If
      // the lengths are the same, then the two are NOT "less
      // than".
      return (my_fields < other_fields);
    }
 
    element_type my_field = me[field];
    element_type other_field = other[field];
 
    if (my_field < other_field)
      return (1);
    if (my_field > other_field)
      return (0);
 
    field++;
  }
 
  return (0);
}
 
//-----------------------------------------------
inline int
ExpandedIdentifier::operator>(const ExpandedIdentifier& other) const
{
  const ExpandedIdentifier& me = *this;
 
  return (other < me);
}
 
//----------------------------------------------------------------
inline int
ExpandedIdentifier::match(const ExpandedIdentifier& other) const
{
  const ExpandedIdentifier& me = *this;
  const size_type my_fields = fields();
  const size_type other_fields = other.fields();
 
  const size_type fs = (my_fields < other_fields) ? my_fields : other_fields;
 
  for (size_type field = 0; field < fs; ++field) {
    if (me[field] != other[field])
      return (0);
  }
 
  return (1);
}