source: HiSusy/trunk/hepmc/x86_64-slc5-gcc41-opt/include/HepMC/IO_BaseClass.h @ 1

Last change on this file since 1 was 1, checked in by zerwas, 11 years ago

first import of structure, PYTHIA8 and DELPHES

File size: 3.7 KB
Line 
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
24namespace 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
Note: See TracBrowser for help on using the repository browser.