Message.h

#ifndef BASE_MESSAGE_H
#define BASE_MESSAGE_H
 
#include <cstdint>
#include <iostream>
 
#include "base/defines.h"
 
namespace base {
 
   enum MessageFormat {
      formatEth1   = 0,  
      formatOptic1 = 1,  
      formatEth2   = 2,  
      formatOptic2 = 3,  
      formatNormal = 4   
   };
 
   enum MessageTypes {
      MSG_NOP    = 0,    
      MSG_HIT    = 1,    
      MSG_EPOCH  = 2,    
      MSG_SYNC   = 3,    
      MSG_AUX    = 4,    
      MSG_EPOCH2 = 5,    
      MSG_GET4   = 6,    
      MSG_SYS    = 7     
   };
 
   enum SysMessageTypes {
      SYSMSG_DAQ_START    = 1,      
      SYSMSG_DAQ_FINISH   = 2,      
      SYSMSG_NX_PARITY    = 3,      
      SYSMSG_SYNC_PARITY  = 4,      
      SYSMSG_DAQ_RESUME   = 5,      
      SYSMSG_FIFO_RESET   = 6,      
      SYSMSG_USER         = 7,      
      SYSMSG_PCTIME       = 8,      
      SYSMSG_ADC          = 9,      
      SYSMSG_PACKETLOST   = 10,     
      SYSMSG_GET4_EVENT   = 11,     
      SYSMSG_CLOSYSYNC_ERROR = 12,  
      SYSMSG_TS156_SYNC   = 13      
   };
 
   enum SysMessageUserTypes {
      SYSMSG_USER_CALIBR_ON    = 7,  
      SYSMSG_USER_CALIBR_OFF   = 8,  
      SYSMSG_USER_RECONFIGURE  = 9   
   };
 
   enum MessagePrintMask {
      msg_print_Prefix = 1,   
      msg_print_Data   = 2,   
      msg_print_Hex    = 4,   
      msg_print_Human  = 8    
   };
 
   class Message {
 
      protected:
         uint64_t data;   
 
      public:
         Message() : data(0) {}
 
         Message(const Message& src) : data(src.data) {}
 
         void assign(const Message& src) { data = src.data; }
 
         Message& operator=(const Message& src) { assign(src); return *this; }
 
         inline void reset() { data = 0; }
 
         inline uint32_t getField(uint32_t shift, uint32_t len) const
            { return (data >> shift) & ((((uint32_t)1) << len) - 1); }
 
         inline void setField(uint32_t shift, uint32_t len, uint32_t value)
            { data = (data & ~(((((uint64_t) 1) << len) - 1) << shift)) | (((uint64_t) value) << shift); }
 
         inline uint8_t getBit(uint32_t shift) const
            { return (data >> shift) & 1; }
 
         inline void setBit(uint32_t shift, uint8_t value)
            { data = value ? (data | (((uint64_t) 1) << shift)) : (data & ~(((uint64_t) 1) << shift)) ; }
 
 
         // --------------------------- common fields ---------------------------------
 
         inline uint8_t getMessageType() const { return getField(0, 4); }
 
         inline uint16_t getRocNumber() const { return getField(48, 16); }
 
         inline void setMessageType(uint8_t v) { setField(0, 4, v); }
 
         inline void setRocNumber(uint16_t v) { setField(48, 16, v); }
 
         // ---------- Epoch marker access methods ------------
 
         // 2 bit unused
 
         inline uint32_t getEpochNumber() const { return data >> 8; }
 
 
         inline uint8_t getEpochMissed() const { return getField(40, 8); }
 
         inline void setEpochNumber(uint32_t v) { setField(8, 32, v); }
 
         inline void setEpochMissed(uint8_t v) { setField(40, 8, v); }
 
 
         // ---------- Sync marker access methods -------------
 
         inline uint8_t getSyncChNum() const { return getField(6, 2); }
 
         inline uint16_t getSyncTs() const { return getField(8, 13) << 1; }
 
         inline uint8_t getSyncEpochLSB() const { return getBit(21); }
 
         inline uint32_t getSyncData() const { return getField(22, 24); }
 
         inline uint8_t getSyncStFlag() const { return getField(46, 2); }
 
 
         inline void setSyncChNum(uint8_t v) { setField(6, 2, v); }
 
         inline void setSyncTs(uint16_t v) { setField(8, 13, v >> 1); }
 
         inline void setSyncEpochLSB(uint8_t v) { setBit(21, v); }
 
         inline void setSyncData(uint32_t v) { setField(22, 24, v); }
 
         inline void setSyncStFlag(uint8_t v)  { setField(46, 2, v); }
 
 
         // ---------- AUX marker access methods --------------
 
         inline uint8_t getAuxChNum() const { return getField(6, 7); }
 
         inline uint16_t getAuxTs() const { return getField(13, 13) << 1; }
 
         inline uint8_t getAuxEpochLSB() const { return getBit(26); }
 
         inline uint8_t getAuxFalling() const { return getBit(27); }
 
         inline uint8_t getAuxOverflow() const { return getBit(28); }
 
 
         inline void setAuxChNum(uint8_t v) { setField(6, 7, v); }
 
         inline void setAuxTs(uint16_t v) { setField(13, 13, v >> 1); }
 
         inline void setAuxEpochLSB(uint8_t v) { setBit(26, v); }
 
         inline void setAuxFalling(uint8_t v) { setBit(27, v); }
 
         inline void setAuxOverflow(uint8_t v) { setBit(28, v); }
 
         // ---------- System message access methods ----------
 
         // 2 bit unused
 
         inline uint8_t getSysMesType() const { return getField(8, 8); }
 
         // inline uint32_t getSysMesData() const { return getField(16, 32); }
         // on some machine 32-bit field not working
         inline uint32_t getSysMesData() const { return data >> 16; }
 
         inline void setSysMesType(uint8_t v) { setField(8, 8, v); }
 
         inline void setSysMesData(uint32_t v) { setField(16, 32, v); }
 
 
         // ---------- Common functions -----------------------
 
         inline bool isNopMsg() const { return getMessageType() == MSG_NOP; }
         inline bool isEpochMsg() const { return getMessageType() == MSG_EPOCH;}
         inline bool isSyncMsg() const { return getMessageType() == MSG_SYNC; }
         inline bool isAuxMsg() const { return getMessageType() == MSG_AUX; }
         inline bool isSysMsg() const { return getMessageType() == MSG_SYS; }
 
         inline bool isStartDaqMsg() const
           { return isSysMsg() && (getSysMesType() == SYSMSG_DAQ_START); }
         inline bool isStopDaqMsg() const
           { return isSysMsg() && (getSysMesType() == SYSMSG_DAQ_FINISH); }
 
         // -------------------- methods for working with different formats
 
         static uint32_t RawSize(int fmt);
 
   };
 
}
 
 
#endif