ReadoutTriggerDataFrame.h

Go to the documentation of this file.

//   **************************************************************************
//   *                                                                        *
//   *                      ! ! ! A T T E N T I O N ! ! !                     *
//   *                                                                        *
//   *  This file was created automatically by GaudiObjDesc, please do not    *
//   *  delete it or edit it by hand.                                         *
//   *                                                                        *
//   *  If you want to change this file, first change the corresponding       *
//   *  xml-file and rerun the tools from GaudiObjDesc (or run make if you    *
//   *  are using it from inside a Gaudi-package).                            *
//   *                                                                        *
//   **************************************************************************

#ifndef ReadoutEvent_ReadoutTriggerDataFrame_H
#define ReadoutEvent_ReadoutTriggerDataFrame_H 1

// Include files
#include "Conventions/Trigger.h"
#include "Event/DaqLtbFrame.h"
#include "Context/TimeStamp.h"
#include "GaudiKernel/boost_allocator.h"
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations
  class ReadoutTriggerDataPkg;
  class ReadoutRpcTriggerDataFrame;
  

  class ReadoutTriggerDataFrame
  {
  public:

  ReadoutTriggerDataFrame(const DayaBay::ReadoutTriggerDataFrame& rhs);
  
    ReadoutTriggerDataFrame() : m_package(0),
                                m_seqNumber(0),
                                m_readoutType(0),
                                m_triggerType(),
                                m_triggerTime(0),
                                m_cycle(0),
                                m_nhit(0),
                                m_esumAdc(0),
                                m_esumComp(0),
                                m_crossSource(0),
                                m_isRpc(false) {}
  
    virtual ~ReadoutTriggerDataFrame() {}
  
    DaqLtbFrame* daqLtbFrame(const DayaBay::Detector& detector) const;
  
    const DayaBay::ReadoutRpcTriggerDataFrame* asRpcFrame() const;
  
    ReadoutTriggerDataFrame& operator=(const DayaBay::ReadoutTriggerDataFrame& rhs);
  
    std::ostream& fillStream(std::ostream& s) const;
  
  const DayaBay::ReadoutTriggerDataPkg* package() const;
  
  void setPackage(DayaBay::ReadoutTriggerDataPkg* value);
  
  int seqNumber() const;
  
  void setSeqNumber(int value);
  
  int readoutType() const;
  
  void setReadoutType(int value);
  
  const DayaBay::Trigger::TriggerType_t& triggerType() const;
  
  void setTriggerType(const DayaBay::Trigger::TriggerType_t& value);
  
  const TimeStamp& triggerTime() const;
  
  void setTriggerTime(const TimeStamp& value);
  
  unsigned int cycle() const;
  
  void setCycle(unsigned int value);
  
  int nhit() const;
  
  void setNhit(int value);
  
  int esumAdc() const;
  
  void setEsumAdc(int value);
  
  int esumComp() const;
  
  void setEsumComp(int value);
  
  int crossSource() const;
  
  void setCrossSource(int value);
  
  bool isRpc() const;
  
  void setIsRpc(bool value);
  
  
  #ifndef GOD_NOALLOC

    static void* operator new ( size_t size )
    {
      return ( sizeof(ReadoutTriggerDataFrame) == size ? 
               boost::singleton_pool<ReadoutTriggerDataFrame, sizeof(ReadoutTriggerDataFrame)>::malloc() :
               ::operator new(size) );
    }
  
    static void* operator new ( size_t size, void* pObj )
    {
      return ::operator new (size,pObj);
    }
  
    static void operator delete ( void* p )
    {
      boost::singleton_pool<ReadoutTriggerDataFrame, sizeof(ReadoutTriggerDataFrame)>::is_from(p) ?
      boost::singleton_pool<ReadoutTriggerDataFrame, sizeof(ReadoutTriggerDataFrame)>::free(p) :
      ::operator delete(p);
    }
  
    static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
  #endif
  protected:

  private:

    DayaBay::ReadoutTriggerDataPkg* m_package;     
    int                             m_seqNumber;   
    int                             m_readoutType; 
    DayaBay::Trigger::TriggerType_t m_triggerType; 
    TimeStamp                       m_triggerTime; 
    unsigned int                    m_cycle;       
    int                             m_nhit;        
    int                             m_esumAdc;     
    int                             m_esumComp;    
    int                             m_crossSource; 
    bool                            m_isRpc;       
  
  }; // class ReadoutTriggerDataFrame

  inline std::ostream& operator<< (std::ostream& str, const ReadoutTriggerDataFrame& obj)
  {
    return obj.fillStream(str);
  }
  
} // namespace DayaBay;

// -----------------------------------------------------------------------------
// end of class
// -----------------------------------------------------------------------------

// Including forward declarations
#include "ReadoutTriggerDataPkg.h"
#include "ReadoutRpcTriggerDataFrame.h"


inline const DayaBay::ReadoutTriggerDataPkg* DayaBay::ReadoutTriggerDataFrame::package() const 
{
  return m_package;
}

inline void DayaBay::ReadoutTriggerDataFrame::setPackage(DayaBay::ReadoutTriggerDataPkg* value) 
{
  m_package = value;
}

inline int DayaBay::ReadoutTriggerDataFrame::seqNumber() const 
{
  return m_seqNumber;
}

inline void DayaBay::ReadoutTriggerDataFrame::setSeqNumber(int value) 
{
  m_seqNumber = value;
}

inline int DayaBay::ReadoutTriggerDataFrame::readoutType() const 
{
  return m_readoutType;
}

inline void DayaBay::ReadoutTriggerDataFrame::setReadoutType(int value) 
{
  m_readoutType = value;
}

inline const DayaBay::Trigger::TriggerType_t& DayaBay::ReadoutTriggerDataFrame::triggerType() const 
{
  return m_triggerType;
}

inline void DayaBay::ReadoutTriggerDataFrame::setTriggerType(const DayaBay::Trigger::TriggerType_t& value) 
{
  m_triggerType = value;
}

inline const TimeStamp& DayaBay::ReadoutTriggerDataFrame::triggerTime() const 
{
  return m_triggerTime;
}

inline void DayaBay::ReadoutTriggerDataFrame::setTriggerTime(const TimeStamp& value) 
{
  m_triggerTime = value;
}

inline unsigned int DayaBay::ReadoutTriggerDataFrame::cycle() const 
{
  return m_cycle;
}

inline void DayaBay::ReadoutTriggerDataFrame::setCycle(unsigned int value) 
{
  m_cycle = value;
}

inline int DayaBay::ReadoutTriggerDataFrame::nhit() const 
{
  return m_nhit;
}

inline void DayaBay::ReadoutTriggerDataFrame::setNhit(int value) 
{
  m_nhit = value;
}

inline int DayaBay::ReadoutTriggerDataFrame::esumAdc() const 
{
  return m_esumAdc;
}

inline void DayaBay::ReadoutTriggerDataFrame::setEsumAdc(int value) 
{
  m_esumAdc = value;
}

inline int DayaBay::ReadoutTriggerDataFrame::esumComp() const 
{
  return m_esumComp;
}

inline void DayaBay::ReadoutTriggerDataFrame::setEsumComp(int value) 
{
  m_esumComp = value;
}

inline int DayaBay::ReadoutTriggerDataFrame::crossSource() const 
{
  return m_crossSource;
}

inline void DayaBay::ReadoutTriggerDataFrame::setCrossSource(int value) 
{
  m_crossSource = value;
}

inline bool DayaBay::ReadoutTriggerDataFrame::isRpc() const 
{
  return m_isRpc;
}

inline void DayaBay::ReadoutTriggerDataFrame::setIsRpc(bool value) 
{
  m_isRpc = value;
}


#endif ///ReadoutEvent_ReadoutTriggerDataFrame_H