In This Package:

FileNameStrings.cc

Go to the documentation of this file.

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

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

using DybDaq::ByteBuffer;
using DybDaq::FileNameStrings;
using DybDaq::FileTraits;
using std::string;

FileNameStrings::FileNameStrings(const std::string application,
                                 const std::string fileBase,
                                 const FileTraits& traits) :
FileBuffer(new char[traits.recordSize(FileTraits::kFileNameStrings) * kBytesInInt],
           traits,
           FileTraits::kFileNameStrings),
m_application(0),
m_fileBase(0),
m_stringBuffer(0) {
    setNameStrings(application,
                   fileBase);
}



FileNameStrings::FileNameStrings(const ByteBuffer& byteBuffer,
                                                                 const FileTraits& traits) :
FileBuffer(byteBuffer,
                   traits),
m_application(0),
m_fileBase(0),
m_stringBuffer(0) {
}

FileNameStrings::~FileNameStrings() {
    if (0 != m_stringBuffer) {
        delete m_stringBuffer;
    }
    if (0 != m_fileBase) {
        delete m_fileBase;
    }
    if (0 != m_application) {
        delete m_application;
    }
}

bool FileNameStrings::isMarked(unsigned int marker) const {
    return FileTraits::kFileNameStrings == marker;
}

unsigned int FileNameStrings::firstLength() const {
    return readUnsignedInt(FileTraits::kFirstNameLength);
}

unsigned int FileNameStrings::formatComponent() const {
    return FileTraits::kFileNameStrings;
}

string FileNameStrings::application() const {
    if (0 == m_application) {
        const char* start;
        if (hasByteBuffer()) {
            start = buffer() + (fileTraits().firstNameLengthOffset() * kBytesInInt);
        } else {
            start = m_stringBuffer;
        }
        m_application = new string(readString(start));
        
        unsigned int appLength = m_application->size();
        unsigned int paddedAppLength = appLength + (kBytesInInt - 1) - ((appLength - 1) % kBytesInInt );
        start += paddedAppLength + kBytesInInt;
        m_fileBase = new string(readString(start));
    }
    return *m_application;
}

string FileNameStrings::fileBase() const {
    if (0 == m_application) {
        application();
    }
    return *m_fileBase;
}

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

void FileNameStrings::setNameStrings(const string application,
                                     const string fileBase) {
    unsigned int stringsLength = calculateStringsLength(application,
                                                        fileBase);
    if (0 != m_stringBuffer) {
        delete m_stringBuffer;
    }
    m_stringBuffer = new char[stringsLength];
    setSize(fileTraits().recordSize(FileTraits::kFileNameStrings) + (stringsLength / kBytesInInt));
    char* start = m_stringBuffer;
    start += writeString(application,
                         start);
    writeString(fileBase,
                start);
    if (0 != m_fileBase) {
        delete m_fileBase;
        m_fileBase = 0;
    }
    if (0 != m_application) {
        delete m_application;
        m_application = 0;
    }
}

string FileNameStrings::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 FileNameStrings::calculateStringsLength(const string application,
                                                     const string fileBase) {
    unsigned int result = 0;
    unsigned int length = application.size();
    unsigned int paddedLength = length + (kBytesInInt - 1) - ((length - 1) % kBytesInInt );
    result += paddedLength + kBytesInInt;        
    length = fileBase.size();
    paddedLength = length + (kBytesInInt - 1) - ((length - 1) % kBytesInInt );
    result += paddedLength + kBytesInInt;        
    return result;
}

unsigned int FileNameStrings::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;
}

---