RawTriggerV0.h

Go to the documentation of this file.

#ifndef DAQRAWTRIGGERV0_H
#define DAQRAWTRIGGERV0_H
#include "DAQDataFormats/RawDAQData.h"
#include "DAQDataFormats/Macros.h"

/// It is requred to
///   1. include DAQDataFormats/DataFormatFirst.inc
///   2. define CURRENT_CLASS
///   3.    define CURRENT_CLASS_VERSION for version of the class
///      OR define LAST_CLASS_VERSION    for the main structure of the class
///   4. (optional) define CURRENT_FIELDS_SUB_NAMESPACE
///   5. include DAQDataFormats/DataFormatLast.inc
/// before the declaration of the DataFormat version class in the header.
#include "DAQDataFormats/DataFormatFirst.inc"
#define  CURRENT_CLASS                RawTrigger
#define  CURRENT_CLASS_VERSION        0
#define  CURRENT_FIELDS_SUB_NAMESPACE rawtrigger
#include "DAQDataFormats/DataFormatLast.inc"

// forward declarations
namespace daqdataformats{
    class RawTriggerHeader;
    class RawTriggerTimingMarker;
    class RawTriggerRange;
    class RawTriggerTime;
    class RawTriggerMask;
}

namespace daqdataformats {

    namespace CURRENT_FIELDS_SUB_NAMESPACE{
    
            /// order in the version vector
            enum TriggerVersions{
                TriggerTimingMarker,
                TriggerRange,
                TriggerTime,
                TriggerMask,
                LAST
            };
    }

namespace  VERSION_NAMESPACE {
    namespace CURRENT_FIELDS_SUB_NAMESPACE{

            /// Versions of Trigger formats for the current trigger
            /// Header is the same version as RawTrigger
            static const version_t VERSION_TriggerTimingMarker = 0;
            static const version_t VERSION_TriggerRange        = 0;
            static const version_t VERSION_TriggerTime         = 0;
            static const version_t VERSION_TriggerMask         = 0;
        }


  //! Class to hold the data from the global trigger in the correct format
  /*!
    The RawTriggerV0 class is designed to mimic the format of the actual
    data that emitted from the global trigger process.  This information
    include the source of the trigger, the trigger number etc...

    The class supports general initialization with an internal or external
    data buffer as well as copyin style initialization for use with
    STL containers.
  */
  class RawTrigger : public PREVIOUS_VERSION_CLASS_NAME {

        public:
            // Constructors
            RawTrigger (const version_t); //! The default constructor
            RawTrigger (const RawTrigger&);
            /// Destructor
            ~RawTrigger();

            void     init           ();
            using    PREVIOUS_VERSION_CLASS_NAME::print;
            void     print          (std::ostream& os=std::cout) const;
            uint32_t sizeofdata     () const {return _size;}
            bool     setBufferSource(const void* pointer);

            // Get Methods for parts of the trigger block
            daqdataformats::RawTriggerHeader*       getTriggerHeader()       const {return _Header;}
            daqdataformats::RawTriggerTimingMarker* getTriggerTimingMarker() const {return _Marker;}
            daqdataformats::RawTriggerRange*        getTriggerRange()        const {return _Range;}
            daqdataformats::RawTriggerTime*         getTriggerTime()         const {return _Time;}
            daqdataformats::RawTriggerMask*         getTriggerMask()         const {return _Mask;}
            
      INIT_FIRST(setTriggerHeader      ,      , bool    , const daqdataformats::RawTriggerHeader&);
      INIT_FIRST(setTriggerTimingMarker,      , bool    , const daqdataformats::RawTriggerTimingMarker&);
      INIT_FIRST(setTriggerRange       ,      , bool    , const daqdataformats::RawTriggerRange&);
      INIT_FIRST(setTriggerTime        ,      , bool    , const daqdataformats::RawTriggerTime&);
      INIT_FIRST(setTriggerMask        ,      , bool    , const daqdataformats::RawTriggerMask&);
            
      INIT_FIRST(getTriggerStart       , const, uint64_t, );
      INIT_FIRST(setTriggerStart       ,      , bool    , const uint64_t);

            using          RawDAQData::readData;
            void*          readData(const void*);
        
        protected:
            /// Method to read data from a PIPE (not socket).
            /// Only one read can be made. After that the pipe is closed.
            /// According to Ron Rechenmacher, the maximum size of a PIPE is 512 bytes.
            INIT_FIRST(readDataFromFileDescriptor         ,      , readDataStatus, const int);
            readDataStatus readDataUnknownVersion(const int);

            bool setVersions();

        protected:
            //! Trigger Consists of the Following Items
            daqdataformats::RawTriggerHeader*       _Header;
            daqdataformats::RawTriggerTimingMarker* _Marker;
            daqdataformats::RawTriggerRange*        _Range;
            daqdataformats::RawTriggerTime*         _Time;
            daqdataformats::RawTriggerMask*         _Mask;

            uint32_t                _size; //< trigger size

            version_t _version_TriggerTimingMarker;
            version_t _version_TriggerRange;
            version_t _version_TriggerTime;
            version_t _version_TriggerMask;
  };
  
  
}} // END NAMESPCE daqdataformats
#endif /* DAQRAWTRIGGERV0_H */