RecordOutput.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_RECORDOUTPUT_H
#define EVIO_6_0_RECORDOUTPUT_H


#include <cstdlib>
#include <cstdint>
#include <cstdio>
#include <vector>
#include <memory>


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


namespace evio {


    class RecordOutput {

    public:

        static constexpr int ONE_MEG = 1024*1024;

        uint32_t MAX_EVENT_COUNT = 1000000;

        uint32_t MAX_BUFFER_SIZE = 8*ONE_MEG;

        uint32_t RECORD_BUFFER_SIZE = 9*ONE_MEG;

        uint32_t userBufferSize = 0;

        uint32_t eventCount = 0;

        uint32_t indexSize = 0;

        uint32_t eventSize = 0;

        size_t startingPosition = 0;

        std::shared_ptr<ByteBuffer> recordIndex;

        std::shared_ptr<ByteBuffer> recordEvents;

        std::shared_ptr<ByteBuffer> recordData;

        std::shared_ptr<ByteBuffer> recordBinary;

        std::shared_ptr<RecordHeader> header;

        ByteOrder byteOrder {ByteOrder::ENDIAN_LOCAL};

        bool userProvidedBuffer = false;


    public:


        RecordOutput();

        explicit RecordOutput(const ByteOrder & order,
                              uint32_t maxEventCount = 1000000,
                              uint32_t maxBufferSize = 8*ONE_MEG,
                              Compressor::CompressionType compressionType = Compressor::UNCOMPRESSED,
                              HeaderType hType = HeaderType::EVIO_RECORD);

        RecordOutput(std::shared_ptr<ByteBuffer> & buffer, uint32_t maxEventCount,
                     Compressor::CompressionType compressionType, HeaderType hType);

        RecordOutput(const RecordOutput & srcRec);
        RecordOutput(RecordOutput && srcBuf) noexcept;

        RecordOutput & operator=(RecordOutput&& other) noexcept;
        RecordOutput & operator=(const RecordOutput& other);

        ~RecordOutput() = default;


    private:


        void allocate();
        bool allowedIntoRecord(uint32_t length);
        void copy(const RecordOutput & rec);


    public:


        void setBuffer(std::shared_ptr<ByteBuffer> & buf);
        void transferDataForReading(const RecordOutput & rec);

        uint32_t getUserBufferSize() const;
        uint32_t getUncompressedSize() const;
        uint32_t getInternalBufferCapacity() const;
        uint32_t getMaxEventCount() const;
        uint32_t getEventCount() const;

        std::shared_ptr<RecordHeader> & getHeader();
        const ByteOrder & getByteOrder() const;
        const std::shared_ptr<ByteBuffer> getBinaryBuffer() const;
        const Compressor::CompressionType getCompressionType() const;
        const HeaderType getHeaderType() const;

        bool hasUserProvidedBuffer() const;
        bool roomForEvent(uint32_t length) const;
        bool oneTooMany() const;

        bool addEvent(const uint8_t * event, uint32_t eventLen, uint32_t extraDataLen = 0);

        bool addEvent(const std::vector<uint8_t> & event);
        bool addEvent(const std::vector<uint8_t> & event, size_t offset, uint32_t eventLen, uint32_t extraDataLen = 0);

        bool addEvent(const ByteBuffer & event, uint32_t extraDataLen = 0);
        bool addEvent(const std::shared_ptr<ByteBuffer> & event, uint32_t extraDataLen = 0);

        bool addEvent(EvioNode & node, uint32_t extraDataLen = 0);
        bool addEvent(std::shared_ptr<EvioNode> & node, uint32_t extraDataLen = 0);

        bool addEvent(EvioBank & event, uint32_t extraDataLen);
        bool addEvent(std::shared_ptr<EvioBank> & event, uint32_t extraDataLen = 0);

        void reset();

        void setStartingBufferPosition(size_t pos);

        void build();
        void build(std::shared_ptr<ByteBuffer> userHeader);
        void build(const ByteBuffer & userHeader);

    };

}


#endif //EVIO_6_0_RECORDOUTPUT_H