In This Package:

RawDataReader.cc

Go to the documentation of this file.

#include "RawData/RawDataReader.h"
#include "RawData/RawRecord.h"
#include "RawData/RawRecordFormat.h"
#include "RawData/RawData.h"
#include "RawData/RawDataFormat.h"
#include "RawData/IFStream.h"
#include "RawData/RRawStream.h"

#include <fstream>
#include <iostream>

#include <cstdlib> 

DayaBay::RawDataReader::RawDataReader()
  : m_input(0),
    m_buffer(0),
    m_size(0),
    m_version(0)
{
  // Default constructor
}

DayaBay::RawDataReader::~RawDataReader()
{
  // Destructor
  if(m_buffer) free(m_buffer);
  m_buffer=0;
  this->close();
  m_size=0;
  m_version=0;
}

bool DayaBay::RawDataReader::open(const char* filename)
{
  // Open the file for reading
  // Return true on success, false on failure
  string fname = filename;
  string ext = fname.substr(fname.size()-5,5);
  
  IInputStream *input = 0;

  if (ext == ".data") {
    input = new IFStream(filename);
  }

  if (ext == ".rraw") {
    input = new RRawStream(filename);
  }

  if (!input || !input->is_open()) return false;
  this->close();
  m_input = input;
    
  return true;
}

void DayaBay::RawDataReader::close()
{
  if (m_input) delete m_input;
  m_input = 0;
}

bool DayaBay::RawDataReader::read(unsigned int size,
                                  unsigned int offset /*=0*/)
{
  // Read data from stream into buffer
  // size = size of data to read (in integer-size blocks)
  // offset = size of data to read (in integer-size blocks)

  if(!m_input) return false;

  if(!m_buffer){
    // Initialize buffer
    m_size = 0;
    static const unsigned int minBufferSize = 16000;
    unsigned int bufSize = minBufferSize;
    if( bufSize < size+offset ) bufSize = size+offset;
    m_buffer = new unsigned int[bufSize];
    if(!m_buffer) return false;
    m_size = bufSize;
  }else if(m_size < (size+offset)){
    // Increase buffer size
    m_size = 0;
    m_buffer = (unsigned int*)realloc(m_buffer, 
                                      (size+offset)*sizeof(unsigned int));
    if(!m_buffer) return false;
    m_size = size+offset;
  }

  // Read input data into buffer
  m_input->read( (char*)(m_buffer+offset), size*sizeof(unsigned int) );
  if(!m_input->good()) return false;
  return true;
}

DayaBay::RawRecord* DayaBay::RawDataReader::nextRecord()
{
  // Read the next record from the input stream

  // First read type, size information
  bool readOk = this->read(RawRecord::minimumSize());
  if( !readOk ){
    std::cerr << "DayaBay::RawDataReader::nextRecord(): "
              << "Failed to read start of next record." << std::endl;
    return 0;
  }
  DayaBay::RawRecord record(m_buffer);
  // Check block size
  if(record.size() > record.minimumSize() ){
    // Read the rest of this data block
    readOk = this->read(record.size()
                        -RawRecord::minimumSize(), 
                        RawRecord::minimumSize());
    if( !readOk ){
      std::cerr << "DayaBay::RawDataReader::nextRecord(): "
                << "Failed to complete read of next record." << std::endl;
      return 0;
    }
  }

  DayaBay::RawRecord* fullRecord = 
    DayaBay::RawRecord::makeNewRecord(m_buffer, m_version);

  // Additional actions for specific data records
  if( fullRecord->isFileStart() ){
    // Process file start information
    bool ok = this->processFileStart();
    if( !ok ){
      delete fullRecord;
      return 0;
    }
  }else if( fullRecord->isDataSeparator() ){
    // Process data separators
    bool ok = this->processDataSeparator();
    if( !ok ){
      delete fullRecord;
      return 0;
    }
  }

  return fullRecord;
}

DayaBay::RawData* DayaBay::RawDataReader::nextData()
{
  // Read until the next data payload is found, and return it
  DayaBay::RawData* data = 0;
  while(!data){
    DayaBay::RawRecord* record = this->nextRecord();
    if( !record ) return 0;
    if( record->isDataSeparator() ){
      // Found a data payload
      DayaBay::RawDataSeparator* dataSeparator = 
        dynamic_cast<DayaBay::RawDataSeparator*>(record);
      if( !dataSeparator ) return 0;
      data = dataSeparator->data();
    }
    delete record;
  }
  return data;
}

DayaBay::RawEvent* DayaBay::RawDataReader::nextEvent()
{
  // Read until the next event data is found, and return it
  DayaBay::RawData* data = 0;
  while( (data = this->nextData()) ){
    if( data->isEventType() ){
      // Found an event data payload
      return dynamic_cast<DayaBay::RawEvent*>(data);
    }
    delete data;
  }
  return 0;
}


bool DayaBay::RawDataReader::processFileStart(){
  // Catch the file version and keep track of it in the reader
  // Pass this information on to other data records
  DayaBay::RawFileStart fileStart(m_buffer);
  m_version = fileStart.version();
  return true;
}

bool DayaBay::RawDataReader::processDataSeparator(){
  // Catch data separators, and read payload data block as well
  DayaBay::RawDataSeparator dataSeparator(m_buffer, m_version);
  unsigned int bytes = dataSeparator.blockSize();
  unsigned int lines = (bytes+sizeof(unsigned int)-1)/sizeof(unsigned int);
  return this->read(lines /*size*/, dataSeparator.size() /*offset*/);
}


// Local Variables: **
// c-basic-offset:2 **
// indent-tabs-mode:nil **
// End: **

---