DetectorDescription/Identifier/Identifier/Identifier.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef IDENTIFIER_IDENTIFIER_H
#define IDENTIFIER_IDENTIFIER_H
 
 
#define IDENTIFIER_TYPE unsigned long long
#define IDENTIFIER_DIFF_TYPE long long
#define IDENTIFIER_PCODE "ll"
 
#include "GaudiKernel/MsgStream.h"
#include "Identifier/Identifier32.h"
#include <string>
#include <boost/io/ios_state.hpp>
 
class Identifier
{
public:
 
    typedef Identifier                  id_type;
    typedef IDENTIFIER_TYPE             value_type;
    typedef IDENTIFIER_DIFF_TYPE        diff_type;
    typedef IDENTIFIER_TYPE             size_type;
 
    typedef enum
    {
        NBITS = sizeof(value_type) * 8, // bits per byte
        MAX_BIT = (static_cast<value_type>(1) << (NBITS - 1)),
        ALL_BITS = ~(static_cast<value_type>(0))
    } bit_defs;
 
 
    Identifier() = default;
    Identifier(const Identifier& other) = default;
    Identifier(Identifier&& other) = default;
    Identifier& operator=(const Identifier& old) = default;
    Identifier& operator=(Identifier&& old) = default;
    ~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  (void) const;
 
    value_type   get_compact  (void) const;
 
    class get_compact_func
    {
    public:
        value_type operator() (const Identifier& id)
            {
                return id.get_compact();
            }
    };
 
  
    bool operator ==    (const Identifier& other) const;
    bool operator !=    (const Identifier& other) const;
    bool operator <     (const Identifier& other) const;
    bool operator >     (const Identifier& other) const;
    bool operator <=    (const Identifier& other) const;
    bool operator >=    (const Identifier& other) const;
 
    bool operator ==    (value_type other) const;
    bool operator !=    (value_type other) const;
    bool operator ==    (Identifier32::value_type other) const;
    bool operator ==    (int 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;
    
    typedef enum {
        //max_value = 0xFFFFFFFFFFFFFFFFULL
        max_value = ~(static_cast<value_type>(0))
    } max_value_type;
 
    //----------------------------------------------------------------
    // The compact identifier data.
    //----------------------------------------------------------------
    value_type m_id = max_value;
 
};
//-----------------------------------------------
 
 
// Define a hash functional
 
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