BlockHeaderV4.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_BLOCKHEADERV4_H
#define EVIO_6_0_BLOCKHEADERV4_H


#include <bitset>
#include <sstream>


#include "IBlockHeader.h"
#include "ByteOrder.h"
#include "ByteBuffer.h"
#include "EvioException.h"


namespace evio {


    class BlockHeaderV4 : public IBlockHeader {

    public:

        static const uint32_t HEADER_SIZE = 8;

        static const uint32_t EV_DICTIONARY_MASK = 0x100;

        static const uint32_t EV_LASTBLOCK_MASK  = 0x200;

        static const uint32_t EV_EVENTTYPE_MASK  = 0x3C00;

        static const uint32_t EV_FIRSTEVENT_MASK  = 0x4000;

        static const uint32_t EV_BLOCKSIZE = 0;
        static const uint32_t EV_BLOCKNUM = 1;
        static const uint32_t EV_HEADERSIZE = 2;
        static const uint32_t EV_COUNT = 3;
        static const uint32_t EV_RESERVED1 = 4;
        static const uint32_t EV_VERSION = 5;
        static const uint32_t EV_RESERVED2 = 6;
        static const uint32_t EV_MAGIC = 7;


        uint32_t size = 0;

        uint32_t number = 1;

        uint32_t headerLength = 8;

        uint32_t eventCount = 0;

        uint32_t version = 4;

        uint32_t reserved1 = 0;

        uint32_t reserved2 = 0;

        std::bitset<24> bitInfo;

        uint32_t magicNumber = MAGIC_NUMBER;

        ByteOrder byteOrder {ByteOrder::ENDIAN_LOCAL};

        int64_t bufferStartingPosition = 0L;


    public:

        BlockHeaderV4() = default;


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


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


        void copy(std::shared_ptr<BlockHeaderV4> & blkHeader) {
            size         = blkHeader->size;
            number       = blkHeader->number;
            headerLength = blkHeader->headerLength;
            version      = blkHeader->version;
            eventCount   = blkHeader->eventCount;
            reserved1    = blkHeader->reserved1;
            reserved2    = blkHeader->reserved2;
            byteOrder    = blkHeader->byteOrder;
            magicNumber  = blkHeader->magicNumber;
            bitInfo      = blkHeader->bitInfo;
            bufferStartingPosition = blkHeader->bufferStartingPosition;
        }


        uint32_t getSize() override {return size;}


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


        uint32_t getEventCount() const {return eventCount;}


        void setEventCount(uint32_t count) {
            if (count < 0) {
                throw EvioException("Bad value for event count in block (physical record) header: " +
                                    std::to_string(count));
            }
            eventCount = count;
        }


        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 != HEADER_SIZE) {
                std::cout << "Warning: Block Header Length = " << headerLength << std::endl;
            }
            headerLength = len;
        }


        uint32_t getVersion() override {return version;}


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


        bool hasFirstEvent() override {return bitInfo[6];}


        static bool hasDictionary(uint32_t i) {return ((i & EV_DICTIONARY_MASK) > 0);}


        bool hasDictionary() override {return bitInfo[0];}


        bool isLastBlock() override {return bitInfo[1];}


        bool isCompressed() override {return false;}


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


        bool hasFirstEvent() const {return bitInfo[6];}


        static bool isLastBlock(uint32_t i) {return ((i & EV_LASTBLOCK_MASK) > 0);}


        static uint32_t setLastBlockBit(uint32_t i)  {return (i |= EV_LASTBLOCK_MASK);}


        static uint32_t clearLastBlockBit(uint32_t i) {return (i &= ~EV_LASTBLOCK_MASK);}


        static bool hasFirstEvent(uint32_t i) {return ((i & EV_FIRSTEVENT_MASK) > 0);}


        static uint32_t setFirstEventBit(uint32_t i)  {return (i |= EV_FIRSTEVENT_MASK);}


        static uint32_t clearFirstEventBit(uint32_t i) {return (i &= ~EV_FIRSTEVENT_MASK);}


        //-//////////////////////////////////////////////////////////////////
        //  BitInfo methods
        //-//////////////////////////////////////////////////////////////////


        uint32_t getEventType() override {
            uint32_t type=0;
            bool bitisSet;
            for (uint32_t i=0; i < 4; i++) {
                bitisSet = bitInfo[i+2];
                if (bitisSet) type |= (uint32_t)1 << i;
            }
            return type;
        }


        static void setFirstEvent(std::bitset<24> & bSet) {
            // Encoding bit #15 (#6 since first is bit #9)
            bSet[6] = true;
        }


        static void unsetFirstEvent(std::bitset<24> & bSet) {
            // Encoding bit #15 (#6 since first is bit #9)
            bSet[6] = false;
        }


        std::bitset<24> getBitInfo() {return bitInfo;}


        bool getBitInfo(uint32_t bitIndex) {
            if (bitIndex > 23) {
                return false;
            }
            return bitInfo[bitIndex];
        }


        void setBit(uint32_t bitIndex, bool value) {
            if (bitIndex > 23) {
                return;
            }
            bitInfo[bitIndex] = value;
        }


        static void setEventType(std::bitset<24> & bSet, uint32_t type) {
            if (type < 0) type = 0;
            else if (type > 15) type = 15;

            for (uint32_t i=2; i < 6; i++) {
                bSet[i] = ((type >> (i-2)) & 0x1) > 0;
            }
        }


        uint32_t getSixthWord() {
            uint32_t v = version & 0xff;

            for (uint32_t i=0; i < bitInfo.size(); i++) {
                if (bitInfo[i]) {
                    v |= (0x1 << (8+i));
                }
            }

            return v;
        }


        static uint32_t generateSixthWord(std::bitset<24> const & set) {
            uint32_t v = 4; // version

            for (uint32_t i=0; i < set.size(); i++) {
                if (i > 23) {
                    break;
                }
                if (set[i]) {
                    v |= (0x1 << (8+i));
                }
            }

            return v;
        }


        static uint32_t generateSixthWord(std::bitset<24> const & bSet, bool hasDictionary, bool isEnd) {
            uint32_t v = 4; // version

            for (uint32_t i=0; i < bSet.size(); i++) {
                if (i > 23) {
                    break;
                }
                if (bSet[i]) {
                    v |= (0x1 << (8+i));
                }
            }

            v =  hasDictionary ? (v | 0x100) : v;
            v =  isEnd ? (v | 0x200) : v;

            return v;
        }


        static uint32_t generateSixthWord(uint32_t version, bool hasDictionary,
                                          bool isEnd, uint32_t eventType) {
            uint32_t v = version;
            v =  hasDictionary ? (v | 0x100) : v;
            v =  isEnd ? (v | 0x200) : v;
            v |= ((eventType & 0xf) << 10);
            return v;
        }


        static uint32_t generateSixthWord(std::bitset<24> bSet, uint32_t version,
                                          bool hasDictionary,
                                          bool isEnd, uint32_t eventType) {
            uint32_t v = version; // version

            for (int i=0; i < bSet.size(); i++) {
                if (i > 23) {
                    break;
                }
                if (bSet[i]) {
                    v |= (0x1 << (8+i));
                }
            }

            v =  hasDictionary ? (v | 0x100) : v;
            v =  isEnd ? (v | 0x200) : v;
            v |= ((eventType & 0xf) << 10);

            return v;
        }


        void parseToBitInfo(uint32_t word) {
            for (int i=0; i < bitInfo.size(); i++) {
                bitInfo[i] = ((word >> (8+i)) & 0x1) > 0;
            }
        }


        //-//////////////////////////////////////////////////////////////////


        uint32_t getSourceId() override {return reserved1;}


        uint32_t getReserved1() const {return reserved1;}


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


        uint32_t getReserved2() const {return reserved2;}


        void setReserved2(uint32_t r2) {reserved2 = r2;}


        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 << "event count:   " << eventCount << std::endl;
            ss << "reserved1:     " << reserved1 << std::endl;
            ss << "bitInfo  bits: " << bitInfo.to_string() << std::endl;

            ss << "bitInfo/ver:   " << getSixthWord() << std::endl;
            ss << "has dict:      " << hasDictionary() << std::endl;
            ss << "is last blk:   " << isLastBlock() << std::endl;

            ss << "version:       " << version << 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*size;}


        size_t getBufferStartingPosition() override {return bufferStartingPosition;}


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


        size_t nextBufferStartingPosition() override {return getBufferEndingPosition();}


        size_t firstEventStartingPosition() override {return bufferStartingPosition + 4*headerLength;}


        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(eventCount);
            byteBuffer.putInt(0);       // unused
            byteBuffer.putInt(getSixthWord());
            byteBuffer.putInt(0);       // unused
            byteBuffer.putInt(magicNumber);
            return 32;
        }

    };


}

#endif //EVIO_6_0_BLOCKHEADERV4_H