[1] | 1 | //-------------------------------------------------------------------------- |
---|
| 2 | #ifndef HEPMC_IO_BASECLASS_H |
---|
| 3 | #define HEPMC_IO_BASECLASS_H |
---|
| 4 | |
---|
| 5 | ////////////////////////////////////////////////////////////////////////// |
---|
| 6 | // Matt.Dobbs@Cern.CH, November 1999, refer to: |
---|
| 7 | // M. Dobbs and J.B. Hansen, "The HepMC C++ Monte Carlo Event Record for |
---|
| 8 | // High Energy Physics", Computer Physics Communications (to be published). |
---|
| 9 | // |
---|
| 10 | // event input/output base class |
---|
| 11 | ////////////////////////////////////////////////////////////////////////// |
---|
| 12 | // |
---|
| 13 | // class from which all input/output classes shall inherit from. |
---|
| 14 | // i.e.: if you want to write events to hbook ntuples, |
---|
| 15 | // then inherit from this class and re-define read_event() |
---|
| 16 | // and write_event() |
---|
| 17 | // |
---|
| 18 | // (Possible extension: Could make this an input iterator) |
---|
| 19 | // |
---|
| 20 | |
---|
| 21 | #include <iostream> |
---|
| 22 | #include "HepMC/GenEvent.h" |
---|
| 23 | |
---|
| 24 | namespace HepMC { |
---|
| 25 | |
---|
| 26 | //! all input/output classes inherit from IO_BaseClass |
---|
| 27 | |
---|
| 28 | /// |
---|
| 29 | /// \class IO_BaseClass |
---|
| 30 | /// If you want to write a new IO class, |
---|
| 31 | /// then inherit from this class and re-define read_event() |
---|
| 32 | /// and write_event() |
---|
| 33 | /// |
---|
| 34 | class IO_BaseClass { |
---|
| 35 | public: |
---|
| 36 | virtual ~IO_BaseClass() {} |
---|
| 37 | |
---|
| 38 | /// write this GenEvent |
---|
| 39 | virtual void write_event( const GenEvent* ) =0; |
---|
| 40 | /// fill this GenEvent |
---|
| 41 | virtual bool fill_next_event( GenEvent* ) =0; |
---|
| 42 | /// write output to ostr |
---|
| 43 | virtual void print( std::ostream& ostr = std::cout ) const; |
---|
| 44 | // |
---|
| 45 | // the read_next_event() differs from |
---|
| 46 | // the fill_***() methods in that it creates a new event |
---|
| 47 | // before calling the corresponding fill_*** method |
---|
| 48 | // (they are not intended to be over-ridden) |
---|
| 49 | GenEvent* read_next_event(); //!< do not over-ride |
---|
| 50 | // |
---|
| 51 | // The overloaded stream operators >>,<< are identical to |
---|
| 52 | // read_next_event and write_event methods respectively. |
---|
| 53 | // (or read_particle_data_table and write_particle_data_table) |
---|
| 54 | // the event argument for the overloaded stream operators is a pointer, |
---|
| 55 | // which is passed by reference. |
---|
| 56 | // i.e. GenEvent* evt; |
---|
| 57 | // io >> evt; |
---|
| 58 | // will give the expected result. |
---|
| 59 | // (note: I don't see any reason to have separate const and non-const |
---|
| 60 | // versions of operator<<, but the pedantic ansi standard insists |
---|
| 61 | // on it) |
---|
| 62 | /// the same as read_next_event |
---|
| 63 | virtual GenEvent*& operator>>( GenEvent*& ); |
---|
| 64 | /// the same as write_event |
---|
| 65 | virtual const GenEvent*& operator<<( const GenEvent*& ); |
---|
| 66 | /// the same as write_event |
---|
| 67 | virtual GenEvent*& operator<<( GenEvent*& ); |
---|
| 68 | }; |
---|
| 69 | |
---|
| 70 | ////////////// |
---|
| 71 | // Inlines // |
---|
| 72 | ////////////// |
---|
| 73 | |
---|
| 74 | inline GenEvent* IO_BaseClass::read_next_event() { |
---|
| 75 | /// creates a new event and fills it by calling |
---|
| 76 | /// the sister method read_next_event( GenEvent* ) |
---|
| 77 | // |
---|
| 78 | // 1. create an empty event container |
---|
| 79 | GenEvent* evt = new GenEvent(); |
---|
| 80 | // 2. fill the evt container - if the read is successful, return the |
---|
| 81 | // pointer, otherwise return null and delete the evt |
---|
| 82 | if ( fill_next_event( evt ) ) return evt; |
---|
| 83 | // note: the below delete is only reached if read fails |
---|
| 84 | // ... thus there is not much overhead in new then delete |
---|
| 85 | // since this statement is rarely reached |
---|
| 86 | delete evt; |
---|
| 87 | return 0; |
---|
| 88 | } |
---|
| 89 | |
---|
| 90 | inline void IO_BaseClass::print( std::ostream& ostr ) const { |
---|
| 91 | ostr << "IO_BaseClass: abstract parent I/O class. " << std::endl; |
---|
| 92 | } |
---|
| 93 | |
---|
| 94 | inline GenEvent*& IO_BaseClass::operator>>( GenEvent*& evt ){ |
---|
| 95 | evt = read_next_event(); |
---|
| 96 | return evt; |
---|
| 97 | } |
---|
| 98 | |
---|
| 99 | inline const GenEvent*& IO_BaseClass::operator<<( |
---|
| 100 | const GenEvent*& evt ) { |
---|
| 101 | write_event( evt ); |
---|
| 102 | return evt; |
---|
| 103 | } |
---|
| 104 | |
---|
| 105 | inline GenEvent*& IO_BaseClass::operator<<( GenEvent*& evt ) { |
---|
| 106 | write_event( evt ); |
---|
| 107 | return evt; |
---|
| 108 | } |
---|
| 109 | |
---|
| 110 | } // HepMC |
---|
| 111 | |
---|
| 112 | #endif // HEPMC_IO_BASECLASS_H |
---|
| 113 | //-------------------------------------------------------------------------- |
---|
| 114 | |
---|
| 115 | |
---|
| 116 | |
---|