DetectorDescription/Identifier/Identifier/Identifier.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef IDENTIFIER_IDENTIFIER_H
#define IDENTIFIER_IDENTIFIER_H
 
#include "GaudiKernel/MsgStream.h"
#include "Identifier/Identifier32.h"
#include <string>
 
/*
 *
 *  @brief Identifier is a simple type-safe 64 bit unsigned integer. An
 *  Identifier relies on other classes - IdHelpers - to encode and
 *  decode its information.
 *  
 *  The default constructor created an Identifier an invalid state
 *  which can be check with the "is_valid" method to allow some error
 *  checking.
 *  
 */
class Identifier{
public:
 
    using id_type = Identifier;
    using value_type = unsigned long long;
    using diff_type = long long;
    using size_type = unsigned long long ;
 
    enum bit_defs{
        NBITS = sizeof(value_type) * 8, // bits per byte
        MAX_BIT = (static_cast<value_type>(1) << (NBITS - 1)),
        ALL_BITS = ~(static_cast<value_type>(0))
    };
 
    Identifier() = default;
 
    explicit Identifier (value_type value);
 
    Identifier (const Identifier32& other);
 
    explicit Identifier (Identifier32::value_type value);
    explicit Identifier (int value);
   
    Identifier& operator = (const Identifier32& old);
    Identifier& operator = (value_type value);
    Identifier& operator = (Identifier32::value_type value);
    Identifier& operator = (int value);
 
private:
    Identifier& operator |= (value_type value);
    Identifier& operator &= (value_type value);
 
public:
 
    void set (const std::string& id);
 
    void clear ();
 
    Identifier& set_literal(value_type value);
 
    Identifier32 get_identifier32() const;
 
    value_type   get_compact() const;
 
    struct get_compact_func{
      value_type operator() (const Identifier& id){
        return id.get_compact();
      }
    };
   
    bool operator == (const Identifier& other) const = default;
    inline auto operator <=> (const Identifier & other) const {return m_id <=> other.m_id;}
    bool operator ==  (value_type other) const;
    bool operator ==  (Identifier32::value_type other) const;
    bool operator ==  (int other) const;
  
    bool is_valid () const;
 
    std::string  getString() const;
 
    void show () const;
 
private:
    value_type extract(size_type shift, size_type mask) const;
 
    value_type mask_shift(value_type mask, size_type shift) const;
 
    value_type extract(size_type shift) const;
 
    // allow IdDict access to the following private methods
    friend class IdDictDictionary;
    friend class IdDictFieldImplementation;
    friend class AtlasDetectorID;
    friend class PixelID;
    
    enum max_value_type{
      max_value = ~(static_cast<value_type>(0))
    };
    value_type m_id = max_value;
};
 
 
namespace std {
  template<>
  struct hash<Identifier>{
    size_t operator()(const Identifier& id) const{
      return static_cast<size_t>(id.get_compact());
    }
  };
}
 
#include "Identifier/Identifier.icc"
 
#endif