EvioCompactReaderV4.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_EVIOCOMPACTREADERV4_H
#define EVIO_6_0_EVIOCOMPACTREADERV4_H


#include <stdexcept>
#include <vector>
#include <memory>
#include <limits>
#include <climits>
#include <string>
#include <cstdio>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fstream>
#include <sys/mman.h>
#include <mutex>
#include <sys/mman.h>


#include "ByteBuffer.h"
#include "ByteOrder.h"
#include "BaseStructure.h"
#include "IEvioCompactReader.h"
#include "IEvioReader.h"
#include "EvioReaderV4.h"
#include "IBlockHeader.h"
#include "EvioNode.h"
#include "RecordNode.h"


namespace evio {


    class EvioCompactReaderV4 : public IEvioCompactReader {

    public:

        static const int BLOCK_SIZE_OFFSET = 0;

        static const int BLOCK_NUMBER = 4;

        static const int BLOCK_HEADER_SIZE_OFFSET = 8;

        static const int BLOCK_EVENT_COUNT = 12;

        static const  int BLOCK_RESERVED_1 = 16;

        static const int VERSION_MASK = 0xff;

    private:

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

        std::unordered_map<uint32_t, std::shared_ptr<RecordNode>> blockNodes;

        int32_t eventCount = -1;

        uint32_t evioVersion = 4;

        ByteOrder byteOrder {ByteOrder::ENDIAN_LOCAL};

        int32_t blockCount = -1;

        uint32_t firstBlockHeaderWords = 0;

        std::shared_ptr<BlockHeaderV4> blockHeader;

        bool hasDict = false;

        std::string dictionaryXML;

        std::shared_ptr<EvioXMLDictionary> dictionary = nullptr;

        std::shared_ptr<ByteBuffer> byteBuffer = nullptr;

        size_t initialPosition = 0;

        size_t validDataWords = 0;

        bool closed = false;

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

        bool readingFile = false;

        std::ifstream file;

        std::string path = "";

        size_t fileBytes = 0;

    public:

        explicit EvioCompactReaderV4(std::string const & path);
        explicit EvioCompactReaderV4(std::shared_ptr<ByteBuffer> & byteBuffer);

        void setBuffer(std::shared_ptr<ByteBuffer> & buf) override ;

        bool isFile() override ;
        bool isCompressed() override ;
        bool isClosed() override ;
        ByteOrder getByteOrder() override ;
        uint32_t getEvioVersion() override ;
        std::string getPath() override ;
        ByteOrder getFileByteOrder() override ;
        std::string getDictionaryXML() override ;
        std::shared_ptr<EvioXMLDictionary> getDictionary() override ;
        bool hasDictionary() override ;

    private:

        void mapFile(std::string const & filename, size_t fileS);
        void generateEventPositionTable();

    public:

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

        std::shared_ptr<EvioNode> getEvent(size_t eventNumber) override ;
        std::shared_ptr<EvioNode> getScannedEvent(size_t eventNumber) override ;

        std::shared_ptr<IBlockHeader> getFirstBlockHeader() override ;

    private:

        IEvioReader::ReadWriteStatus readFirstHeader();
        void readDictionary();
        std::shared_ptr<EvioNode> scanStructure(size_t eventNumber);

    public:

        void searchEvent(size_t eventNumber, uint16_t tag, uint8_t num,
                         std::vector<std::shared_ptr<EvioNode>> & vec) override ;
        void searchEvent(size_t eventNumber, std::string const & dictName,
                         std::shared_ptr<EvioXMLDictionary> & dictionary,
                         std::vector<std::shared_ptr<EvioNode>> & vec) override ;


        std::shared_ptr<ByteBuffer> removeEvent(size_t eventNumber) override ;

        std::shared_ptr<ByteBuffer> removeStructure(std::shared_ptr<EvioNode> & removeNode) override ;
        std::shared_ptr<ByteBuffer> addStructure(size_t eventNumber, ByteBuffer & addBuffer) override ;

        std::shared_ptr<ByteBuffer> getData(std::shared_ptr<EvioNode> & node) override ;
        std::shared_ptr<ByteBuffer> getData(std::shared_ptr<EvioNode> & node, bool copy) override ;

        std::shared_ptr<ByteBuffer> getData(std::shared_ptr<EvioNode> & node,
                                            std::shared_ptr<ByteBuffer> & buf) override ;
        std::shared_ptr<ByteBuffer> getData(std::shared_ptr<EvioNode> & node,
                                            std::shared_ptr<ByteBuffer> & buf, bool copy) override ;

        std::shared_ptr<ByteBuffer> getEventBuffer(size_t eventNumber) override ;
        std::shared_ptr<ByteBuffer> getEventBuffer(size_t eventNumber, bool copy) override ;

        std::shared_ptr<ByteBuffer> getStructureBuffer(std::shared_ptr<EvioNode> & node) override ;
        std::shared_ptr<ByteBuffer> getStructureBuffer(std::shared_ptr<EvioNode> & node, bool copy) override ;

        void close() override ;

        uint32_t  getEventCount() override ;
        uint32_t getBlockCount() override ;

        void toFile(std::string const & fileName) override ;
    };

}

#endif //EVIO_6_0_EVIOCOMPACTREADERV4_H