CompositeData.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_COMPOSITEDATA_H
#define EVIO_6_0_COMPOSITEDATA_H


#include <vector>
#include <cstring>
#include <string>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <climits>
#include <ios>
#include <iomanip>
#include <exception>
#include <stdexcept>
#include <sstream>
#include <memory>
#include <algorithm>


#include "ByteOrder.h"
#include "ByteBuffer.h"
#include "DataType.h"
#include "BankHeader.h"
#include "SegmentHeader.h"
#include "TagSegmentHeader.h"
#include "EventHeaderParser.h"
#include "EvioNode.h"


#undef COMPOSITE_DEBUG
#undef COMPOSITE_PRINT

// /////////////////////
// Doxygen:
// For some reason doxygen does NOT extract the documentation for the methods of CompositeData class.
// To get around this, just copied the doxygen doc from .cpp to this file.
// ////////////////////

namespace evio {

    class CompositeData {


        typedef struct {
            int left;
            int nrepeat;
            /* Right parenthesis counter, or how many times format in parenthesis already repeated. */
            int irepeat;
        } LV;


    public:

        union SingleMember {

        public:

            // Data being stored

            float     flt;
            double    dbl;
            uint64_t ul64;
            int64_t   l64;
            uint32_t ui32;
            int32_t   i32;
            uint16_t us16;
            int16_t   s16;
            uint8_t   ub8;
            int8_t     b8;
            bool      str;
        };


        class DataItem {

        public:

            SingleMember item = {0};
            std::vector<std::string> strVec {};

            DataItem() = default;

            DataItem(DataItem const &other) {
                item   = other.item;
                strVec = other.strVec;
            };

        };



        class Data  {

        private:

            friend class CompositeData;

            uint32_t dataBytes = 0;

            uint32_t paddingBytes = 0;

            uint32_t pads[4] = {0,3,2,1};

            std::vector<DataItem> dataItems;

            std::vector<DataType> dataTypes;

            std::vector<int32_t> Nlist;

            std::vector<int16_t> nlist;

            std::vector<int8_t> mlist;

            uint16_t formatTag = 0;

            uint16_t dataTag = 0;

            uint8_t dataNum = 0;

        public:

            Data() {
                dataItems.reserve(200);
                dataTypes.reserve(200);
                Nlist.reserve(100);
                nlist.reserve(100);
                mlist.reserve(100);
            }

        private:

            void addBytesToData(uint32_t bytes) {
                dataBytes += bytes;
                // Pad to 4 byte boundaries.
                paddingBytes = pads[dataBytes%4];
            }

        public:
            void setFormatTag(uint16_t tag) {formatTag = tag;}

            void setDataTag(uint16_t tag) {dataTag = tag;}

            void setDataNum(uint8_t num) {dataNum = num;}

            uint16_t getFormatTag() const {return formatTag;}

            uint16_t getDataTag() const {return dataTag;}

            uint8_t getDataNum() const {return dataNum;}

            uint32_t getDataSize() const {return (dataBytes + paddingBytes);}

            uint32_t getPadding() const {return paddingBytes;}

            void addN(uint32_t N) {
                Nlist.push_back(N);
                DataItem mem;
                mem.item.ui32 = N;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::UINT32);
                addBytesToData(4);
            }

            void addn(uint16_t n) {
                nlist.push_back(n);
                DataItem mem;
                mem.item.us16 = n;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::USHORT16);
                addBytesToData(2);
            }

            void addm(uint8_t m) {
                mlist.push_back(m);
                DataItem mem;
                mem.item.ub8 = m;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::UCHAR8);
                addBytesToData(1);
            }

            //-----------------------------------------------------

            void addInt(int32_t i) {
                DataItem mem;
                mem.item.i32 = i;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::INT32);
                addBytesToData(4);
            }

            void addInt(std::vector<int32_t> const & i) {
                for (auto ii : i) {
                    DataItem mem;
                    mem.item.i32 = ii;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::INT32);
                }
                addBytesToData(4 * i.size());
            }

            void addUint(uint32_t i) {
                DataItem mem;
                mem.item.ui32 = i;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::UINT32);
                addBytesToData(4);
            }

            void addUint(std::vector<uint32_t> const & i) {
                for (auto ii : i) {
                    DataItem mem;
                    mem.item.ui32 = ii;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::UINT32);
                }
                addBytesToData(4 * i.size());
            }

            //-----------------------------------------------------

            void addShort(int16_t s) {
                DataItem mem;
                mem.item.s16 = s;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::SHORT16);
                addBytesToData(2);
            }

            void addShort(std::vector<int16_t> const & s) {
                for (auto ii : s) {
                    DataItem mem;
                    mem.item.s16 = ii;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::SHORT16);
                }
                addBytesToData(2 * s.size());
            }

            void addUShort(uint16_t s) {
                DataItem mem;
                mem.item.us16 = s;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::USHORT16);
                addBytesToData(2);
            }

            void addUShort(std::vector<uint16_t> const & s) {
                for (auto ii : s) {
                    DataItem mem;
                    mem.item.us16 = ii;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::USHORT16);
                }
                addBytesToData(2 * s.size());
            }

            //-----------------------------------------------------

            void addLong(int64_t l) {
                DataItem mem;
                mem.item.l64 = l;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::LONG64);
                addBytesToData(8);
            }

            void addLong(std::vector<int64_t> const & l) {
                for (auto ii : l) {
                    DataItem mem;
                    mem.item.l64 = ii;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::LONG64);
                }
                addBytesToData(8 * l.size());
            }

            void addULong(uint64_t l) {
                DataItem mem;
                mem.item.ul64 = l;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::ULONG64);
                addBytesToData(8);
            }

            void addULong(std::vector<uint64_t> const & l) {
                for (auto ii : l) {
                    DataItem mem;
                    mem.item.ul64 = ii;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::ULONG64);
                }
                addBytesToData(8 * l.size());
            }

            //-----------------------------------------------------

            void addChar(int8_t b) {
                DataItem mem;
                mem.item.b8 = b;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::CHAR8);
                addBytesToData(1);
            }

            void addChar(std::vector<int8_t> const & b) {
                for (auto ii : b) {
                    DataItem mem;
                    mem.item.b8 = ii;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::CHAR8);
                }
                addBytesToData(b.size());

            }

            void addUChar(uint8_t b) {
                DataItem mem;
                mem.item.ub8 = b;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::UCHAR8);
                addBytesToData(1);
            }

            void addUChar(std::vector<uint8_t> const & b) {
                for (auto ii : b) {
                    DataItem mem;
                    mem.item.ub8 = ii;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::UCHAR8);
                }
                addBytesToData(b.size());
            }

            //-----------------------------------------------------

            void addFloat(float f) {
                DataItem mem;
                mem.item.flt = f;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::FLOAT32);
                addBytesToData(4);
            }

            void addFloat(std::vector<float> const & f) {
                for (auto ff : f) {
                    DataItem mem;
                    mem.item.flt = ff;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::FLOAT32);
                }
                addBytesToData(4 * f.size());
            }

            void addDouble(double d) {
                DataItem mem;
                mem.item.dbl = d;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::DOUBLE64);
                addBytesToData(8);
            }

            void addDouble(std::vector<double> const & d) {
                for (auto dd : d) {
                    DataItem mem;
                    mem.item.dbl = dd;
                    dataItems.push_back(mem);
                    dataTypes.push_back(DataType::DOUBLE64);
                }
                addBytesToData(8 * d.size());
            }

            //-----------------------------------------------------

            void addString(std::string const & s) {
                std::vector<std::string> v {s};
                DataItem mem;
                mem.item.str = true;
                mem.strVec = v;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::CHARSTAR8);
                addBytesToData(Util::stringsToRawSize(v));
            }

            void addString(std::vector<std::string> const & s) {
                DataItem mem;
                mem.item.str = true;
                mem.strVec = s;
                dataItems.push_back(mem);
                dataTypes.push_back(DataType::CHARSTAR8);
                addBytesToData(Util::stringsToRawSize(s));
            }
        };


    private:

        std::string format;

        std::vector<uint16_t> formatInts;

        std::vector<DataItem> items;

        std::vector<DataType> types;

        std::vector<int32_t> NList;

        std::vector<int16_t> nList;

        std::vector<int8_t> mList;

        std::shared_ptr<TagSegmentHeader> tsHeader;

        std::shared_ptr<BankHeader> bHeader;

        std::vector<uint8_t> rawBytes;

        uint32_t dataBytes = 0;

        uint32_t dataPadding = 0;

        uint32_t dataOffset = 0;

        ByteOrder byteOrder {ByteOrder::ENDIAN_LOCAL};

        /* mutable ? */
        uint32_t getIndex = 0;


//        // Only constructors with raw data or a vector of Data as an arg
//        // are used. That way there is never an "empty" CompositeData object.
//        // Thus, each object will have a raw byte representation generated.

        CompositeData() = default;

        CompositeData(std::string const & format, const Data & data);

        CompositeData(std::string const & format,
                      const Data & data,
                      uint16_t formatTag,
                      uint16_t dataTag, uint8_t dataNum,
                      ByteOrder const & order = ByteOrder::ENDIAN_LOCAL);

        CompositeData(uint8_t *bytes, ByteOrder const & byteOrder);

        CompositeData(ByteBuffer & bytes);

        static std::shared_ptr<CompositeData> getInstance();


    public:


        static std::shared_ptr<CompositeData> getInstance(std::string & format, const Data & data);

        static std::shared_ptr<CompositeData> getInstance(std::string & format,
                                                          const Data & data,
                                                          uint16_t formatTag,
                                                          uint16_t dataTag, uint8_t dataNum,
                                                          ByteOrder const & order = ByteOrder::ENDIAN_LOCAL);

        static std::shared_ptr<CompositeData> getInstance(uint8_t *bytes,
                                                          ByteOrder const & order = ByteOrder::ENDIAN_LOCAL);

        static std::shared_ptr<CompositeData> getInstance(ByteBuffer & bytes);

        static void parse(uint8_t *bytes, size_t bytesSize, ByteOrder const & order,
                          std::vector<std::shared_ptr<CompositeData>> & list);

        static void generateRawBytes(std::vector<std::shared_ptr<CompositeData>> & data,
                                     std::vector<uint8_t> & rawBytes, ByteOrder & order);

        static std::string stringsToFormat(std::vector<std::string> strings);


        static int compositeFormatToInt(const std::string & formatStr, std::vector<uint16_t> & ifmt);



        uint32_t getPadding() const;
        std::string getFormat() const;
        ByteOrder getByteOrder() const;


        std::vector<uint8_t> & getRawBytes();
        std::vector<DataItem> & getItems();


        std::vector<DataType> & getTypes();
        std::vector<int32_t>  & getNValues();
        std::vector<int16_t>  & getnValues();
        std::vector<int8_t>   & getmValues();


        uint32_t index() const;
        void index(uint32_t index);


        int32_t getNValue();
        int16_t getnValue();
        int8_t  getmValue();
        int32_t getHollerit();


        int8_t  getChar();
        uint8_t getUChar();


        int16_t  getShort();
        uint16_t getUShort();
        int32_t  getInt();
        uint32_t getUInt();


        int64_t  getLong();
        uint64_t getULong();


        float  getFloat();
        double getDouble();


        std::vector<std::string> & getStrings();


        void swap();


        static void swapAll(uint8_t *src, uint8_t *dest, size_t length, bool srcIsLocal);


        // Swap in place
        static void swapAll(ByteBuffer & buf, uint32_t srcPos, uint32_t len);
        static void swapAll(std::shared_ptr<ByteBuffer> & buf, uint32_t srcPos, uint32_t len);


        // Swap elsewhere

        static void swapAll(std::shared_ptr<ByteBuffer> & srcBuf,
                            std::shared_ptr<ByteBuffer> & destBuf,
                            uint32_t srcPos, uint32_t destPos, uint32_t len);
        static void swapAll(ByteBuffer & srcBuffer, ByteBuffer & destBuffer,
                            uint32_t srcPos, uint32_t destPos, uint32_t len);



        static void swapData(ByteBuffer & srcBuf, ByteBuffer & destBuf,
                             size_t nBytes, const std::vector<uint16_t> & ifmt);
        static void swapData(std::shared_ptr<ByteBuffer> & srcBuf,
                             std::shared_ptr<ByteBuffer> & destBuf,
                             size_t srcPos, size_t destPos, size_t nBytes,
                             const std::vector<uint16_t> & ifmt);
        static void swapData(ByteBuffer & srcBuf, ByteBuffer & destBuf,
                             size_t srcPos, size_t destPos, size_t nBytes,
                             const std::vector<uint16_t> & ifmt);
        static void swapData(int32_t *src, int32_t *dest, size_t nwrd,
                             const std::vector<uint16_t> & ifmt,
                             uint32_t padding, bool srcIsLocal);

        // This is an in-place swap

        static void swapData(int32_t *iarr, int nwrd, const std::vector<uint16_t> & ifmt,
                             uint32_t padding);


        static void dataToRawBytes(ByteBuffer & rawBuf, Data const & data,
                                   std::vector<uint16_t> & ifmt);


        void process();


        std::string toString() const;
        std::string toString(const std::string & indent, bool hex);
        std::string toString(bool hex) const;
    };


}


#endif //EVIO_6_0_COMPOSITEDATA_H