RecordHeader.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_RECORDHEADER_H
#define EVIO_6_0_RECORDHEADER_H


#include <cstdint>
#include <string>
#include <bitset>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <vector>
#include <memory>


#include "HeaderType.h"
#include "ByteOrder.h"
#include "ByteBuffer.h"
#include "IBlockHeader.h"
#include "EvioException.h"
#include "Compressor.h"
#include "Util.h"


namespace evio {


    class RecordHeader : public IBlockHeader {

    private:

        static uint32_t padValue[4];

    public:

        static const uint32_t   HEADER_SIZE_WORDS = 14;
        static const uint32_t   HEADER_SIZE_BYTES = 56;
        static const uint32_t   HEADER_MAGIC = 0xc0da0100;

        // Byte offset to header words

        static const uint32_t   RECORD_LENGTH_OFFSET = 0;
        static const uint32_t   RECORD_NUMBER_OFFSET = 4;
        static const uint32_t   HEADER_LENGTH_OFFSET = 8;
        static const uint32_t   EVENT_COUNT_OFFSET = 12;
        static const uint32_t   INDEX_ARRAY_OFFSET = 16;
        static const uint32_t   BIT_INFO_OFFSET = 20;
        static const uint32_t   USER_LENGTH_OFFSET = 24;
        static const uint32_t   MAGIC_OFFSET = 28;
        static const uint32_t   UNCOMPRESSED_LENGTH_OFFSET = 32;
        static const uint32_t   COMPRESSION_TYPE_OFFSET = 36;
        static const uint32_t   REGISTER1_OFFSET = 40;
        static const uint32_t   REGISTER2_OFFSET = 48;

        // Bits in bit info word

        static const uint32_t   DICTIONARY_BIT = 0x100;
        static const uint32_t   LAST_RECORD_BIT = 0x200;

        static const uint32_t   DATA_ROC_RAW_BITS = 0x000;
        static const uint32_t   DATA_PHYSICS_BITS = 0x800;
        static const uint32_t   DATA_PARTIAL_BITS = 0x1000;
        static const uint32_t   DATA_DISENTANGLED_BITS = 0x1800;
        static const uint32_t   DATA_USER_BITS    = 0x2000;
        static const uint32_t   DATA_CONTROL_BITS = 0x2800;
        static const uint32_t   DATA_OTHER_BITS   = 0x7800;

        // Bit masks

        static const uint32_t VERSION_MASK = 0xff;
        static const uint32_t LAST_RECORD_MASK = 0x400;

    private:

        static const uint32_t COMP_PADDING_MASK = 0x03000000;
        static const uint32_t DATA_PADDING_MASK = 0x00C00000;
        static const uint32_t USER_PADDING_MASK = 0x00300000;
        static const uint32_t HEADER_TYPE_MASK = 0xF0000000;

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

        uint64_t recordUserRegisterFirst = 0ULL;
        uint64_t recordUserRegisterSecond = 0ULL;
        size_t position = 0ULL;
        uint32_t  recordLength = 0;
        uint32_t  recordLengthWords = 0;
        uint32_t  recordNumber = 1;


        uint32_t  entries = 0;
        uint32_t  bitInfo = 0;
        uint32_t  eventType = 0;
        uint32_t  headerLength = HEADER_SIZE_BYTES;
        uint32_t  headerLengthWords = HEADER_SIZE_WORDS;
        uint32_t  userHeaderLength = 0;
        uint32_t  userHeaderLengthWords = 0;
        uint32_t  indexLength = 0;
        uint32_t  dataLength = 0;
        uint32_t  dataLengthWords = 0;
        uint32_t  compressedDataLength = 0;
        uint32_t  compressedDataLengthWords = 0;
        uint32_t  headerVersion = 6;
        uint32_t  headerMagicWord = HEADER_MAGIC;

        uint32_t  userHeaderLengthPadding = 0;
        uint32_t  dataLengthPadding = 0;
        uint32_t  compressedDataLengthPadding = 0;

        HeaderType headerType {HeaderType::EVIO_RECORD};

        ByteOrder byteOrder {ByteOrder::ENDIAN_LOCAL};

        Compressor::CompressionType compressionType {Compressor::UNCOMPRESSED};


    public:

        RecordHeader();
        RecordHeader(const RecordHeader & head);
        explicit RecordHeader(const HeaderType & type);
        RecordHeader(size_t pos, uint32_t len, uint32_t ent);
        ~RecordHeader() = default;

        RecordHeader & operator=(const RecordHeader& head);

    private:

        void bitInfoInit();
        void decodeBitInfoWord(uint32_t word);

    public:

        void copy(std::shared_ptr<RecordHeader> const & head);
        void reset();

        static uint32_t getWords(uint32_t length);
        static uint32_t getPadding(uint32_t length);

        // Getters

        const HeaderType & getHeaderType() const;
        // getByteOrder part of IBlockHeader below ...

        uint32_t  getUncompressedRecordLength() const;
        uint32_t  getCompressedRecordLength() const;
        uint32_t  getLength() const;
        uint32_t  getLengthWords() const;
        uint32_t  getEntries() const;
        uint32_t  getUserHeaderLength() const;
        uint32_t  getUserHeaderLengthWords() const;
        //  getVersion() part of IBlockHeader below ...
        uint32_t  getDataLength() const;
        uint32_t  getDataLengthWords() const;
        uint32_t  getIndexLength() const;
        uint32_t  getCompressedDataLength() const;
        uint32_t  getCompressedDataLengthPadding() const;
        uint32_t  getCompressedDataLengthWords() const;
        uint32_t  getHeaderLength() const;
        // getHeaderWords part of IBlockHeader below ...
        uint32_t  getRecordNumber() const;
        uint64_t  getUserRegisterFirst() const;
        uint64_t  getUserRegisterSecond() const;
        size_t    getPosition() const;
        Compressor::CompressionType  getCompressionType() override;

        // Bit info methods

        uint32_t  setBitInfo(bool isLastRecord, bool haveDictionary);
        uint32_t  getBitInfoWord() const;
        void setBitInfoWord(uint32_t word);
        void setBitInfoWord(std::bitset<24> const & set);

        static uint32_t generateSixthWord(std::bitset<24> const & set);
        static uint32_t generateSixthWord(uint32_t version, bool hasDictionary,
                                          bool isEnd, uint32_t eventType);
        static uint32_t generateSixthWord(std::bitset<24> const & set, uint32_t version,
                                          bool hasDictionary, bool isEnd, uint32_t eventType,
                                          uint32_t headerType = 0);

        // Boolean setters/getters

        uint32_t    hasDictionary(bool hasFirst);
        // hasDictionary() part of IBlockHeader below ...
        static bool hasDictionary(int bitInfo);

        uint32_t    isLastRecord(bool isLast);
        bool        isLastRecord() const;
        static bool isLastRecord(uint32_t bitInfo);

        bool        isCompressed() override;

        bool        isEvioTrailer() const;
        bool        isEvioRecord()  const;
        bool        isHipoTrailer() const;
        bool        isHipoRecord()  const;

        static bool isEvioTrailer(uint32_t bitInfo);
        static bool isEvioRecord(uint32_t bitInfo);
        static bool isHipoTrailer(uint32_t bitInfo);
        static bool isHipoRecord(uint32_t bitInfo);

        // Setters

        static uint32_t clearLastRecordBit(uint32_t i);
        uint32_t  setBitInfoEventType (uint32_t type);

        RecordHeader & setHeaderType(HeaderType const & type);
        RecordHeader & setPosition(size_t pos);
        RecordHeader & setRecordNumber(uint32_t num);
        RecordHeader & setLength(uint32_t length);
        RecordHeader & setDataLength(uint32_t length);
        RecordHeader & setCompressedDataLength(uint32_t length);
        RecordHeader & setIndexLength(uint32_t length);
        RecordHeader & setCompressionType(Compressor::CompressionType type);
        RecordHeader & setEntries(uint32_t n);
        RecordHeader & setUserHeaderLength(uint32_t length);
        RecordHeader & setHeaderLength(uint32_t length);
        RecordHeader & setUserRegisterFirst(uint64_t reg);
        RecordHeader & setUserRegisterSecond(uint64_t reg);


        void writeHeader(ByteBuffer & buf, size_t off = 0);
        void writeHeader(std::shared_ptr<ByteBuffer> & buffer, size_t off = 0);
        void writeHeader(uint8_t *array, const ByteOrder & order);


        static void writeTrailer(uint8_t* array, size_t arrayLen,
                                 uint32_t recordNum, const ByteOrder & order,
                                 const std::shared_ptr<std::vector<uint32_t>> & recordLengths = nullptr);

        static void writeTrailer(std::vector<uint8_t> & array, size_t off,
                                 uint32_t recordNum, const ByteOrder & order,
                                 const std::shared_ptr<std::vector<uint32_t>> & recordLengths = nullptr);

        static void writeTrailer(ByteBuffer & buf, size_t off, uint32_t recordNum,
                                 const std::shared_ptr<std::vector<uint32_t>> & recordLengths = nullptr);

        static void writeTrailer(std::shared_ptr<ByteBuffer> & buf, size_t off, uint32_t recordNum,
                                 const std::shared_ptr<std::vector<uint32_t>> & recordLengths = nullptr);


        static bool isCompressed(ByteBuffer & buffer, size_t offset);
        static bool isCompressed(std::shared_ptr<ByteBuffer> & buffer, size_t offset);


        void readHeader(ByteBuffer & buffer, size_t offset = 0);
        void readHeader(std::shared_ptr<ByteBuffer> & buffer, size_t offset = 0);
        void readHeader(uint8_t *src, ByteOrder order);

        std::string eventTypeToString() const;

        // Methods for implementing IBlockHeader

        uint32_t getSize() override;
        uint32_t getNumber() override;
        uint32_t getHeaderWords() override;
        uint32_t getSourceId() override;
        bool     hasFirstEvent() override;
        uint32_t getEventType() override;
        uint32_t getVersion() override;
        uint32_t getMagicNumber() override;
        ByteOrder & getByteOrder() override;

        bool         hasDictionary() override;
        bool         isLastBlock() override;
        std::string  toString() override;
        size_t       write(ByteBuffer & byteBuffer) override;

        // Methods are not used in this class but must be part of IBlockHeader interface

        size_t getBufferEndingPosition() override;
        size_t getBufferStartingPosition() override;
        void   setBufferStartingPosition(size_t bufferStartingPosition) override;
        size_t nextBufferStartingPosition() override;
        size_t firstEventStartingPosition() override;
        size_t bytesRemaining(size_t pos) override;

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

        int main(int argc, char **argv);

    };

}


#endif //EVIO_6_0_RECORDHEADER_H