ROIrawID.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <stdint.h>
 
namespace Belle2 {
  class ROIrawID {
 
  public:
    //    typedef unsigned long baseType;
    typedef uint64_t baseType; 
    enum {
      UnusedBits = 21,
      SystemFlagBits = 1,
      DHHIDBits = 6,
      MinVBits = 10,
      MinUBits = 8,
      MaxVBits = 10,
      MaxUBits = 8,
      Bits = UnusedBits + SystemFlagBits + DHHIDBits + MinVBits + MinUBits + MaxVBits + MaxUBits,
 
// the following are unused atm, might be used for consistency checks
//       MaxSystemFlag = (1 << SystemFlagBits) - 1,
//       MaxDHHID = (1 << DHHIDBits) - 1,
//       MaxMinV = (1 << MinVBits) - 1,
//       MaxMinU = (1 << MinUBits) - 1,
//       MaxMaxV = (1 << MaxVBits) - 1,
//       MaxMaxU = (1 << MaxUBits) - 1,
    };
 
 
    explicit ROIrawID(baseType id = 0)
    {
      m_rawID.id = id;
    } 
    ROIrawID(baseType SystemFlag, baseType DHHID, baseType MinV, baseType MinU, baseType MaxV, baseType MaxU)
    {
 
      m_rawID.parts.unused = 0;
      m_rawID.parts.systemFlag = SystemFlag;
      m_rawID.parts.DHHID = DHHID;
      m_rawID.parts.minV = MinV;
      m_rawID.parts.minU = MinU;
      m_rawID.parts.maxV = MaxV;
      m_rawID.parts.maxU = MaxU;
    } 
    baseType getSystemFlag() const {return m_rawID.parts.systemFlag;} 
    baseType getDHHID() const {return m_rawID.parts.DHHID;} 
    baseType getMinVid() const {return m_rawID.parts.minV;} 
    baseType getMinUid() const {return m_rawID.parts.minU;} 
    baseType getMaxVid() const {return m_rawID.parts.maxV;} 
    baseType getMaxUid() const {return m_rawID.parts.maxU;} 
    baseType getID() const {return m_rawID.id;} 
    baseType getBigEndian() const; 
    void setSystemFlag(baseType  SystemFlag) {m_rawID.parts.systemFlag = SystemFlag;} 
    void setDHHID(baseType DHHID) {m_rawID.parts.DHHID = DHHID;} 
    void setMinVid(baseType MinV) {m_rawID.parts.minV = MinV;} 
    void setMinUid(baseType MinU) {m_rawID.parts.minU = MinU;} 
    void setMaxVid(baseType MaxV) {m_rawID.parts.maxV = MaxV;} 
    void setMaxUid(baseType MaxU) {m_rawID.parts.maxU = MaxU;} 
    void setID(baseType id) {m_rawID.id = id;} 
    ~ROIrawID() {};
 
    inline bool operator()(const ROIrawID& roi1, const ROIrawID& roi2) const
    {
      if (roi1.getDHHID() == roi2.getDHHID())
        return roi1.getID() < roi2.getID();
      else return roi1.getDHHID() < roi2.getDHHID();
    } 
  private:
 
    union {
baseType id: Bits;
      struct {
baseType maxU: MaxUBits;
baseType maxV: MaxVBits;
baseType minU: MinUBits;
baseType minV: MinVBits;
baseType DHHID: DHHIDBits;
baseType systemFlag: SystemFlagBits;
baseType unused: UnusedBits;
      } parts;
 
    } m_rawID; 
  };
}