In This Package:

DaqFormatFromBytes.cc

Go to the documentation of this file.

/*
 *  DaqFormatFromBytes.cc
 *  RawFileReading
 *
 *  Created by Simon Patton on 7/18/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "DaqReadoutFormat/ByteBuffer.h"
#include "EventReadoutFormat/EventReadout.h"
#include "FileReadoutFormat/CalibrationParametersRecord.h"
#include "FileReadoutFormat/DataSeparatorRecord.h"
#include "FileReadoutFormat/FileEndRecord.h"
#include "FileReadoutFormat/FileTraits.h"
#include "FileReadoutFormat/FileNameStrings.h"
#include "FileReadoutFormat/FileStartRecord.h"
#include "FileReadoutFormat/MetadataStrings.h"
#include "FileReadoutFormat/RunParametersRecord.h"
#include "FileReadoutFormat/DaqFormatFromBytes.h"

using DybDaq::ByteBuffer;
using DybDaq::CalibrationParametersRecord;
using DybDaq::DataSeparatorRecord;
using DybDaq::EventReadout;
using DybDaq::FileBuffer;
using DybDaq::FileEndRecord;
using DybDaq::DaqFormatFromBytes;
using DybDaq::FileNameStrings;
using DybDaq::FileStartRecord;
using DybDaq::MetadataStrings;
using DybDaq::RunParametersRecord;

static const unsigned int MINIMUM_CAPACITY = 2 * ByteBuffer::BYTES_IN_INT;

DaqFormatFromBytes::DaqFormatFromBytes() :
m_traits(&FileTraits::defaultTraits()),
m_additionalCapacity(0) {
}

DaqFormatFromBytes::~DaqFormatFromBytes() {
}

const FileBuffer* DaqFormatFromBytes::processMarker(const ByteBuffer* buffer,
                                                                                                  unsigned int marker) {
        if (0 == m_traits || marker == m_traits->marker(FileTraits::kFileStartRecord)) {
                FileStartRecord*  result = new FileStartRecord(*buffer,
                                                       *m_traits);
        buffer->release();
        const FileTraits* otherTraits = &(result->fileTraits());
        if (m_traits != otherTraits) {
            if (0 == otherTraits) {
                delete result;
                m_additionalCapacity = 0;
                return 0;
            }
            m_traits = otherTraits;
        }
                return result;
        }
        if (marker == m_traits->marker(FileTraits::kFileNameStrings)) {
                const FileBuffer* result = new FileNameStrings(*buffer,
                                                                                                           *m_traits);
        buffer->release();
                return result;
        }
        if (marker == m_traits->marker(FileTraits::kMetadataStrings)) {
                const FileBuffer* result = new MetadataStrings(*buffer,
                                                                                                           *m_traits);
        buffer->release();
                return result;
        }
        if (marker == m_traits->marker(FileTraits::kRunParametersRecord)) {
                const FileBuffer* result = new RunParametersRecord(*buffer,
                                                                                                                   *m_traits);
        buffer->release();
                return result;
        }
        if (marker == m_traits->marker(FileTraits::kCalibrationParametersRecord)) {
                const FileBuffer* result = new CalibrationParametersRecord(*buffer,
                                                                                                                                   *m_traits);
        buffer->release();
                return result;
        }
        if (marker == m_traits->marker(FileTraits::kDataSeparatorRecord)) {
                DataSeparatorRecord* result = new DataSeparatorRecord(*buffer,
                                                                                                                          *m_traits);
                unsigned int length = result->blockLength();
                if (length  > buffer->remaining()) {
                        m_additionalCapacity = length - buffer->remaining();
                        delete result;
                        return 0;
                }
                const EventReadout* dataBlock = new EventReadout(*buffer);
        buffer->release();
                result->setBlock(dataBlock);
                return result;
        }
        if (marker == m_traits->marker(FileTraits::kFileEndRecord)) {
                const FileBuffer* result = new FileEndRecord(*buffer,
                                                                                                         *m_traits);
        buffer->release();
                return result;
        }
        m_additionalCapacity = 0;
        return 0;
}

unsigned int DaqFormatFromBytes::additionalCapacity() {
        return m_additionalCapacity;
}

const FileBuffer* DaqFormatFromBytes::createFileBuffer(const ByteBuffer* buffer) {
        unsigned int remaining = buffer->remaining();
        if (MINIMUM_CAPACITY > remaining) {
                m_additionalCapacity = MINIMUM_CAPACITY - remaining;
                return 0;
        }
        
        unsigned int size = buffer->readUnsignedInt(buffer->position() + ByteBuffer::BYTES_IN_INT);
        unsigned int lengthInBytes = size * ByteBuffer::BYTES_IN_INT;
        if (lengthInBytes >  remaining) {
                m_additionalCapacity = lengthInBytes - remaining;
                return 0;
        }       
        
        return processMarker(buffer,
                                                 buffer->readUnsignedInt(buffer->position()));
}

---