JDAQEventHeader.hh

Go to the documentation of this file.

#ifndef __JDAQEVENTHEADER__
#define __JDAQEVENTHEADER__

#include "JIO/JSerialisable.hh"
#include "JDAQ/JDAQRoot.hh"
#include "JDAQ/JDAQHeader.hh"
#include "JDAQ/JDAQTriggerCounter.hh"
#include "JDAQ/JDAQTriggerMask.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  using JIO::JReader;
  using JIO::JWriter;


  /**
   * JDAQ event header.
   */
  class JDAQEventHeader :
    public JDAQHeader,
    public JDAQTriggerCounter,
    public JDAQTriggerMask
  {
  public:
    /**
     * Default constructor.
     */
    JDAQEventHeader() :
      JDAQHeader(),
      JDAQTriggerCounter(),
      JDAQTriggerMask(),
      overlays(0)
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    DAQ chronometer
     * \param  mask           trigger mask
     */
    JDAQEventHeader(const JDAQChronometer& chronometer,
                    const JDAQTriggerMask& mask = JDAQTriggerMask()) :
      JDAQHeader(chronometer),
      JDAQTriggerCounter(),
      JDAQTriggerMask(mask),
      overlays(0)
    {}

    
    /**
     * Get DAQ event header.
     *
     * \return                DAQ event header
     */
    const JDAQEventHeader& getDAQEventHeader() const
    {
      return static_cast<const JDAQEventHeader&>(*this);
    }


    /**
     * Check if header is same.
     *
     * \param  header         DAQ event header
     * \return                true if event headers are same; else false
     */
    inline bool is_same(const JDAQEventHeader& header) const
    {
      return (this->getDetectorID() == header.getDetectorID() &&
              this->getRunNumber()  == header.getRunNumber()  &&
              this->getFrameIndex() == header.getFrameIndex() &&
              this->getCounter()    == header.getCounter());
    }
        

    /**
     * Get number of overlays.
     *
     * \return                number of overlays
     */
    unsigned int getOverlays() const
    {
      return overlays;
    }


    /**
     * Read DAQ event header from input.
     *
     * \param  in             JReader
     * \param  header         JDAQEventHeader
     * \return                JReader
     */
    friend inline JReader& operator>>(JReader& in, JDAQEventHeader& header)
    {
      in >> static_cast<JDAQHeader&>        (header);
      in >> static_cast<JDAQTriggerCounter&>(header);
      in >> static_cast<JDAQTriggerMask&>   (header);
      in >> header.overlays;
       
      return in;
    }


    /**
     * Write DAQ event header to output.
     *
     * \param  out           JWriter
     * \param  header        JDAQEventHeader
     * \return               JWriter
     */
    friend inline JWriter& operator<<(JWriter& out, const JDAQEventHeader& header)
    {
      out << static_cast<const JDAQHeader&>        (header);
      out << static_cast<const JDAQTriggerCounter&>(header);
      out << static_cast<const JDAQTriggerMask&>   (header);
      out << header.overlays;

      return out;
    }


    /**
     * Get size of object.
     *
     * \return               number of bytes
     */
    static int sizeOf()
    {
      return (JDAQHeader        ::sizeOf() +
              JDAQTriggerCounter::sizeOf() +
              JDAQTriggerMask   ::sizeOf() +
              sizeof(unsigned int));
    }


    ClassDef(JDAQEventHeader,3);


  protected:
    unsigned int overlays;
  };


  /**
   * Equal operator for DAQ event headers.
   *
   * \param  first     event header
   * \param  second    event header
   * \result           true if first event header equal to second; else false
   */
  inline bool operator==(const JDAQEventHeader& first,
                         const JDAQEventHeader& second)
  {
    return (first.getDAQHeader()         == second.getDAQHeader()         &&
            first.getDAQTriggerCounter() == second.getDAQTriggerCounter() &&
            first.getDAQTriggerMask()    == second.getDAQTriggerMask());
  }


  /**
   * Not-equal operator for DAQ event headers.
   *
   * \param  first     event header
   * \param  second    event header
   * \result           true if first event header not equal to second; else false
   */
  inline bool operator!=(const JDAQEventHeader& first,
                         const JDAQEventHeader& second)
  {
    return !(first == second);
  }
}

#endif