In This Package:

MetadataStrings.cc

Go to the documentation of this file.

/*
 *  MetadataStrings.cpp
 *  RawDataBundle
 *
 *  Created by Simon Patton on 7/18/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "FileReadoutFormat/MetadataStrings.h"

#include "FileReadoutFormat/FileTraits.h"
#include <cstring>

using DybDaq::ByteBuffer;
using DybDaq::FileTraits;
using DybDaq::MetadataStrings;
using std::pair;
using std::string;
using std::vector;

MetadataStrings::MetadataStrings(const MetadataStringPtrList& metadataStrings,
                                                                 const FileTraits& traits) :
FileBuffer(new char[traits.recordSize(FileTraits::kMetadataStrings) * kBytesInInt],
           traits,
           FileTraits::kMetadataStrings),
m_strings(0),
m_stringBuffer(0) {
    setMetadataStrings(metadataStrings);
}

MetadataStrings::MetadataStrings(const ByteBuffer& byteBuffer,
                                                                 const FileTraits& traits) :
FileBuffer(byteBuffer,
                   traits),
m_strings(0),
m_stringBuffer(0) {
}

MetadataStrings::~MetadataStrings() {
    if (0 != m_stringBuffer) {
        delete m_stringBuffer;
    }
        if (0 != m_strings) {
                MetadataStringPtrList::const_iterator entry;
                for (entry = m_strings->begin();
                         entry != m_strings->end();
                         ++entry) {
                        delete const_cast<MetadataString*>(*entry);
                }
                delete m_strings;
        }
}

bool MetadataStrings::isMarked(unsigned int marker) const {
    return FileTraits::kMetadataStrings == marker;
}

const MetadataStrings::MetadataStringPtrList& MetadataStrings::metadataStrings() const {
    if (0 == m_strings) {
        m_strings = new MetadataStringPtrList();
        const unsigned int finished = readUnsignedInt(FileTraits::kMetadataCount);
        const char* start;
        if (hasByteBuffer()) {
            start = buffer() + (fileTraits().firstMetadataLengthOffset() * kBytesInInt);
        } else {
            start = m_stringBuffer;
        }
        for (unsigned int metadata = 0;
             metadata != finished ;
             ++metadata) {
            string entry = readString(start);
            const unsigned int length = entry.size();
            const unsigned int paddedLength = length + (kBytesInInt - 1) - ((length - 1) % kBytesInInt );
            start += paddedLength + kBytesInInt;
            size_t found = entry.find('=');
            if (found != string::npos) {
                string first = entry.substr(0,
                                            found);
                string second = entry.substr(found + 1, length - (found + 1));
                m_strings->push_back(new MetadataString(first,
                                                        second));
            }
        }
    }
        return *m_strings;
}

unsigned int MetadataStrings::gather(OutputBufferList& outputBuffers) const {
    if (hasByteBuffer()) {
        return FileBuffer::gather(outputBuffers);
    }
    const unsigned int fixedLength = fileTraits().recordSize(FileTraits::kMetadataStrings) * kBytesInInt;
    outputBuffers.push_back(OutputBuffer(buffer(),
                                         fixedLength));
    unsigned int stringsLength = (size() * kBytesInInt) - fixedLength;
    outputBuffers.push_back(OutputBuffer(m_stringBuffer,
                                         stringsLength));
    return fixedLength + stringsLength;
}

unsigned int MetadataStrings::formatComponent() const {
    return FileTraits::kMetadataStrings;
}

void MetadataStrings::setMetadataStrings(const MetadataStringPtrList& metadataStrings) {
    if (0 != m_stringBuffer) {
        delete m_stringBuffer;
    }
    unsigned int stringsLength = calculateStringsLength(metadataStrings);
    setSize(fileTraits().recordSize(FileTraits::kMetadataStrings) + (stringsLength / kBytesInInt));
    m_stringBuffer = new char[stringsLength];
    char* start = m_stringBuffer;
    MetadataStrings::MetadataStringPtrList::const_iterator metadata;
    for (metadata = metadataStrings.begin();
         metadata != metadataStrings.end();
         ++metadata) {
        const string entry = (*metadata)->first + "=" + (*metadata)->second;
        start += writeString(entry,
                             start);
    }
    writeField((unsigned int)(metadataStrings.size()),
               FileTraits::kMetadataCount);
    if (0 != m_strings) {
        delete m_strings;
        m_strings = 0;
    }
}

string MetadataStrings::readString(const char* buffer) {
    unsigned int length = *((unsigned int*)(buffer));
    char* base = new char[length + 1];
    memcpy(base,
           buffer + kBytesInInt,
           length);
    base[length] = 0;
    string result(base);
    delete base;
    return result;
}

unsigned int MetadataStrings::calculateStringsLength(const MetadataStringPtrList& metadataStrings) {
    unsigned int result = 0;
    MetadataStrings::MetadataStringPtrList::const_iterator metadata;
    for (metadata = metadataStrings.begin();
         metadata != metadataStrings.end();
         ++metadata) {
        const string entry = (*metadata)->first + "=" + (*metadata)->second;
        const unsigned int length = entry.size();
        const unsigned int paddedLength = length + (kBytesInInt - 1) - ((length - 1) % kBytesInInt );
        result += paddedLength + kBytesInInt;        
    }
    return result;
}

unsigned int MetadataStrings::writeString(const string& value,
                                          char* buffer) {
    unsigned int length = value.size();
    char* start = buffer;
    *((unsigned int*)(start)) = length;
    start += kBytesInInt;
    memcpy(start,
           value.data(),
           length);
    unsigned int padding = (kBytesInInt - 1) - ((length - 1) % kBytesInInt );
    start += length;
    for (unsigned int index = 0;
         index != padding;
         ++index) {
        *start = ' ';
        ++start;
    }
    return kBytesInInt + length + padding;
}

---