In This Package:

RunData.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 RunData_RunData_H
#define RunData_RunData_H 1

// Include files
#include "Context/TimeStamp.h"
#include "Conventions/Detectors.h"
#include "Conventions/RunType.h"
#include "Event/CalibSource.h"
#include "GaudiKernel/boost_allocator.h"
#include <vector>
#include <algorithm>
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations

  class RunData
  {
  public:

    typedef std::vector<DayaBay::Detector> DetectorContainer;
    typedef std::vector<DayaBay::CalibSource> CalibSources;
  
    RunData() : m_runNumber(0),
                m_runType(DayaBay::RunType::kUnknown),
                m_detectors(),
                m_startTime(0),
                m_endTime(0),
                m_calibSources() {}
  
    RunData(const RunData & rh);
  
     RunData & operator=(const RunData & rh);
  
    virtual ~RunData() {}
  
    bool hasDetector(const DayaBay::Detector& detector) const;
  
    bool hasSource(const DayaBay::CalibSourceId& sourceId) const;
  
    CalibSource* getSource(const DayaBay::CalibSourceId& sourceId);
  
    std::ostream& fillStream(std::ostream& s) const;
  
  int runNumber() const;
  
  void setRunNumber(int value);
  
  const DayaBay::RunType::RunType_t& runType() const;
  
  void setRunType(const DayaBay::RunType::RunType_t& value);
  
  const DetectorContainer& detectors() const;
  
  void setDetectors(const DetectorContainer& value);
  
  const TimeStamp& startTime() const;
  
  void setStartTime(const TimeStamp& value);
  
  const TimeStamp& endTime() const;
  
  void setEndTime(const TimeStamp& value);
  
  const CalibSources& calibSources() const;
  
  void setCalibSources(const CalibSources& value);
  
  
  #ifndef GOD_NOALLOC
    static void* operator new ( size_t size )
    {
      return ( sizeof(RunData) == size ? 
               boost::singleton_pool<RunData, sizeof(RunData)>::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<RunData, sizeof(RunData)>::is_from(p) ?
      boost::singleton_pool<RunData, sizeof(RunData)>::free(p) :
      ::operator delete(p);
    }
  
    static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
  #endif
  protected:

  private:

    int                         m_runNumber;    
    DayaBay::RunType::RunType_t m_runType;      
    DetectorContainer           m_detectors;    
    TimeStamp                   m_startTime;    
    TimeStamp                   m_endTime;      
    CalibSources                m_calibSources; 
  
  }; // class RunData

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

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

// Including forward declarations

inline DayaBay::RunData::RunData(const DayaBay::RunData & rh) : 
   m_runNumber( rh.m_runNumber ),
   m_runType( rh.m_runType ),
   m_detectors( rh.m_detectors ),
   m_startTime( rh.m_startTime ),
   m_endTime( rh.m_endTime ),
   m_calibSources( rh.m_calibSources )
   {}

inline DayaBay::RunData & DayaBay::RunData::operator=(const DayaBay::RunData & rh) {
  if ( this != &rh ) {
    m_runNumber    = rh.m_runNumber;
    m_runType      = rh.m_runType;
    m_detectors    = rh.m_detectors;
    m_startTime    = rh.m_startTime;
    m_endTime      = rh.m_endTime;
    m_calibSources = rh.m_calibSources;
  }
  return *this;
}

inline int DayaBay::RunData::runNumber() const 
{
  return m_runNumber;
}

inline void DayaBay::RunData::setRunNumber(int value) 
{
  m_runNumber = value;
}

inline const DayaBay::RunType::RunType_t& DayaBay::RunData::runType() const 
{
  return m_runType;
}

inline void DayaBay::RunData::setRunType(const DayaBay::RunType::RunType_t& value) 
{
  m_runType = value;
}

inline const DayaBay::RunData::DetectorContainer& DayaBay::RunData::detectors() const 
{
  return m_detectors;
}

inline void DayaBay::RunData::setDetectors(const DetectorContainer& value) 
{
  m_detectors = value;
}

inline const TimeStamp& DayaBay::RunData::startTime() const 
{
  return m_startTime;
}

inline void DayaBay::RunData::setStartTime(const TimeStamp& value) 
{
  m_startTime = value;
}

inline const TimeStamp& DayaBay::RunData::endTime() const 
{
  return m_endTime;
}

inline void DayaBay::RunData::setEndTime(const TimeStamp& value) 
{
  m_endTime = value;
}

inline const DayaBay::RunData::CalibSources& DayaBay::RunData::calibSources() const 
{
  return m_calibSources;
}

inline void DayaBay::RunData::setCalibSources(const CalibSources& value) 
{
  m_calibSources = value;
}

inline bool DayaBay::RunData::hasDetector(const DayaBay::Detector& detector) const 
{

          return (std::find(m_detectors.begin(), m_detectors.end(), detector)
                  != m_detectors.end());
        
}

inline bool DayaBay::RunData::hasSource(const DayaBay::CalibSourceId& sourceId) const 
{

            DayaBay::RunData::CalibSources::const_iterator srcIter, srcDone
               = m_calibSources.end();
            for (srcIter=m_calibSources.begin(); srcIter != srcDone; ++srcIter){
                if( (*srcIter).id() == sourceId ) return true;
            }
            return false;
        
}

inline DayaBay::CalibSource* DayaBay::RunData::getSource(const DayaBay::CalibSourceId& sourceId) 
{

            DayaBay::RunData::CalibSources::iterator srcIter, srcDone
               = m_calibSources.end();
            for (srcIter=m_calibSources.begin(); srcIter != srcDone; ++srcIter){
                if( (*srcIter).id() == sourceId ) return &(*srcIter);
            }
            return 0;
        
}


#endif 

---