EvtIdxHandler.cxx

Go to the documentation of this file.

#include "RawFile/EvtIdxHandler.h"
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <unistd.h>
using namespace std;
 
#define DefaultIdxBlockSize 512 * 1024
 
int            EvtIdxHandler::_nHandler = 0;
EvtIdxHandler* EvtIdxHandler::_instance = 0;
 
EvtIdxHandler* EvtIdxHandler::instance( const std::vector<std::string>& idxfnames ) {
  if ( _instance == 0 ) { _instance = new EvtIdxHandler( idxfnames ); }
 
  ++_nHandler;
 
  return _instance;
}
 
void EvtIdxHandler::release() {
  if ( _nHandler > 0 && --_nHandler == 0 )
  {
    delete _instance;
    _instance = 0;
  }
}
 
EvtIdxHandler::EvtIdxHandler( const std::vector<std::string>& idxfnames )
    : m_idxPos( 0 ), m_blockSize( DefaultIdxBlockSize ), m_fnames( idxfnames ) {
  m_EIdBlock = new uint32_t[m_blockSize];
  m_PosBlock = new uint32_t[m_blockSize];
 
  m_curFile = m_fnames.begin();
  init_idx();
}
 
EvtIdxHandler::EvtIdxHandler()
    : m_totEvt( 0 ), m_idxPos( -1 ), m_blockSize( DefaultIdxBlockSize ) {
  m_EIdBlock = new uint32_t[m_blockSize];
  m_PosBlock = new uint32_t[m_blockSize];
}
 
EvtIdxHandler::~EvtIdxHandler() {
  delete[] m_EIdBlock;
  delete[] m_PosBlock;
}
 
void EvtIdxHandler::next_file() {
  ++m_curFile;
 
  m_idxPos = 0;
  init_idx();
}
 
uint32_t EvtIdxHandler::nextPos( int nIgnore ) {
  m_idxPos += nIgnore;
  return m_PosBlock[m_idxPos++];
}
 
uint32_t EvtIdxHandler::findPosById( uint32_t evtId ) {
  while ( m_totEvt > m_idxPos )
  {
    if ( m_EIdBlock[m_idxPos] == evtId ) { return m_PosBlock[m_idxPos++]; }
    ++m_idxPos;
  }
  return 0;
}
 
void EvtIdxHandler::addPos( uint32_t evtId, uint32_t pos ) {
  ++m_totEvt;
 
  if ( m_totEvt > m_blockSize ) enlarge_block( m_totEvt );
 
  m_EIdBlock[m_totEvt - 1] = evtId;
  m_PosBlock[m_totEvt - 1] = pos;
}
 
void EvtIdxHandler::write( std::string fname ) {
  if ( m_idxPos >= 0 )
  {
    std::cerr << "[RawFile] Writing an EvtIdxHandler for reading !!!" << std::endl;
    exit( 1 );
  }
 
  m_fs.open( fname.c_str(), std::ios::out | std::ios::binary );
 
  uint32_t marker = EvtIdxHandler::IdxFileStartMarker();
  m_fs.write( (char*)&marker, sizeof( marker ) );
  m_fs.write( (char*)&m_totEvt, sizeof( m_totEvt ) );
 
  marker = EvtIdxHandler::IdxIdBlockMarker();
  m_fs.write( (char*)&marker, sizeof( marker ) );
  m_fs.write( (char*)m_EIdBlock, m_totEvt * sizeof( uint32_t ) );
 
  marker = EvtIdxHandler::IdxPosBlockMarker();
  m_fs.write( (char*)&marker, sizeof( marker ) );
  m_fs.write( (char*)m_PosBlock, m_totEvt * sizeof( uint32_t ) );
 
  if ( !m_fs.good() )
  {
    std::cerr << "[RawFile] Error writing IDX file: " << fname << std::endl;
    exit( 1 );
  }
 
  m_fs.close();
 
  std::cout << "[RawFile] Written IDX file: " << fname << std::endl;
 
  m_totEvt = 0;
}
 
void EvtIdxHandler::init_idx() {
  if ( access( m_curFile->c_str(), F_OK ) < 0 )
  {
    std::cerr << "[RawFile] Invalid IDX file: " << *m_curFile << std::endl;
    exit( 1 );
  }
 
  std::cout << "[RawFile] Initialize IDX with file: " << *m_curFile << std::endl;
 
  m_fs.open( m_curFile->c_str(), std::ios::in | std::ios::binary );
 
  uint32_t marker;
 
  m_fs.read( (char*)&marker, sizeof( marker ) );
  if ( marker != EvtIdxHandler::IdxFileStartMarker() )
  {
    std::cerr << "[RawFile] Wrong IdxFileStartMarker!" << std::endl;
    exit( 1 );
  }
 
  m_fs.read( (char*)&m_totEvt, sizeof( m_totEvt ) );
 
  if ( m_totEvt > m_blockSize ) enlarge_block( m_totEvt );
 
  m_fs.read( (char*)&marker, sizeof( marker ) );
  if ( marker != EvtIdxHandler::IdxIdBlockMarker() )
  {
    std::cerr << "[RawFile] Wrong IdxIdBlockMarker!" << std::endl;
    exit( 1 );
  }
 
  m_fs.read( (char*)m_EIdBlock, m_totEvt * sizeof( uint32_t ) );
 
  m_fs.read( (char*)&marker, sizeof( marker ) );
  if ( marker != EvtIdxHandler::IdxPosBlockMarker() )
  {
    std::cerr << "[RawFile] Wrong IdxPosBlockMarker!" << std::endl;
    exit( 1 );
  }
 
  m_fs.read( (char*)m_PosBlock, m_totEvt * sizeof( uint32_t ) );
 
  if ( !m_fs.good() )
  {
    std::cerr << "[RawFile] Error occured while initialize the IDX file!" << std::endl;
    exit( 1 );
  }
 
  m_fs.close();
}
 
void EvtIdxHandler::enlarge_block( int min_size ) {
  int _initSize = m_blockSize;
  while ( min_size > m_blockSize ) { m_blockSize *= 2; }
 
  uint32_t* _EIdBlock = new uint32_t[m_blockSize];
  uint32_t* _PosBlock = new uint32_t[m_blockSize];
 
  memcpy( (void*)_EIdBlock, (const void*)m_EIdBlock, sizeof( uint32_t ) * _initSize );
  memcpy( (void*)_PosBlock, (const void*)m_PosBlock, sizeof( uint32_t ) * _initSize );
 
  delete[] m_EIdBlock;
  delete[] m_PosBlock;
 
  m_EIdBlock = _EIdBlock;
  m_PosBlock = _PosBlock;
}