Identifier.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
/// Constructor from Identifier32
//-----------------------------------------------
inline Identifier::Identifier(const Identifier32& other)
  : m_id(max_value)
{
  if (other.is_valid()) {
    m_id = (static_cast<value_type>(other.get_compact()) << 32);
  }
}
 
/// Constructor from Identifier32 value_type (unsigned int)
/// (only use in id64 case since otherwise redundant)
//-----------------------------------------------
inline Identifier::Identifier(Identifier32::value_type value)
  : m_id(max_value)
{
  if (value == ~static_cast<Identifier32::value_type>(0)) {
    m_id = max_value;
  } else {
    m_id = (static_cast<value_type>(value) << 32);
  }
}
inline Identifier::Identifier(int value)
  : m_id(static_cast<value_type>(value) << 32)
{
}
 
//-----------------------------------------------
inline Identifier::Identifier(value_type value)
  : m_id(value)
{
 
  // Print out warning for potential call with value for a 32-bit id
  // I.e. if lower bits are set and no upper bit set
  const value_type upper = 0XFFFFFFFF00000000LL;
  const value_type lower = 0X00000000FFFFFFFFLL;
  const value_type testUpper = value & upper;
  const value_type testLower = value & lower;
  if (testUpper == 0 && testLower > 0) {
    boost::io::ios_flags_saver ifs(std::cout);
    std::cout << "Identifier::Identifier - WARNING Constructing 64-bit id "
                 "with empty upper and non-empty lower: "
              << std::hex << testUpper << " " << testLower << std::endl;
    m_id = (value << 32);
  }
}
 
// Modifications
//-----------------------------------------------
 
inline Identifier&
Identifier::operator=(const Identifier32& old)
{
  m_id = (static_cast<value_type>(old.get_compact()) << 32);
  return (*this);
}
 
inline Identifier&
Identifier::operator=(value_type value)
{
 
  // Print out warning for potential call with value for a 32-bit id
  // I.e. if lower bits are set and no upper bit set
  const value_type upper = 0XFFFFFFFF00000000LL;
  const value_type lower = 0X00000000FFFFFFFFLL;
  const value_type testUpper = value & upper;
  const value_type testLower = value & lower;
  if (testUpper == 0 && testLower > 0) {
    boost::io::ios_flags_saver ifs(std::cout);
    std::cout << "Identifier::opertor = - WARNING Constructing 64-bit id "
                 "with empty upper and non-empty lower: "
              << std::hex << testUpper << " " << testLower << std::endl;
    m_id = (value << 32);
    return (*this);
  }
 
  m_id = value;
  return (*this);
}
 
inline Identifier&
Identifier::operator=(Identifier32::value_type value)
{
  if (value == ~static_cast<Identifier32::value_type>(0)) {
    m_id = max_value;
  } else {
    m_id = static_cast<value_type>(value) << 32;
  }
  return (*this);
}
inline Identifier&
Identifier::operator=(int value)
{
  m_id = static_cast<value_type>(value) << 32;
  return (*this);
}
 
inline Identifier&
Identifier::operator|=(value_type value)
{
  m_id |= value;
  return (*this);
}
 
inline Identifier&
Identifier::operator&=(value_type value)
{
  m_id &= value;
  return (*this);
}
 
inline Identifier&
Identifier::set_literal(value_type value)
{
  m_id = value;
  return (*this);
}
 
inline void
Identifier::clear()
{
  m_id = max_value;
}
 
inline Identifier::value_type
Identifier::extract(Identifier::size_type shift,
                    Identifier::size_type mask) const
{
  return (m_id >> shift) & static_cast<Identifier::value_type>(mask);
}
 
inline Identifier::value_type
Identifier::mask_shift(Identifier::value_type mask,
                       Identifier::size_type shift) const
{
  return (m_id & mask) >> shift;
}
 
inline Identifier::value_type
Identifier::extract(Identifier::size_type shift) const
{
  return (m_id >> shift);
}
 
inline Identifier32
Identifier::get_identifier32(void) const
{
  // test for bit set in lower 32
  if (extract(0, 0xFFFFFFFF))
    return (Identifier32());
  return (Identifier32(extract(32)));
}
 
inline Identifier::value_type
Identifier::get_compact(void) const
{
  return (m_id);
}
 
// Comparison operators
//----------------------------------------------------------------
inline bool
Identifier::operator==(const Identifier& other) const
{
  return (m_id == other.m_id);
}
 
//----------------------------------------------------------------
inline bool
Identifier::operator!=(const Identifier& other) const
{
  return (m_id != other.m_id);
}
 
//-----------------------------------------------
inline bool
Identifier::operator<(const Identifier& other) const
{
  return (m_id < other.m_id);
}
 
//-----------------------------------------------
inline bool
Identifier::operator>(const Identifier& other) const
{
  return (m_id > other.m_id);
}
 
//-----------------------------------------------
inline bool
Identifier::operator<=(const Identifier& other) const
{
  return (m_id <= other.m_id);
}
 
//-----------------------------------------------
inline bool
Identifier::operator>=(const Identifier& other) const
{
  return (m_id >= other.m_id);
}
 
//----------------------------------------------------------------
inline bool
Identifier::operator==(Identifier::value_type other) const
{
  return (m_id == other);
}
 
inline bool
Identifier::operator!=(Identifier::value_type other) const
{
  return (m_id != other);
}
 
inline bool
Identifier::operator==(Identifier32::value_type other) const
{
  return ((*this) == Identifier(other));
}
 
inline bool
Identifier::operator==(int other) const
{
  return ((*this) == Identifier(other));
}
 
inline bool
Identifier::operator!=(Identifier32::value_type other) const
{
  return ((*this) != Identifier(other));
}
 
inline bool
Identifier::operator!=(int other) const
{
  return ((*this) != Identifier(other));
}
 
/// This is for logging
 
inline MsgStream&
operator<<(MsgStream& f, const Identifier& id)
{
  f << id.getString();
  return f;
}
 
inline std::ostream&
operator<<(std::ostream& os, const Identifier& id)
{
  os << id.getString();
  return os;
}
 
inline bool
Identifier::is_valid() const
{
  return (!(max_value == m_id));
}