EvioReaderV4.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_EVIOREADERV4_H
#define EVIO_6_0_EVIOREADERV4_H


#include <fstream>
#include <vector>
#include <memory>
#include <mutex>
#include <stdexcept>


#include "ByteOrder.h"
#include "ByteBuffer.h"
#include "IEvioReader.h"
#include "IBlockHeader.h"
#include "BlockHeaderV2.h"
#include "BlockHeaderV4.h"
#include "EventParser.h"


namespace evio {

    class EvioReaderV4 : public IEvioReader {

    public:

        static const uint32_t MAGIC_OFFSET = 28;

        static const uint32_t VERSION_OFFSET = 20;

        static const uint32_t BLOCK_SIZE_OFFSET = 0;

        static const uint32_t VERSION_MASK = 0xff;

        static const uint32_t DEFAULT_READ_BYTES = 32768 * 500; // 16384000 bytes

    private:

        uint32_t eventNumber = 0;

        int32_t eventCount = -1;

        uint32_t evioVersion = 4;

        ByteOrder byteOrder {ByteOrder::ENDIAN_LOCAL};

        uint32_t firstBlockSize = 0;

        uint32_t blockCount = 0;

        std::shared_ptr<BlockHeaderV2> blockHeader2;

        std::shared_ptr<BlockHeaderV4> blockHeader4;

        std::shared_ptr<IBlockHeader> blockHeader;

        std::shared_ptr<IBlockHeader> firstBlockHeader;

        std::shared_ptr<BlockHeaderV2> firstBlockHeader2;

        std::shared_ptr<BlockHeaderV4> firstBlockHeader4;

        uint32_t blockNumberExpected = 1;

        bool checkBlockNumSeq = false;

        bool lastBlock = false;

        bool synchronized = false;

        std::string dictionaryXML;

        std::shared_ptr<ByteBuffer> byteBuffer;

        std::shared_ptr<EventParser> parser;

        size_t initialPosition = 0;

        std::vector<uint32_t> eventPositions;

        std::mutex mtx;


        //------------------------
        // File specific members
        //------------------------


        std::string path;

        std::ifstream file;

        size_t fileBytes = 0;

        bool swap = false;

        bool sequentialRead = false;


        //------------------------
        // EvioReader's state
        //------------------------


        bool closed = false;

        class ReaderState {
          public:
            bool lastBlock;
            uint32_t eventNumber;
            size_t filePosition;
            size_t byteBufferLimit;
            size_t byteBufferPosition;
            uint32_t blockNumberExpected;
            std::shared_ptr<BlockHeaderV2> blockHeader2;
            std::shared_ptr<BlockHeaderV4> blockHeader4;
        };

        ReaderState * getState();
        void restoreState(ReaderState * state);

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

        size_t generateEventPositions(std::shared_ptr<ByteBuffer> & byteBuffer);

    public:

        explicit EvioReaderV4(std::string const & path, bool checkBlkNumSeq = false, bool synced = false);
        explicit EvioReaderV4(std::shared_ptr<ByteBuffer> & byteBuffer, bool checkBlkNumSeq = false, bool synced = false);


        void setBuffer(std::shared_ptr<ByteBuffer> & buf) override;
        bool isClosed() override;
        bool checkBlockNumberSequence() override;
        ByteOrder & getByteOrder() override;
        uint32_t getEvioVersion() override;
        std::string getPath() override;

        std::shared_ptr<EventParser> & getParser() override;
        void setParser(std::shared_ptr<EventParser> & evParser) override;

        std::string getDictionaryXML() override;
        bool hasDictionaryXML() override;
        std::shared_ptr<EvioEvent> getFirstEvent() override;
        bool hasFirstEvent() override;

        size_t getNumEventsRemaining() override;
        std::shared_ptr<ByteBuffer> getByteBuffer() override ;
        size_t fileSize() override;
        std::shared_ptr<IBlockHeader> getFirstBlockHeader() override ;

    protected:

        void parseFirstHeader(std::shared_ptr<ByteBuffer> & headerBuf);
        IEvioReader::ReadWriteStatus processNextBlock();

    private:

        void prepareForSequentialRead();
        void prepareForBufferRead(std::shared_ptr<ByteBuffer> & buffer) const;

        void readDictionary(std::shared_ptr<ByteBuffer> & buffer);
        std::shared_ptr<EvioEvent> getEventV4(size_t index);

    public:

        std::shared_ptr<EvioEvent> getEvent(size_t index) override ;
        std::shared_ptr<EvioEvent> parseEvent(size_t index) override ;
        std::shared_ptr<EvioEvent> nextEvent() override ;
        std::shared_ptr<EvioEvent> parseNextEvent() override ;
        void parseEvent(std::shared_ptr<EvioEvent> evioEvent) override ;
        uint32_t getEventArray(size_t evNumber, std::vector<uint8_t> & vec) override;
        uint32_t getEventBuffer(size_t evNumber, ByteBuffer & buf) override;

    private:

        size_t bufferBytesRemaining() const;
        uint32_t blockBytesRemaining() const;
        std::shared_ptr<EvioEvent> gotoEventNumber(size_t evNumber, bool parse);

    public:

        void rewind() override ;
        ssize_t position() override;
        void close() override ;

        std::shared_ptr<IBlockHeader> getCurrentBlockHeader() override ;
        std::shared_ptr<EvioEvent> gotoEventNumber(size_t evNumber) override ;

        size_t getEventCount() override;
        size_t getBlockCount() override;
    };


}


#endif //EVIO_6_0_EVIOREADERV4_H