Reader.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_READER_H
#define EVIO_6_0_READER_H


#include <cstdint>
#include <cstring>
#include <string>
#include <vector>
#include <fstream>
#include <ios>
#include <iostream>
#include <stdexcept>
#include <memory>


#include "ByteOrder.h"
#include "ByteBuffer.h"
#include "FileHeader.h"
#include "RecordHeader.h"
#include "FileEventIndex.h"
#include "RecordInput.h"
#include "EvioException.h"
#include "EvioNode.h"
#include "IBlockHeader.h"
#include "Util.h"


namespace evio {

    class Reader {

        friend class EvioCompactReaderV6;

    private:


        class RecordPosition {

        private:

            size_t position;

            uint32_t length;

            uint32_t count;

        public:

            explicit RecordPosition(size_t pos) {
                count = length = 0;
                position = pos;
            }

            RecordPosition(size_t pos, uint32_t len, uint32_t cnt) {
                position = pos;
                length = len;
                count = cnt;
            }

            RecordPosition setPosition(size_t _pos) {
                position = _pos;
                return *this;
            }

            RecordPosition setLength(uint32_t _len) {
                length = _len;
                return *this;
            }

            RecordPosition setCount(uint32_t _cnt) {
                count = _cnt;
                return *this;
            }

            size_t getPosition() const { return position; }

            uint32_t getLength() const { return length; }

            uint32_t getCount() const { return count; }

            std::string toString() const {
                std::stringstream ss;
                ss << " POSITION = " << std::setw(16) << position << ", LENGTH = " << std::setw(12) <<
                        length << ", COUNT = " << std::setw(8) << count << std::endl;
                return ss.str();
            }
        };


        static const uint32_t headerInfoLen = 8;


        std::vector<RecordPosition> recordPositions;
        std::ifstream inStreamRandom;
        std::string fileName {""};
        size_t fileSize = 0;
        FileHeader fileHeader;
        bool fromFile = true;


        std::shared_ptr<ByteBuffer> buffer = nullptr;
        size_t bufferOffset = 0;
        size_t bufferLimit = 0;


        RecordInput inputRecordStream;
        uint32_t currentRecordLoaded = 0;
        // TODO: Look at this
        std::shared_ptr<RecordHeader> firstRecordHeader = nullptr;
        uint32_t recordNumberExpected = 1;
        bool checkRecordNumberSequence = false;
        FileEventIndex eventIndex;


        std::string dictionaryXML {""};
        std::shared_ptr<uint8_t> firstEvent = nullptr;
        uint32_t firstEventSize = 0;

        // TODO: The HIPO library is NOT evio dependent!!!!

        std::vector<std::shared_ptr<EvioNode>> eventNodes;


        bool closed = false;
        bool compressed = false;
        ByteOrder byteOrder {ByteOrder::ENDIAN_LOCAL};
        int32_t sequentialIndex = -1;

        bool evioFormat = true;

        bool lastCalledSeqNext = false;
        uint32_t evioVersion = 6;



        void setByteOrder(ByteOrder & order);
        static uint32_t getTotalByteCounts(ByteBuffer & buf, uint32_t* info, uint32_t infoLen);
        static uint32_t getTotalByteCounts(std::shared_ptr<ByteBuffer> & buf, uint32_t* info, uint32_t infoLen);
        //static std::string getStringArray(ByteBuffer & buffer, int wrap, int max);
        //static std::string getHexStringInt(int32_t value);

    public:

        Reader();
        explicit Reader(std::string const & filename);
        Reader(std::string const & filename, bool forceScan);
        explicit Reader(std::shared_ptr<ByteBuffer> & buffer, bool checkRecordNumSeq = false);

        ~Reader() = default;

        void open(std::string const & filename, bool scan = true);
        void close();

        bool isClosed() const;
        bool isFile() const;

        std::string getFileName() const;
        size_t getFileSize() const;

        void setBuffer(std::shared_ptr<ByteBuffer> & buf);
        std::shared_ptr<ByteBuffer> getBuffer();
        size_t getBufferOffset() const;

        FileHeader & getFileHeader();
        std::shared_ptr<RecordHeader> & getFirstRecordHeader();

        ByteOrder & getByteOrder();
        uint32_t getVersion() const;
        bool isCompressed() const;
        bool isEvioFormat() const;
        std::string getDictionary();
        bool hasDictionary() const;

        std::shared_ptr<uint8_t> & getFirstEvent(uint32_t *size);
        uint32_t getFirstEventSize();
        bool hasFirstEvent() const;

        uint32_t getEventCount() const;
        uint32_t getRecordCount() const;

        std::vector<RecordPosition> & getRecordPositions();
        std::vector<std::shared_ptr<EvioNode>> & getEventNodes();

        bool getCheckRecordNumberSequence() const;

        uint32_t getNumEventsRemaining() const;

        std::shared_ptr<uint8_t> getNextEvent(uint32_t * len);
        std::shared_ptr<uint8_t> getPrevEvent(uint32_t * len);

        std::shared_ptr<EvioNode> getNextEventNode();
        std::shared_ptr<ByteBuffer> readUserHeader();

        std::shared_ptr<uint8_t> getEvent(uint32_t index, uint32_t * len);
        ByteBuffer & getEvent(ByteBuffer & buf, uint32_t index);
        std::shared_ptr<ByteBuffer> getEvent(std::shared_ptr<ByteBuffer> & buf, uint32_t index);
        uint32_t getEventLength(uint32_t index);
        std::shared_ptr<EvioNode> getEventNode(uint32_t index);

        bool hasNext() const;
        bool hasPrev() const;

        uint32_t getRecordEventCount() const;
        uint32_t getCurrentRecord() const;
        RecordInput & getCurrentRecordStream();
        bool readRecord(uint32_t index);


    protected:

        void extractDictionaryAndFirstEvent();
        void extractDictionaryFromBuffer();
        void extractDictionaryFromFile();


        static void findRecordInfo(std::shared_ptr<ByteBuffer> & buf, uint32_t offset,
                                   uint32_t* info, uint32_t infoLen);
        static void findRecordInfo(ByteBuffer & buf, uint32_t offset,
                                   uint32_t* info, uint32_t infoLen);


        std::shared_ptr<ByteBuffer> scanBuffer();
        void scanUncompressedBuffer();
        void forceScanFile();
        void scanFile(bool force);

        // The next 2 methods will not work on events which are not evio format data.
        // They are included here so other classes, like EvioCompactReader and EvioReader,
        // can use their APIs to call the new evio version 6 classes like this one.
        // These new classes were initially designed to be data format agnostic, but adding
        // these methods violates that.
        std::shared_ptr<ByteBuffer> & addStructure(uint32_t eventNumber, ByteBuffer & addBuffer);
        std::shared_ptr<ByteBuffer> & removeStructure(std::shared_ptr<EvioNode> & removeNode);

        void show() const;

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

    };

}


#endif //EVIO_6_0_READER_H