RecordFromFStream.cc

Go to the documentation of this file.

#include "RawRecordPool/RecordFromFStream.h"
#include "RawRecordPool/RecordBuffer.h"
#include "RawRecordPool/RawRecordPoolUtil.h"
#include <cstdlib>
#include <iostream>
#include <cstring>

using DybDaq::RecordFromFStream;
using DybDaq::RecordBuffer;

RecordFromFStream::RecordFromFStream()
    : m_block(0),
      m_limit(64*1024),
      m_preRead(16)  //4*sizeof(uint32_t) = 16 bytes
{
    m_block = new char[m_limit];
#ifdef RPC_ERROR_DEBUG
    m_debug = RPC_ERROR_DEBUG;
#endif
}

RecordFromFStream::~RecordFromFStream()
{
    if ( m_block !=  0 ) delete [] m_block;
    if ( m_fs.is_open() ) m_fs.close();
}

bool RecordFromFStream::open(const std::string& fname)
{
    if ( m_fs.is_open() ) m_fs.close();

    if ( access( fname.c_str(), F_OK ) < 0 ) {
        std::cerr << "Invalid file: " << fname << std::endl;
        return false;
    }
    m_fs.clear();
    m_fs.open(fname.c_str(), std::ios::binary);

    uint32_t header = 0;
    m_fs.read((char*)&header, sizeof(uint32_t));
    m_fs.seekg(0, std::ios::beg);
    if ( header != DybDaq::RawRecordPoolUtil::FileStartMarker ) {
        std::cerr << fname << " is not a DAQ format file!" << std::endl;
        return false;
    }

    return m_fs.good();
}

RecordBuffer* RecordFromFStream::next()
{
    RecordBuffer* result = 0;

    while ( result == 0 ) {
        m_fs.read(m_block, m_preRead);
        if ( !m_fs.good() ) break;

        uint32_t marker     = ((uint32_t*)m_block)[0];
        uint32_t recordSize = ((uint32_t*)m_block)[1] * sizeof(uint32_t);
        bool     isEvent    = marker == DybDaq::RawRecordPoolUtil::DataSeparatorMarker;
        if ( isEvent ) {
            recordSize += ((int*)m_block)[3];
        }

        if ( recordSize > m_limit ) {
            do {
                m_limit *= 2;
            } while ( recordSize > m_limit );
            char* pnew = new char[m_limit];
            memcpy(pnew, m_block, m_preRead);
            delete [] m_block;
            m_block = pnew;
        }

        m_fs.read( (m_block+m_preRead), (recordSize-m_preRead) );
        if ( m_fs.eof() ) break;

        if ( isEvent && (((uint32_t*)m_block)[11]&1) != 0 ) {
#ifdef RPC_ERROR_DEBUG
            if ( m_debug-- > 0 ) {
                std::cout << "Skipping an invalid event..." << std::endl;
            }
#endif
            continue;
        }

        char* data = new char[recordSize];
        memcpy(data, m_block, recordSize);

        result = new RecordBuffer(data, recordSize);
    }

    return result;
}