SVDModeByte.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.                  *
 **************************************************************************/
 
#ifndef SVDMODEBYTE_H
#define SVDMODEBYTE_H
 
#include <cstdint>
#include <string>
#include <ostream>
 
namespace Belle2 {
  // NB: I replaced enums with constexpressions here, since GCC complains
  // (falsely, clang does not) about structure sizes, and the warnings can
  // not be suppressed due to an error in GCC (July 2017).
 
  namespace SVDRunType {
    constexpr uint8_t
    raw = 0, 
    transparent = 1, 
    zero_suppressed = 2, 
    zero_suppressed_timefit = 3; 
  }
 
  namespace SVDEventType {
    constexpr uint8_t
    global_run = 0, 
    local_run = 1; 
  }
 
  namespace SVDDAQModeType {
    constexpr uint8_t
    daq_1sample = 0, 
    daq_3samples = 1, 
    daq_6samples = 2; 
  }
 
  class SVDModeByte {
  public:
    typedef uint8_t baseType;
    enum {
      TriggerBinBits = 3,
      DAQModeBits = 2,
      EventTypeBits = 1,
      RunTypeBits = 2,
      Bits = TriggerBinBits + DAQModeBits + EventTypeBits + RunTypeBits,
 
      MaxTriggerTime = (1 << TriggerBinBits) - 1,
      MaxGoodTriggerBin = 3,
      MaxDAQMode = (1 << DAQModeBits) - 1,
      MaxEventType = (1 << EventTypeBits) - 1,
      MaxRunType = (1 << RunTypeBits) - 1,
      MaxID = (1 << Bits) - 1,
 
    };
 
    static const baseType c_DefaultID;
 
    // cppcheck-suppress noExplicitConstructor
    SVDModeByte(baseType id = c_DefaultID)
    {
      m_id.id = id;
    }
    SVDModeByte(baseType runType, baseType eventType, baseType daqMode,
                baseType triggerBin)
    {
      m_id.parts.triggerBin   = triggerBin;
      m_id.parts.daqMode  = daqMode;
      m_id.parts.eventType = eventType;
      m_id.parts.runType = runType;
    }
    SVDModeByte(const SVDModeByte& b): m_id(b.m_id) {}
 
    SVDModeByte& operator=(const SVDModeByte& b) { m_id = b.m_id; return *this; }
    SVDModeByte& operator=(baseType id) { m_id.id = id; return *this; }
    operator baseType() const { return getID(); }
    operator std::string() const;
    bool operator==(const SVDModeByte& b) const   { return getID() == b.getID(); }
 
    baseType getID() const { return m_id.id; }
    baseType getTriggerBin() const { return m_id.parts.triggerBin; }
    baseType getDAQMode() const { return m_id.parts.daqMode; }
    baseType getEventType() const { return m_id.parts.eventType; }
    baseType getRunType() const { return m_id.parts.runType; }
 
    // Some useful getters
    bool hasTimeFit() const
    { return m_id.parts.runType == SVDRunType::zero_suppressed_timefit; }
    bool isZeroSuppressedRun() const
    {
      return (
               (m_id.parts.runType == SVDRunType::zero_suppressed)
               ||
               (m_id.parts.runType == SVDRunType::zero_suppressed_timefit)
             );
    }
 
    void setID(baseType id) { m_id.id = id; }
    void setTriggerBin(baseType triggerBin)
    { m_id.parts.triggerBin  = triggerBin;  }
    void setDAQMode(baseType daqMode)
    { m_id.parts.daqMode = daqMode; }
    void setEventType(baseType eventType)
    { m_id.parts.eventType = eventType; }
    void setRunType(baseType runType)
    { m_id.parts.runType = runType; }
 
    std::string __str__() const { return (std::string)(*this); }
 
  private:
 
    // NB: the awful indentation is due to fixstyle.
    union {
baseType id: Bits;
      struct {
baseType triggerBin: TriggerBinBits;
baseType daqMode: DAQModeBits;
baseType eventType: EventTypeBits;
baseType runType: RunTypeBits;
      } parts ;
    } m_id; 
  };
 
  std::ostream& operator<<(std::ostream& out, const SVDModeByte& id);
} // namespace Belle2
 
#endif //SVDMODEBYTE_H