In This Package:

RawLtbFrame.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 RawEvent_RawLtbFrame_H
#define RawEvent_RawLtbFrame_H 1

// Include files
#include "Context/TimeStamp.h"
#include "GaudiKernel/boost_allocator.h"
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations

  class RawLtbFrame
  {
  public:

    RawLtbFrame() : m_accStat(false),
                    m_GPSValid(false),
                    m_timestampType(false),
                    m_clockSystemValid(false),
                    m_iltSn(0),
                    m_rot(0),
                    m_triggerSrc(0),
                    m_nanoSecondLow(0),
                    m_nanoSecondHigh(0),
                    m_accumulationLow(0),
                    m_accumulationHigh(0),
                    m_hsum(0),
                    m_esumComp(0),
                    m_esumADC(0),
                    m_blockedValidTrigger(0),
                    m_crossTriggerSrc(0),
                    m_feeBufferStat(false),
                    m_ltbBufferStat(false),
                    m_timestamp(0) {}
  
    virtual ~RawLtbFrame() {}
  
   virtual std::ostream& fillStream(std::ostream& s) const;
  
  bool accStat() const;
  
  void setAccStat(bool value);
  
  bool gpsValid() const;
  
  void setGPSValid(bool value);
  
  bool timestampType() const;
  
  void setTimestampType(bool value);
  
  bool clockSystemValid() const;
  
  void setClockSystemValid(bool value);
  
  int iltSn() const;
  
  void setIltSn(int value);
  
  int rot() const;
  
  void setRot(int value);
  
  int triggerSrc() const;
  
  void setTriggerSrc(int value);
  
  int nanoSecondLow() const;
  
  void setNanoSecondLow(int value);
  
  int nanoSecondHigh() const;
  
  void setNanoSecondHigh(int value);
  
  int accumulationLow() const;
  
  void setAccumulationLow(int value);
  
  int accumulationHigh() const;
  
  void setAccumulationHigh(int value);
  
  int hsum() const;
  
  void setHsum(int value);
  
  int esumComp() const;
  
  void setEsumComp(int value);
  
  int esumADC() const;
  
  void setEsumADC(int value);
  
  int blockedValidTrigger() const;
  
  void setBlockedValidTrigger(int value);
  
  int crossTriggerSrc() const;
  
  void setCrossTriggerSrc(int value);
  
  bool feeBufferStat() const;
  
  void setFeeBufferStat(bool value);
  
  bool ltbBufferStat() const;
  
  void setLtbBufferStat(bool value);
  
  const TimeStamp& timestamp() const;
  
  void setTimestamp(const TimeStamp& value);
  
  
  #ifndef GOD_NOALLOC
    static void* operator new ( size_t size )
    {
      return ( sizeof(RawLtbFrame) == size ? 
               boost::singleton_pool<RawLtbFrame, sizeof(RawLtbFrame)>::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<RawLtbFrame, sizeof(RawLtbFrame)>::is_from(p) ?
      boost::singleton_pool<RawLtbFrame, sizeof(RawLtbFrame)>::free(p) :
      ::operator delete(p);
    }
  
    static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
  #endif
  protected:

  private:

    bool      m_accStat;             
    bool      m_GPSValid;            
    bool      m_timestampType;       
    bool      m_clockSystemValid;    
    int       m_iltSn;               
    int       m_rot;                 
    int       m_triggerSrc;          
    int       m_nanoSecondLow;       
    int       m_nanoSecondHigh;      
    int       m_accumulationLow;     
    int       m_accumulationHigh;    
    int       m_hsum;                
    int       m_esumComp;            
    int       m_esumADC;             
    int       m_blockedValidTrigger; 
    int       m_crossTriggerSrc;     
    bool      m_feeBufferStat;       
    bool      m_ltbBufferStat;       
    TimeStamp m_timestamp;           
  
  }; // class RawLtbFrame

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

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

// Including forward declarations

inline std::ostream& DayaBay::RawLtbFrame::fillStream(std::ostream& s) const
{
  char l_accStat = (m_accStat) ? 'T' : 'F';
  char l_GPSValid = (m_GPSValid) ? 'T' : 'F';
  char l_timestampType = (m_timestampType) ? 'T' : 'F';
  char l_clockSystemValid = (m_clockSystemValid) ? 'T' : 'F';
  char l_feeBufferStat = (m_feeBufferStat) ? 'T' : 'F';
  char l_ltbBufferStat = (m_ltbBufferStat) ? 'T' : 'F';
  s << "{ " << "accStat :       " << l_accStat << std::endl
            << "GPSValid :      " << l_GPSValid << std::endl
            << "timestampType : " << l_timestampType << std::endl
            << "clockSystemValid :      " << l_clockSystemValid << std::endl
            << "iltSn : " << m_iltSn << std::endl
            << "rot :   " << m_rot << std::endl
            << "triggerSrc :    " << m_triggerSrc << std::endl
            << "nanoSecondLow : " << m_nanoSecondLow << std::endl
            << "nanoSecondHigh :        " << m_nanoSecondHigh << std::endl
            << "accumulationLow :       " << m_accumulationLow << std::endl
            << "accumulationHigh :      " << m_accumulationHigh << std::endl
            << "hsum :  " << m_hsum << std::endl
            << "esumComp :      " << m_esumComp << std::endl
            << "esumADC :       " << m_esumADC << std::endl
            << "blockedValidTrigger :   " << m_blockedValidTrigger << std::endl
            << "crossTriggerSrc :       " << m_crossTriggerSrc << std::endl
            << "feeBufferStat : " << l_feeBufferStat << std::endl
            << "ltbBufferStat : " << l_ltbBufferStat << std::endl
            << "timestamp :     " << m_timestamp << std::endl << " }";
  return s;
}


inline bool DayaBay::RawLtbFrame::accStat() const 
{
  return m_accStat;
}

inline void DayaBay::RawLtbFrame::setAccStat(bool value) 
{
  m_accStat = value;
}

inline bool DayaBay::RawLtbFrame::gpsValid() const 
{
  return m_GPSValid;
}

inline void DayaBay::RawLtbFrame::setGPSValid(bool value) 
{
  m_GPSValid = value;
}

inline bool DayaBay::RawLtbFrame::timestampType() const 
{
  return m_timestampType;
}

inline void DayaBay::RawLtbFrame::setTimestampType(bool value) 
{
  m_timestampType = value;
}

inline bool DayaBay::RawLtbFrame::clockSystemValid() const 
{
  return m_clockSystemValid;
}

inline void DayaBay::RawLtbFrame::setClockSystemValid(bool value) 
{
  m_clockSystemValid = value;
}

inline int DayaBay::RawLtbFrame::iltSn() const 
{
  return m_iltSn;
}

inline void DayaBay::RawLtbFrame::setIltSn(int value) 
{
  m_iltSn = value;
}

inline int DayaBay::RawLtbFrame::rot() const 
{
  return m_rot;
}

inline void DayaBay::RawLtbFrame::setRot(int value) 
{
  m_rot = value;
}

inline int DayaBay::RawLtbFrame::triggerSrc() const 
{
  return m_triggerSrc;
}

inline void DayaBay::RawLtbFrame::setTriggerSrc(int value) 
{
  m_triggerSrc = value;
}

inline int DayaBay::RawLtbFrame::nanoSecondLow() const 
{
  return m_nanoSecondLow;
}

inline void DayaBay::RawLtbFrame::setNanoSecondLow(int value) 
{
  m_nanoSecondLow = value;
}

inline int DayaBay::RawLtbFrame::nanoSecondHigh() const 
{
  return m_nanoSecondHigh;
}

inline void DayaBay::RawLtbFrame::setNanoSecondHigh(int value) 
{
  m_nanoSecondHigh = value;
}

inline int DayaBay::RawLtbFrame::accumulationLow() const 
{
  return m_accumulationLow;
}

inline void DayaBay::RawLtbFrame::setAccumulationLow(int value) 
{
  m_accumulationLow = value;
}

inline int DayaBay::RawLtbFrame::accumulationHigh() const 
{
  return m_accumulationHigh;
}

inline void DayaBay::RawLtbFrame::setAccumulationHigh(int value) 
{
  m_accumulationHigh = value;
}

inline int DayaBay::RawLtbFrame::hsum() const 
{
  return m_hsum;
}

inline void DayaBay::RawLtbFrame::setHsum(int value) 
{
  m_hsum = value;
}

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

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

inline int DayaBay::RawLtbFrame::esumADC() const 
{
  return m_esumADC;
}

inline void DayaBay::RawLtbFrame::setEsumADC(int value) 
{
  m_esumADC = value;
}

inline int DayaBay::RawLtbFrame::blockedValidTrigger() const 
{
  return m_blockedValidTrigger;
}

inline void DayaBay::RawLtbFrame::setBlockedValidTrigger(int value) 
{
  m_blockedValidTrigger = value;
}

inline int DayaBay::RawLtbFrame::crossTriggerSrc() const 
{
  return m_crossTriggerSrc;
}

inline void DayaBay::RawLtbFrame::setCrossTriggerSrc(int value) 
{
  m_crossTriggerSrc = value;
}

inline bool DayaBay::RawLtbFrame::feeBufferStat() const 
{
  return m_feeBufferStat;
}

inline void DayaBay::RawLtbFrame::setFeeBufferStat(bool value) 
{
  m_feeBufferStat = value;
}

inline bool DayaBay::RawLtbFrame::ltbBufferStat() const 
{
  return m_ltbBufferStat;
}

inline void DayaBay::RawLtbFrame::setLtbBufferStat(bool value) 
{
  m_ltbBufferStat = value;
}

inline const TimeStamp& DayaBay::RawLtbFrame::timestamp() const 
{
  return m_timestamp;
}

inline void DayaBay::RawLtbFrame::setTimestamp(const TimeStamp& value) 
{
  m_timestamp = value;
}


#endif 

---