Writer.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_WRITER_H
#define EVIO_6_0_WRITER_H


#include <fstream>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <string>
#include <future>
#include <chrono>
#include <memory>


#include "FileHeader.h"
#include "ByteBuffer.h"
#include "ByteOrder.h"
#include "EvioNode.h"
#include "RecordOutput.h"
#include "RecordHeader.h"
#include "Compressor.h"
#include "Util.h"
#include "EvioException.h"


namespace evio {


    class Writer {

    private:

        bool toFile = true;

        // If writing to file ...

        std::string fileName = "";
        std::ofstream outFile;
        FileHeader fileHeader;
        std::future<void> future;
        std::shared_ptr<RecordOutput> unusedRecord = nullptr;

        // If writing to buffer ...

        std::shared_ptr<ByteBuffer> buffer;

        // For both files & buffers

        std::shared_ptr<ByteBuffer> userHeaderBuffer = nullptr;
        uint8_t* userHeader = nullptr;
        uint32_t userHeaderLength = 0;
        std::string dictionary;
        std::shared_ptr<ByteBuffer> dictionaryFirstEventBuffer;
        uint8_t* firstEvent = nullptr;
        uint32_t firstEventLength = 0;

        ByteOrder byteOrder {ByteOrder::ENDIAN_LOCAL};
        std::shared_ptr<RecordOutput> outputRecord = nullptr;
        std::shared_ptr<RecordOutput> beingWrittenRecord = nullptr;
        std::vector<uint8_t> headerArray;

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

        std::shared_ptr<std::vector<uint32_t>> recordLengths;

        size_t writerBytesWritten = 0;
        uint32_t recordNumber = 1;

        bool addingTrailer = true;
        bool addTrailerIndex = false;
        bool closed = false;
        bool opened = false;
        bool firstRecordWritten = false;
        bool haveDictionary = false;
        bool haveFirstEvent = false;
        bool haveUserHeader = false;

    public:

        // Writing to file

        Writer();

        explicit Writer(const ByteOrder & order,
                        uint32_t maxEventCount = 0,
                        uint32_t maxBufferSize = 0);

        Writer(const std::string & filename,
               const ByteOrder & order,
               uint32_t maxEventCount = 0,
               uint32_t maxBufferSize = 0);

        explicit Writer(const HeaderType & hType,
                        const ByteOrder & order = ByteOrder::ENDIAN_LOCAL,
                        uint32_t maxEventCount = 0,
                        uint32_t maxBufferSize = 0,
                        const std::string & dictionary = std::string(""),
                        uint8_t* firstEvent = nullptr,
                        uint32_t firstEventLength = 0,
                        const Compressor::CompressionType & compressionType = Compressor::UNCOMPRESSED,
                        bool addTrailerIndex = false);

        // Writing to buffer

        explicit Writer(std::shared_ptr<ByteBuffer> & buf);
        Writer(std::shared_ptr<ByteBuffer> & buf, uint8_t * userHdr, uint32_t len);
        Writer(std::shared_ptr<ByteBuffer> & buf, uint32_t maxEventCount, uint32_t maxBufferSize,
               const std::string & dictionary, uint8_t* firstEvent, uint32_t firstEventLength);

        ~Writer() = default;



    private:

        //    Writer & operator=(Writer&& other) noexcept;
        // Don't allow assignment
        Writer & operator=(const Writer& other);

        std::shared_ptr<ByteBuffer> createDictionaryRecord();
        void writeOutput();
        void writeOutputToBuffer();

        static void staticWriteFunction(Writer *pWriter, const char* data, size_t len);

    public:

        const ByteOrder & getByteOrder() const;
        std::shared_ptr<ByteBuffer> getBuffer();
        FileHeader  & getFileHeader();
//    RecordHeader & getRecordHeader();
//    RecordOutput & getRecord();
        Compressor::CompressionType getCompressionType();
        void setCompressionType(Compressor::CompressionType compression);

        bool addTrailer() const;
        void addTrailer(bool add);
        bool addTrailerWithIndex();
        void addTrailerWithIndex(bool addTrailingIndex);

        void open(const std::string & filename);
        void open(const std::string & filename, uint8_t* userHdr, uint32_t len);
        void open(std::shared_ptr<ByteBuffer> & buf,  uint8_t* userHdr, uint32_t len);

        static std::shared_ptr<ByteBuffer> createRecord(const std::string & dictionary,
                                                        uint8_t* firstEvent, uint32_t firstEventLen,
                                                        const ByteOrder & byteOrder,
                                                        FileHeader* fileHeader,
                                                        RecordHeader* recordHeader);

        std::shared_ptr<ByteBuffer> createHeader(uint8_t* userHdr, uint32_t userLen);
        std::shared_ptr<ByteBuffer> createHeader(ByteBuffer & userHdr);
        void createHeader(ByteBuffer & buf, uint8_t* userHdr, uint32_t userLen);
        void createHeader(ByteBuffer & buf, ByteBuffer & userHdr);

        void writeRecord(RecordOutput & record);

        // Use internal RecordOutput to write individual events

        void addEvent(uint8_t* buffer, uint32_t length);
        void addEvent(std::shared_ptr<ByteBuffer> & buffer);
        void addEvent(ByteBuffer & buffer);
        void addEvent(std::shared_ptr<EvioBank> & bank);
        void addEvent(std::shared_ptr<EvioNode> & node);
        void addEvent(EvioNode & node);

        void reset();
        void close();

    private:

        void writeTrailer(bool writeIndex, uint32_t recordNum, uint64_t trailerPos);

    };

}


#endif //EVIO_6_0_WRITER_H