In This Package:

DaqTraits.cc

Go to the documentation of this file.

/*
 *  DaqTraits.cc
 *  DaqReadoutFormat
 *
 *  Created by Simon Patton on 7/21/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */

#include "DaqReadoutFormat/DaqTraits.h"

#include "DaqReadoutFormat/BitsDefinition.h"

using DybDaq::BitsDefinition;
using DybDaq::DaqTraits;
using std::string;

DaqTraits::DaqTraits() {
}

DaqTraits::~DaqTraits() {
}

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

unsigned int DaqTraits::marker(unsigned int marker) const {
        if (marker >= markersEnd()) {
                return illegalMarker();
        }
        return markers()[marker];
}

unsigned int DaqTraits::index(unsigned int field) const {
        if (field >= fieldsEnd()) {
                return illegalField();
        }
        return indices()[field];
}

unsigned int DaqTraits::shift(unsigned int field) const {
        if (field >= fieldsEnd()) {
                return 0;
        }
        return shifts()[field];
}

unsigned int DaqTraits::mask(unsigned int field) const {
        if (field >= fieldsEnd()) {
                return 0;
        }
        return masks()[field];
}

const char* DaqTraits::boolAsString(bool value) const {
    if (value) {
        return "yes";
    }
    return "no";
}

DaqTraits::Definitions* DaqTraits::definitions(unsigned int /* component */) const {
    return 0;
}

void DaqTraits::setDefinitions(DaqTraits::Definitions* /* definitions */,
                               unsigned int /* component */) {
}

const unsigned int* DaqTraits::componentFields(unsigned int /* component */) const {
    return 0;
}

const unsigned int DaqTraits::componentFieldsEnd(unsigned int /* component */) const {
    return 0;
}

const string* DaqTraits::descriptions() const {
    return 0;
}

const DaqTraits::Definitions& DaqTraits::bitsDefinitions(unsigned int component) const {
    DaqTraits::Definitions* componentDefinitions = definitions(component);
    if (0 == componentDefinitions) {
        componentDefinitions = new DaqTraits::Definitions();
        const unsigned int* fieldIndices = componentFields(component);
        const unsigned int finished = componentFieldsEnd(component);
        for (unsigned int index = 0;
             finished != index;
             ++index) {
            const unsigned int field = fieldIndices[index];
            unsigned int shift = shifts()[field];
            const unsigned int mask = masks()[field];
            unsigned int count = 0;
            unsigned int bit = 1;
            if (0 != mask) {
                if (0 == (bit & mask)) {
                    // Assumes it is binary
                    while (32 > count && (0 == (bit & mask)) ) {
                        bit <<= 1;
                        ++count;
                    }
                    shift = count - 1;
                    count = 1;
                } else {
                    while (32 > count && (0 != (bit & mask)) ) {
                        bit <<= 1;
                        ++count;
                    }
                }
            }
            componentDefinitions->push_back(BitsDefinition(field,
                                                           indices()[field],
                                                           shift,
                                                           count,
                                                           descriptions()[field]));
        }
        const_cast<DaqTraits*>(this)->setDefinitions(componentDefinitions,
                                                     component);
    }
    return *componentDefinitions;
}

---