Reader.hh

Go to the documentation of this file.

#ifndef READER_h
#define READER_h

#include <zlib.h>
#include <string>
#include "RawEvent.hh"
#include "VParameterNode.hh"


class Reader{
public:
  Reader(const std::string& filename);
  ~Reader();
public:
  //access functions
  bool IsOk(){ return _ok; } 
  bool eof(){ return _end_last_file || ( gzeof(_fin) && OpenNextFile() ); }
  //All event getters return null pointer if error
  RawEventPtr GetNextEvent(bool read_header = true);   
  RawEventPtr GetEventWithIndex(int index);
  RawEventPtr GetEventWithID(uint32_t id);
  RawEventPtr GetLastEvent();
  int GetCurrentIndex(){ return _current_index; }
  bool GetAssociatedParameter(VParameterNode* par, 
                              std::string key="");

  // headers for version control
public:
  static const uint32_t magic_number = 0xdec0ded1; 
  static const uint32_t latest_global_version = 1;
  static const uint32_t latest_event_version = 1;
  struct global_header{
    uint32_t magic_num_check;
    uint32_t global_header_size;
    uint32_t global_header_version;
    uint32_t event_header_size; 
    uint32_t event_header_version;
    uint32_t file_size;
    uint32_t start_time;
    uint32_t end_time;
    uint32_t run_id;
    uint32_t file_index;
    uint32_t nevents;
    uint32_t event_id_min;
    uint32_t event_id_max;
    global_header() : magic_num_check(magic_number), 
                      global_header_size(sizeof(global_header)),
                      global_header_version(1),
                      event_header_size(sizeof(event_header)),
                      event_header_version(1) {}
    
  };
  struct event_header{
    uint32_t event_size; 
    uint32_t event_id;
    uint32_t timestamp;
    uint32_t nblocks;
    event_header() : event_size(sizeof(event_header)){}
    void reset(){ event_size=0; event_id=0; timestamp=0; nblocks=0; }
  };

  struct datablock_header{
    uint32_t total_blocksize_disk;
    uint32_t datasize;
    uint32_t type;
  };
  
  struct event_header_v0{
    uint32_t event_size;
    uint32_t event_id;
    uint32_t timestamp;
  };

private:
  const std::string _filename; 
  gzFile _fin; 
  bool _ok; 
  long _current_index;  
  long _current_id; 
  global_header _ghead; 
  event_header _ehead; 
  RawEventPtr _current_event; 
  uint32_t _current_file_index; 
  std::string _current_file_name; 
  static const uint32_t _unset_file_index = 0xFFFFFFFF;
  bool _end_last_file; 
  
  bool ErrorCheck(int bytes_read, int bytes_requested); 
  
  int Reset();
  int ReadNextHeader();
  z_off_t SkipNextEvent(bool skip_header = true);
  
  int OpenNextFile();
  int CloseCurrentFile();
  
};

#endif