BlockHeaderV2.h

Go to the documentation of this file.

//
// Copyright 2020, Jefferson Science Associates, LLC.
// Subject to the terms in the LICENSE file found in the top-level directory.
//
// EPSCI Group
// Thomas Jefferson National Accelerator Facility
// 12000, Jefferson Ave, Newport News, VA 23606
// (757)-269-7100


#ifndef EVIO_6_0_BLOCKHEADERV2_H
#define EVIO_6_0_BLOCKHEADERV2_H


#include <string>
#include <stdexcept>


#include "ByteOrder.h"
#include "IBlockHeader.h"


namespace evio {

    class BlockHeaderV2 : public IBlockHeader {

    public:

        static const uint32_t MAX_BLOCK_SIZE = 32768;

    private:

        uint32_t size = 0;

        uint32_t number = 1;

        uint32_t headerLength = 8;

        uint32_t start = 8;

        uint32_t end = 0;

        uint32_t version = 2;

        uint32_t reserved1 = 0;

        uint32_t magicNumber = MAGIC_NUMBER;

        ByteOrder byteOrder {ByteOrder::ENDIAN_LOCAL};

        uint64_t bufferStartingPosition = 0L;

    public:

        BlockHeaderV2() = default;


        BlockHeaderV2(uint32_t sz, uint32_t num) {
            size = sz;
            number = num;
            end = size;
        }


        explicit BlockHeaderV2(std::shared_ptr<BlockHeaderV2> & blkHeader) {
            copy(blkHeader);
        }


        void copy(std::shared_ptr<BlockHeaderV2> & blkHeader) {
            size         = blkHeader->size;
            number       = blkHeader->number;
            headerLength = blkHeader->headerLength;
            version      = blkHeader->version;
            end          = blkHeader->end;
            start        = blkHeader->start;
            reserved1    = blkHeader->reserved1;
            byteOrder    = blkHeader->byteOrder;
            magicNumber  = blkHeader->magicNumber;
            bufferStartingPosition = blkHeader->bufferStartingPosition;
        }


        bool hasDictionary() override {return false;}


        bool isLastBlock() override {return false;}


        bool isCompressed() override {return false;}


        Compressor::CompressionType getCompressionType() override {return Compressor::UNCOMPRESSED;}


        uint32_t getSize() override {return size;}


        void setSize(uint32_t sz) {
            if ((sz < 8) || (sz > MAX_BLOCK_SIZE)) {
                throw EvioException("Bad value for size in block (physical record) header: " + std::to_string(sz));
            }
            size = sz;
        }


        uint32_t getStart() const {return start;}


        void setStart(uint32_t strt) {
            if ((strt < 0) || (strt > MAX_BLOCK_SIZE)) {
                throw EvioException("Bad value for start in block (physical record) header: " + std::to_string(strt));
            }
            start = strt;
        }


        uint32_t getEnd() const {return end;}


        void setEnd(uint32_t endd) {
            if ((endd < 8) || (endd > MAX_BLOCK_SIZE)) {
                throw EvioException("Bad value for end in block (physical record) header: " + std::to_string(endd));
            }
            end = endd;
        }


        uint32_t getNumber() override {return number;}


        void setNumber(uint32_t num) {number = num;}


        uint32_t getHeaderLength() const {return headerLength;}


        uint32_t getHeaderWords() override {return headerLength;}


        void setHeaderLength(uint32_t len) {
            if (len != 8) {
                throw EvioException("Bad Block (Physical Record) Header Length: " + std::to_string(len));
            }
            headerLength = len;
        }


        bool hasFirstEvent() override {return false;}


        uint32_t getEventType() override {return 0;}


        uint32_t getVersion() override {return version;}


        void setVersion(uint32_t ver) {version = ver;}


        uint32_t getSourceId() override {return reserved1;}


        uint32_t getReserved1() const {return reserved1;}


        void setReserved1(uint32_t r1) {reserved1 = r1;}


        uint32_t getMagicNumber() override {return magicNumber;}


        void setMagicNumber(uint32_t magicNum) {
            if (magicNum != MAGIC_NUMBER) {
                throw EvioException("Value for magicNumber, " + std::to_string(magicNum) +
                                    " does not match MAGIC_NUMBER 0xc0da0100");
            }
            magicNumber = MAGIC_NUMBER;
        }


        ByteOrder & getByteOrder() override {return byteOrder;}


        void setByteOrder(ByteOrder & order) {byteOrder = order;}


        std::string toString() override {
            std::stringstream ss;

            ss << "block size:    " << size << std::endl;
            ss << "number:        " << number << std::endl;
            ss << "headerLen:     " << headerLength << std::endl;
            ss << "start:         " << start << std::endl;
            ss << "end:           " << end << std::endl;
            ss << "version:       " << version << std::endl;
            ss << "reserved1:     " << reserved1 << std::endl;
            ss << "magicNumber:   " << magicNumber << std::endl;
            ss << "  *buffer start: " << getBufferStartingPosition() << std::endl;
            ss << "  *next   start: " << nextBufferStartingPosition() << std::endl;

            return ss.str();
        }


        size_t getBufferEndingPosition() override {return bufferStartingPosition + 4*end;}


        size_t getBufferStartingPosition() override {return bufferStartingPosition;}


        void setBufferStartingPosition(size_t pos) override {bufferStartingPosition = pos;}


        size_t nextBufferStartingPosition() override {return bufferStartingPosition + 4*size;}


        size_t firstEventStartingPosition() override {
            if (start == 0) {
                return 0UL;
            }
            return bufferStartingPosition + 4*start;
        }


        size_t bytesRemaining(size_t position) override {
            if (position < bufferStartingPosition) {
                throw EvioException("Provided position is less than buffer starting position.");
            }

            size_t nextBufferStart = nextBufferStartingPosition();
            if (position > nextBufferStart) {
                throw EvioException("Provided position beyond buffer end position.");
            }

            return nextBufferStart - position;
        }


        size_t write(ByteBuffer & byteBuffer) override {

            if (byteBuffer.remaining() < 32) {
                throw std::overflow_error("not enough room in buffer to write");
            }
            byteBuffer.putInt(size);
            byteBuffer.putInt(number);
            byteBuffer.putInt(headerLength); // should always be 8
            byteBuffer.putInt(start);
            byteBuffer.putInt(end);
            byteBuffer.putInt(version);
            byteBuffer.putInt(reserved1);
            byteBuffer.putInt(magicNumber);
            return 32;
        }
    };


}

#endif //EVIO_6_0_BLOCKHEADERV2_H