In This Package:

DaqBuffer.cc

Go to the documentation of this file.

/*
 *  DaqBuffer.cc
 *  DaqReadutFormat
 *
 *  Created by Simon Patton on 7/20/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "DaqReadoutFormat/DaqBuffer.h"

#include "DaqReadoutFormat/BitsDefinition.h"
#include "DaqReadoutFormat/BitsInspector.h"
#include "DaqReadoutFormat/ByteBuffer.h"
#include "DaqReadoutFormat/ByteInspector.h"
#include "DaqReadoutFormat/DaqTraits.h"

using DybDaq::ByteBuffer;
using DybDaq::ByteInspector;
using DybDaq::DaqTraits;
using DybDaq::DaqBuffer;

const unsigned int DaqBuffer::kBytesInInt = 4;
const unsigned int DaqBuffer::kUndefinedFormatComponent = 0xffffffff;


DaqBuffer::DaqBuffer(const DaqBuffer& buffer) :
m_byteBuffer(&(buffer.byteBuffer())),
m_buffer(buffer.byteBuffer().grab()),
m_traits(&(buffer.daqTraits())) {
    // Currently assumes a ByteBuffer based DaqBuffer is being copied.
}

DaqBuffer::DaqBuffer(char* buffer,
                     const DaqTraits& traits,
                     const unsigned int size) :
m_byteBuffer(0),
m_buffer(buffer),
m_traits(&traits) {
    const unsigned int finished = size * kBytesInInt;
    for (unsigned int element = 0;
         finished != element;
         ++element) {
        buffer[element] = 0;
    }
}

DaqBuffer::DaqBuffer(const ByteBuffer& byteBuffer,
                     const DaqTraits& traits) :
m_byteBuffer(&byteBuffer),
m_buffer(byteBuffer.grab()),
m_traits(&traits) {
}

DaqBuffer::~DaqBuffer() {
    if (0 == m_byteBuffer) {
        delete [] m_buffer;
    } else {
        m_byteBuffer->release();
    }
}

bool DaqBuffer::hasDaqTraits() const {
    return 0 != &daqTraits();
}

const DaqTraits& DaqBuffer::daqTraits() const {
    return *m_traits;
}

const char* DaqBuffer::buffer() const {
    return m_buffer;
}

bool DaqBuffer::hasByteBuffer() const {
    return 0 != m_byteBuffer;
}

const ByteBuffer& DaqBuffer::byteBuffer() const {
    return *m_byteBuffer;
}

bool DaqBuffer::readBool(const unsigned int field) const {
    unsigned int fourBytes = readUnsignedInt(field);
    return 0 != fourBytes;
}

int DaqBuffer::readInt(const unsigned int field) const {
    unsigned int fourBytes = readUnsignedInt(field);
    return *(int*)(&fourBytes);
}

unsigned char DaqBuffer::readUnsignedChar(const unsigned int field) const {
    unsigned int fourBytes = readUnsignedInt(field);
    return *(unsigned char*)(&fourBytes);
}

unsigned int DaqBuffer::readUnsignedInt(const unsigned int field) const {
    const DaqTraits& traits = daqTraits();
    unsigned int index = traits.index(field);
    if (index == traits.illegalField()) {
        return 0;
    }
    const unsigned int fourBytes = *(((unsigned int*)m_buffer) + index);
    return (fourBytes >> traits.shift(field)) & traits.mask(field);
}

unsigned int DaqBuffer::gather(OutputBufferList& outputBuffers) const {
    const unsigned int result = bufferSize() * kBytesInInt;
    outputBuffers.push_back(OutputBuffer(m_buffer,
                                         result));
    return result;
}

unsigned int DaqBuffer::inspect(DaqBuffer::Bytes& inspectors) const {
    const unsigned int component = formatComponent();
    unsigned int cursor = 0;
    const unsigned int size = bufferSize();
    if (kUndefinedFormatComponent == component) {
        if (0 != size) {
            inspectors.push_back(new ByteInspector(*(((unsigned int*)m_buffer) + cursor),
                                                   0));
        }
    } else {
        cursor = fillInspectors(inspectors,
                                component,
                                cursor);
    }
    while ((size - cursor) > 1) {
        ++cursor;
        inspectors.push_back(new ByteInspector(*(((unsigned int*)m_buffer) + cursor),
                                               0));
    }
    return cursor + 1;
}

unsigned int DaqBuffer::fillInspectors(DaqBuffer::Bytes& inspectors,
                                       unsigned int component,
                                       unsigned int cursor) const {
    const DybDaq::DaqTraits::Definitions& definitions = daqTraits().bitsDefinitions(component);
    ByteInspector::Bits* bitsInByte = 0;
    const DybDaq::DaqTraits::Definitions::const_iterator finished = definitions.end();
    for (DybDaq::DaqTraits::Definitions::const_iterator definition = definitions.begin();
         finished != definition;
         ++definition) {
        const DybDaq::BitsDefinition& bits = *definition;
        if (0 == bitsInByte || (bits.offset() != cursor)) {
            if (0 == bitsInByte && (cursor != bits.offset())) {
                inspectors.push_back(new ByteInspector(*(((unsigned int*)m_buffer) + cursor),
                                                       0));
            }
            while (((bits.offset() - cursor) > 1)) {
                ++cursor;
                inspectors.push_back(new ByteInspector(*(((unsigned int*)m_buffer) + cursor),
                                                       0));
            }
            bitsInByte = new ByteInspector::Bits();
            cursor = bits.offset();
            inspectors.push_back(new ByteInspector(*(((unsigned int*)m_buffer) + bits.offset()),
                                                   bitsInByte));
        } 
        DybDaq::BitsInspector* bitInfo = new BitsInspector(readUnsignedInt(bits.field()),
                                                           bits);
        bitsInByte->push_back(bitInfo);
    }
    return cursor;
}

char* DaqBuffer::buffer() {
    return const_cast<char*>(m_buffer);
}

void DaqBuffer::writeField(const bool value,
                           const unsigned int field) {
    const DaqTraits& traits = daqTraits();
    unsigned int index = traits.index(field);
    if (index == traits.illegalField()) {
        return;
    }
    const unsigned int mask = traits.mask(field);
    const unsigned int cleared = (*(((unsigned int*)m_buffer) + index)) & (~mask);
    if (value) {
        *(((unsigned int*)m_buffer) + index) = cleared | mask;
    }
}

void DaqBuffer::writeField(const int value,
                           const unsigned int field) {
    const DaqTraits& traits = daqTraits();
    unsigned int index = traits.index(field);
    if (index == traits.illegalField()) {
        return;
    }
    const unsigned int shift = traits.shift(field);
    const unsigned int mask = traits.mask(field) << shift;
    unsigned int* location = (((unsigned int*)m_buffer) + index);
    const unsigned int cleared = (*location) & (~mask);
    *location = cleared | ((value << shift) & mask);
}

void DaqBuffer::writeField(const unsigned int value,
                           const unsigned int field) {
    const DaqTraits& traits = daqTraits();
    unsigned int index = traits.index(field);
    if (index == traits.illegalField()) {
        return;
    }
    const unsigned int shift = traits.shift(field);
    const unsigned int mask = traits.mask(field) << shift;
    unsigned int* location = (((unsigned int*)m_buffer) + index);
    const unsigned int cleared = (*location) & (~mask);
    *location = cleared | ((value << shift) & mask);
}

unsigned int DaqBuffer::formatComponent() const {
    return kUndefinedFormatComponent;
}

---