In This Package:

SimTrigCommand.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 SimTrigEvent_SimTrigCommand_H
#define SimTrigEvent_SimTrigCommand_H 1

// Include files
#include "Conventions/Trigger.h"
#include "Conventions/Detectors.h"
#include "GaudiKernel/boost_allocator.h"
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations

  class SimTrigCommand
  {
  public:

  SimTrigCommand(const DayaBay::Detector& in_det,
                   const DayaBay::Trigger::TriggerType_t& in_type,
                   unsigned int in_cycle,
                   int in_nhit=0,
                   int in_esum=0,
                   int in_esumComp=0) : m_detector(in_det),
                                                                               m_type(in_type),
                                                                               m_clockCycle(in_cycle),
                                                                               m_nhit(in_nhit),
                                                                               m_esumAdc(in_esum),
                                                                               m_esumComp(in_esumComp) {}
  
    SimTrigCommand() : m_detector(),
                       m_type(),
                       m_clockCycle(0),
                       m_nhit(0),
                       m_esumAdc(0),
                       m_esumComp(0) {}
  
    virtual ~SimTrigCommand() {}
  
    std::ostream& fillStream(std::ostream& s) const;
  
    static bool LessThan(DayaBay::SimTrigCommand* d1,
                         DayaBay::SimTrigCommand* d2);
  
  const DayaBay::Detector& detector() const;
  
  void setDetector(const DayaBay::Detector& value);
  
  const DayaBay::Trigger::TriggerType_t& type() const;
  
  void setType(const DayaBay::Trigger::TriggerType_t& value);
  
  unsigned int clockCycle() const;
  
  void setClockCycle(unsigned int value);
  
  int nhit() const;
  
  void setNhit(int value);
  
  int esumAdc() const;
  
  void setEsumAdc(int value);
  
  int esumComp() const;
  
  void setEsumComp(int value);
  
  
  #ifndef GOD_NOALLOC
    static void* operator new ( size_t size )
    {
      return ( sizeof(SimTrigCommand) == size ? 
               boost::singleton_pool<SimTrigCommand, sizeof(SimTrigCommand)>::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<SimTrigCommand, sizeof(SimTrigCommand)>::is_from(p) ?
      boost::singleton_pool<SimTrigCommand, sizeof(SimTrigCommand)>::free(p) :
      ::operator delete(p);
    }
  
    static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
  #endif
  protected:

  private:

    DayaBay::Detector               m_detector;   
    DayaBay::Trigger::TriggerType_t m_type;       
    unsigned int                    m_clockCycle; 
    int                             m_nhit;       
    int                             m_esumAdc;    
    int                             m_esumComp;   
  
  }; // class SimTrigCommand

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

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

// Including forward declarations

inline const DayaBay::Detector& DayaBay::SimTrigCommand::detector() const 
{
  return m_detector;
}

inline void DayaBay::SimTrigCommand::setDetector(const DayaBay::Detector& value) 
{
  m_detector = value;
}

inline const DayaBay::Trigger::TriggerType_t& DayaBay::SimTrigCommand::type() const 
{
  return m_type;
}

inline void DayaBay::SimTrigCommand::setType(const DayaBay::Trigger::TriggerType_t& value) 
{
  m_type = value;
}

inline unsigned int DayaBay::SimTrigCommand::clockCycle() const 
{
  return m_clockCycle;
}

inline void DayaBay::SimTrigCommand::setClockCycle(unsigned int value) 
{
  m_clockCycle = value;
}

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

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

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

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

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

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


#endif 

---