LCReader.h

Go to the documentation of this file.

#ifndef MT_LCREADER_H
#define MT_LCREADER_H 1

// -- std headers
#include <string>
#include <vector>
#include <fstream>
#include <memory>

// -- lcio headers
#include "MT/Types.h"
#include "MT/LCReaderListener.h"
#include "LCIOSTLTypes.h"
#include "LCIOTypes.h"
#include "EVENT/LCIO.h"

// need to make forward declaration to 
// avoid lcio dependencies to include directly sio headers

namespace sio {
  class buffer ;
}

namespace SIO {
  class LCIORandomAccessMgr ;
  class SIOHandlerMgr ;
}

namespace MT {

class LCReader {
private:
  // No copy
  LCReader(const LCReader&) = delete;
  LCReader& operator=(const LCReader&) = delete;

public:
  static constexpr int directAccess =  0x00000001 << 0  ;
  static constexpr int lazyUnpack =  0x00000002 << 0  ;

public:
  ~LCReader() = default;

  LCReader( int lcReaderFlag ) ;

  void open( const std::string & filename );

  void open( const std::vector<std::string> & filenames ) ;

  std::unique_ptr<EVENT::LCRunHeader> readNextRunHeader( int accessMode = EVENT::LCIO::READ_ONLY ) ;

  std::unique_ptr<EVENT::LCEvent> readNextEvent( int accessMode = EVENT::LCIO::READ_ONLY ) ;

  int getNumberOfEvents() ;

  int getNumberOfRuns() ;

  void getRuns( EVENT::IntVec & runs ) ;

  void getEvents( EVENT::IntVec & events ) ;

  void setReadCollectionNames( const std::vector<std::string> & colnames ) ;

  void skipNEvents( int n ) ;

  std::unique_ptr<EVENT::LCRunHeader> readRunHeader( int runNumber , int accessMode = EVENT::LCIO::READ_ONLY ) ;

  std::unique_ptr<EVENT::LCEvent> readEvent( int runNumber, int evtNumber , int accessMode = EVENT::LCIO::READ_ONLY ) ;

  void close() ;

  void readStream( const LCReaderListenerList & listeners ) ;

  void readStream( const LCReaderListenerList & listeners , int maxRecord ) ;

  void readNextRecord( const LCReaderListenerList & listeners ) ;

  void readStream( LCReaderListener *listener ) ;

  void readStream( LCReaderListener *listener , int maxRecord ) ;

  void readNextRecord( LCReaderListener *listener ) ;

private:
  // void readRecord( const sio::record_map &records , sio::record_read_result &readResult ) ;
  void postProcessEvent( EVENT::LCEvent *evt ) ;
  void getEventMap() ;

private:
  std::ifstream                               _stream {} ;
  std::shared_ptr<sio::buffer>                _rawBuffer {nullptr} ; //{1*sio::mbyte} ;
  std::shared_ptr<sio::buffer>                _compBuffer {nullptr} ; //{2*sio::mbyte} ;
  std::shared_ptr<SIO::SIOHandlerMgr>         _eventHandlerMgr {nullptr} ;
  bool                                        _readEventMap {false} ;
  bool                                        _lazyUnpack {false} ;
  std::vector<std::string>                    _myFilenames {} ;
  std::vector<std::string>                    _readCollectionNames {} ;
  unsigned int                                _currentFileIndex {0} ;
  std::shared_ptr<SIO::LCIORandomAccessMgr>   _raMgr {nullptr} ;
  std::size_t                                 _bufferMaxSize {0} ;
}; // class

} // namespace MT

#endif /* ifndef MT_LCREADER_H */