FileHeader.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_FILEHEADER_H
#define EVIO_6_0_FILEHEADER_H


#include <string>
#include <iostream>
#include <ios>
#include <iomanip>
#include <sstream>


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


namespace evio {


    class FileHeader {


    private:

    public:

        static const uint32_t   HIPO_FILE_UNIQUE_WORD = 0x4F504948; // 0x4849504F = HIPO
        static const uint32_t   EVIO_FILE_UNIQUE_WORD = 0x4556494F; // = EVIO
        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   FILE_ID_OFFSET = 0;
        static const uint32_t   FILE_NUMBER_OFFSET = 4;
        static const uint32_t   HEADER_LENGTH_OFFSET = 8;
        static const uint32_t   RECORD_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   REGISTER1_OFFSET = 32;
        static const uint32_t   TRAILER_POSITION_OFFSET = 40;
        static const uint32_t   INT1_OFFSET = 48;
        static const uint32_t   INT2_OFFSET = 52;

        // Bits in bit info word

        static const uint32_t   DICTIONARY_BIT = 0x100;
        static const uint32_t   FIRST_EVENT_BIT = 0x200;
        static const uint32_t   TRAILER_WITH_INDEX_BIT = 0x400;

    private:

        uint32_t  fileId = HIPO_FILE_UNIQUE_WORD;
        uint32_t  fileNumber = 1;
        uint64_t userRegister = 0L;
        uint64_t trailerPosition = 0L;
        uint32_t  userIntFirst = 0;
        uint32_t  userIntSecond = 0;
        size_t position = 0;

        uint32_t  entries = 0;
        uint32_t  bitInfo = 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  totalLength = HEADER_SIZE_BYTES;

        uint32_t  headerVersion = 6;
        uint32_t  headerMagicWord = HEADER_MAGIC;

        uint32_t  userHeaderLengthPadding = 0;

        ByteOrder  byteOrder {ByteOrder::ENDIAN_LOCAL};

        HeaderType headerType {HeaderType::HIPO_FILE};

    public:

        FileHeader();
        FileHeader(const FileHeader & header);
        explicit FileHeader(bool isEvio);
        ~FileHeader() = default;

        void copy(const FileHeader & head);
        void reset();

    private:

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

    public:

        // Getters

        const ByteOrder  & getByteOrder()  const;
        const HeaderType & getHeaderType() const;

        uint32_t  getFileNumber() const;
        uint32_t  getFileId()  const;
        uint32_t  getVersion() const;
        uint32_t  getEntries() const;

        uint32_t  getLength() const;
        uint32_t  getIndexLength() const;
        uint32_t  getHeaderLength() const;

        uint32_t  getUserHeaderLength() const;
        uint32_t  getUserHeaderLengthWords() const;
        uint32_t  getUserHeaderLengthPadding() const;

        uint32_t  getUserIntFirst()  const;
        uint32_t  getUserIntSecond() const;
        uint64_t  getUserRegister()  const;

        size_t    getPosition() const;
        size_t    getTrailerPosition() const;

        //--------------------
        // Bit info methods
        //--------------------

        uint32_t getBitInfoWord() const;
        void     setBitInfoWord(uint32_t word);
        uint32_t setBitInfo(bool haveFirst, bool haveDictionary, bool haveTrailerWithIndex);
        static uint32_t generateBitInfoWord(uint32_t version, bool hasDictionary,
                                            bool hasFirst, bool trailerWithIndex,
                                            uint32_t headerType = 1);

        uint32_t hasFirstEvent(bool hasFirst);
        bool     hasFirstEvent() const;

        uint32_t hasDictionary(bool hasDictionary);
        bool     hasDictionary() const;

        uint32_t hasTrailerWithIndex(bool hasTrailerWithIndex);
        bool     hasTrailerWithIndex() const;

        bool hasUserHeader() const;
        bool hasIndex() const;

        static bool hasFirstEvent(uint32_t bitInfo);
        static bool hasDictionary(uint32_t bitInfo);
        static bool hasTrailerWithIndex(uint32_t bitInfo);

        // Setters

        FileHeader & setFileNumber(uint32_t num);
        FileHeader & setUserRegister(uint64_t val);
        FileHeader & setUserIntFirst(uint32_t val);
        FileHeader & setUserIntSecond(uint32_t val);
        FileHeader & setHeaderType(HeaderType & type);
        FileHeader & setPosition(size_t pos);
        FileHeader & setIndexLength(uint32_t length);
        FileHeader & setEntries(uint32_t n);
        FileHeader & setUserHeaderLength(uint32_t length);
        FileHeader & setHeaderLength(uint32_t length);
        FileHeader & setLength(uint32_t length);


        // Writing, reading, printing
        void writeHeader(ByteBuffer & buf, size_t off);
        void writeHeader(std::shared_ptr<ByteBuffer> & buf, size_t off = 0);
        void readHeader(ByteBuffer & buffer, size_t offset = 0);
        void readHeader(std::shared_ptr<ByteBuffer> & buffer, size_t offset = 0);

        std::string toString() const;
    };

}


#endif //EVIO_6_0_FILEHEADER_H