Event.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#ifndef GAUDIEXAMPLES_EVENT_H
#define GAUDIEXAMPLES_EVENT_H 1
 
// Include files
#include <GaudiKernel/DataObject.h>
#include <GaudiKernel/Kernel.h>
#include <GaudiKernel/SmartRefVector.h>
#include <GaudiKernel/StreamBuffer.h>
#include <GaudiKernel/Time.h>
#include <iostream>
 
namespace Gaudi {
  namespace Examples {
 
    class Collision;
 
    // CLID definition
    static const CLID& CLID_Event = 110;
 
    class GAUDI_API Event : public DataObject {
 
    public:
      Event();
 
      const CLID&        clID() const override { return classID(); }
      static const CLID& classID() { return CLID_Event; }
 
      int event() const { return m_event; }
      void setEvent( int value ) { m_event = value; }
 
      int run() const { return m_run; }
      void setRun( int value ) { m_run = value; }
 
      const Gaudi::Time& time() const { return m_time; }
      void setTime( const Gaudi::Time& value ) { m_time = value; }
 
      const SmartRefVector<Collision>& collisions() const;
 
      void addCollision( Collision* vtx );
 
      void removeCollision( Collision* vtx );
 
      virtual StreamBuffer& serialize( StreamBuffer& s ) const;
      virtual StreamBuffer& serialize( StreamBuffer& s );
 
      std::ostream& fillStream( std::ostream& s ) const override;
 
    private:
      int m_event{ 0 };
      int m_run{ 0 };
      Gaudi::Time m_time;
 
      SmartRefVector<Collision> m_collisions;
    };
  } // namespace Examples
} // namespace Gaudi
 
#include "Collision.h"
 
namespace Gaudi {
  namespace Examples {
 
    //
    // Inline code must be outside the class definition
    //
 
    inline StreamBuffer& Event::serialize( StreamBuffer& s ) const {
      return s << m_event << m_run << m_time << m_collisions( this );
    }
 
    inline StreamBuffer& Event::serialize( StreamBuffer& s ) {
      return s >> m_event >> m_run >> m_time >> m_collisions( this );
    }
 
    inline std::ostream& Event::fillStream( std::ostream& s ) const {
      return s << "class Event :"
               << "\n    Event number = " << std::setw( 12 ) << m_event << "\n    Run number   = " << std::setw( 12 )
               << m_run << "\n    Time         = " << m_time;
    }
 
    inline const SmartRefVector<Collision>& Event::collisions() const { return m_collisions; }
 
    inline void Event::addCollision( Collision* c ) { m_collisions.push_back( SmartRef<Collision>( c ) ); }
 
    inline void Event::removeCollision( Collision* c ) {
      for ( auto i = m_collisions.begin(); i != m_collisions.end(); ++i ) {
        if ( i->target() == c ) {
          m_collisions.erase( i );
          return;
        }
      }
    }
 
    inline std::ostream& operator<<( std::ostream& s, const Event& obj ) { return obj.fillStream( s ); }
  } // namespace Examples
} // namespace Gaudi
#endif // GAUDIEXAMPLES_EVENT_H