Identifier.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 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) {
    std::cout << "Identifier::Identifier - WARNING Constructing 64-bit id "
                 "with empty upper and non-empty lower: "
              << std::hex << testUpper << " " << testLower << std::dec << std::endl;
    m_id = (value << 32);
  }
}
 
 
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) {
    std::cout << "Identifier::operator = - WARNING Constructing 64-bit id "
                 "with empty upper and non-empty lower: "
              << std::hex << testUpper << " " << testLower << std::dec << 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() 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() const{
  return (m_id);
}
 
 
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));
}
 
/// 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));
}