CompactEventBuilder.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_COMPACTEVENTBUILDER_H
#define EVIO_6_0_COMPACTEVENTBUILDER_H


#include <vector>
#include <memory>
#include <cstring>


#include "ByteOrder.h"
#include "ByteBuffer.h"
#include "DataType.h"
#include "EvioNode.h"
#include "EvioSwap.h"
#include "Util.h"
#include "FileHeader.h"
#include "RecordHeader.h"


namespace evio {

    class CompactEventBuilder {

    private:

        std::shared_ptr<ByteBuffer> buffer = nullptr;

        uint8_t * array = nullptr;

        size_t arrayOffset = 0;

        size_t position = 0;

        ByteOrder order {ByteOrder::ENDIAN_LOCAL};

        bool createdBuffer = false;

        bool generateNodes = false;

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

        static const uint32_t MAX_LEVELS = 50;

        static const uint32_t padCount[];


        class StructureContent {
          public:

            size_t pos = 0;
            uint32_t dataLen = 0;
            uint32_t padding = 0;
            DataType type {DataType::BANK};
            DataType dataType {DataType::UNKNOWN32};

            StructureContent() = default;

            void setData(size_t pos, DataType const & type, DataType const & dataType) {
                this->pos = pos;
                this->type = type;
                this->dataType = dataType;
                padding = dataLen = 0;
            }
        };


        std::vector<std::shared_ptr<StructureContent>> stackArray;

        std::vector<uint32_t> totalLengths;

        std::shared_ptr<StructureContent> currentStructure = nullptr;

        int32_t currentLevel = -1;


    public:

        CompactEventBuilder(size_t bufferSize, ByteOrder const & order, bool generateNodes = false);
        explicit CompactEventBuilder(std::shared_ptr<ByteBuffer> buffer, bool generateNodes = false);

        void setBuffer(std::shared_ptr<ByteBuffer> buffer, bool generateNodes = false);

    private:

        void initBuffer(std::shared_ptr<ByteBuffer> buffer, bool generateNodes);

    public:

        std::shared_ptr<ByteBuffer> getBuffer();

        size_t getTotalBytes() const;

        std::shared_ptr<EvioNode> openSegment(uint16_t tag, DataType const & dataType);
        std::shared_ptr<EvioNode> openTagSegment(int tag, DataType dataType);
        std::shared_ptr<EvioNode> openBank(uint16_t tag, DataType const & dataType, uint8_t num);

        bool closeStructure();
        void closeAll();

        void setTopLevelTag(short tag);

    private:

        void addToAllLengths(uint32_t len);

        void setCurrentHeaderLength(uint32_t len);
        void setCurrentHeaderPadding(uint32_t padding);

        void writeHeader(std::shared_ptr<EvioNode> & node);
        void writeNode(std::shared_ptr<EvioNode> & node, bool swapData);

    public:

        void addEvioNode(std::shared_ptr<EvioNode> node);

        void addByteData(uint8_t * data, uint32_t len);
        void addIntData(uint32_t * data, uint32_t len);
        void addShortData(uint16_t * data, uint32_t len);
        void addLongData(uint64_t * data, uint32_t len);
        void addFloatData(float * data, uint32_t len);
        void addDoubleData(double * data, uint32_t len);
        void addStringData(std::vector<std::string> & strings);
        void addCompositeData(std::vector<std::shared_ptr<CompositeData>> & data);

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

    };


}


#endif //EVIO_6_0_COMPACTEVENTBUILDER_H