EventHeaderParser.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_EVENTHEADERPARSER_H
#define EVIO_6_0_EVENTHEADERPARSER_H


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


#include "ByteOrder.h"
#include "BankHeader.h"
#include "SegmentHeader.h"
#include "TagSegmentHeader.h"
#include "EvioNode.h"


namespace evio {


    class EventHeaderParser {

    public:

        static std::shared_ptr<BankHeader> createBankHeader(uint8_t * bytes, ByteOrder const & byteOrder) {

            std::shared_ptr<BankHeader> header = std::make_shared<BankHeader>();

            // Does the length make sense?
            uint32_t len = 0;
            Util::toIntArray(reinterpret_cast<char *>(bytes), 4, byteOrder, &len);

            header->setLength(len);
            bytes += 4;

            // Read and parse second header word
            uint32_t word = 0;
            Util::toIntArray(reinterpret_cast<char *>(bytes), 4, byteOrder, &word);

            header->setTag(word >> 16);
            int dt = (word >> 8) & 0xff;
            int type = dt & 0x3f;
            uint8_t padding = dt >> 6;
            header->setDataType(type);
            header->setPadding(padding);
            header->setNumber(word);

            return header;
        }


        static std::shared_ptr<SegmentHeader> createSegmentHeader(uint8_t * bytes, ByteOrder const & byteOrder) {

            std::shared_ptr<SegmentHeader> header = std::make_shared<SegmentHeader>();

            // Read and parse header word
            uint32_t word = 0;
            Util::toIntArray(reinterpret_cast<char *>(bytes), 4, byteOrder, &word);

            uint32_t len = word & 0xffff;
            header->setLength(len);

            int dt = (word >> 16) & 0xff;
            int type = dt & 0x3f;
            int padding = dt >> 6;
            header->setDataType(type);
            header->setPadding(padding);
            header->setTag(word >> 24);

            return header;
        }


        static std::shared_ptr<TagSegmentHeader> createTagSegmentHeader(uint8_t * bytes, ByteOrder const & byteOrder) {

            std::shared_ptr<TagSegmentHeader> header = std::make_shared<TagSegmentHeader>();

            // Read and parse header word
            uint32_t word = 0;
            Util::toIntArray(reinterpret_cast<char *>(bytes), 4, byteOrder, &word);

            uint32_t len = word & 0xffff;
            header->setLength(len);
            header->setDataType((word >> 16) & 0xf);
            header->setTag(word >> 20);

            return header;
        }


        static void swapBankHeader(std::shared_ptr<EvioNode> & node,
                                   std::shared_ptr<ByteBuffer> & srcBuffer,
                                   std::shared_ptr<ByteBuffer> & destBuffer,
                                   uint32_t srcPos, uint32_t destPos) {
            swapBankHeader(*(node.get()), *(srcBuffer.get()), *(destBuffer.get()), srcPos, destPos);
        }


        static void swapBankHeader(EvioNode & node, ByteBuffer & srcBuffer, ByteBuffer & destBuffer,
                                   uint32_t srcPos, uint32_t destPos) {

            // Check endianness
            if (srcBuffer.order() == destBuffer.order()) {
                throw evio::EvioException("src & dest buffers need different byte order for swapping");
            }

            // Read & swap first bank header word
            uint32_t length = srcBuffer.getInt(srcPos);
            destBuffer.putInt(destPos, length);
            srcPos  += 4;
            destPos += 4;

            // Read & swap second bank header word
            uint32_t word = srcBuffer.getInt(srcPos);
            destBuffer.putInt(destPos, word);

            node.tag      = (word >> 16) & 0xffff;
            uint32_t dt   = (word >> 8) & 0xff;

            node.dataType = dt & 0x3f;
            node.pad      = dt >> 6;
            node.num      = word & 0xff;
            node.len      = length;
            node.pos      = destPos - 4;
            node.dataPos  = destPos + 4;
            node.dataLen  = length - 1;
        }


        static void swapSegmentHeader(std::shared_ptr<EvioNode> & node,
                                      std::shared_ptr<ByteBuffer> & srcBuffer,
                                      std::shared_ptr<ByteBuffer> & destBuffer,
                                      uint32_t srcPos, uint32_t destPos) {
            swapSegmentHeader(*(node.get()), *(srcBuffer.get()), *(destBuffer.get()), srcPos, destPos);
        }


        static void swapSegmentHeader(EvioNode & node, ByteBuffer & srcBuffer, ByteBuffer & destBuffer,
                                      uint32_t srcPos, uint32_t destPos) {

            if (srcBuffer.order() == destBuffer.order()) {
                throw evio::EvioException("src & dest buffers need different byte order for swapping");
            }

            // Read & swap segment header word
            uint32_t word = srcBuffer.getInt(srcPos);
            destBuffer.putInt(destPos, word);

            node.tag      = (word >> 24) & 0xff;
            uint32_t dt   = (word >> 16) & 0xff;
            node.dataType = dt & 0x3f;
            node.pad      = dt >> 6;
            node.len      = word & 0xffff;
            node.num      = 0;
            node.pos      = destPos;
            node.dataPos  = destPos + 4;
            node.dataLen  = node.len;
        }


        static void swapTagSegmentHeader(std::shared_ptr<EvioNode> & node,
                                         std::shared_ptr<ByteBuffer> & srcBuffer,
                                         std::shared_ptr<ByteBuffer> & destBuffer,
                                         uint32_t srcPos, uint32_t destPos) {
            swapTagSegmentHeader(*(node.get()), *(srcBuffer.get()), *(destBuffer.get()), srcPos, destPos);
        }


        static void swapTagSegmentHeader(EvioNode & node, ByteBuffer & srcBuffer, ByteBuffer & destBuffer,
                                         uint32_t srcPos, uint32_t destPos) {

            if (srcBuffer.order() == destBuffer.order()) {
                throw evio::EvioException("src & dest buffers need different byte order for swapping");
            }

            // Read & swap tagsegment header word
            uint32_t word = srcBuffer.getInt(srcPos);
            destBuffer.putInt(destPos, word);

            node.tag      = (word >> 20) & 0xfff;
            node.dataType = (word >> 16) & 0xf;
            node.len      = word & 0xffff;
            node.num      = 0;
            node.pad      = 0;
            node.pos      = destPos;
            node.dataPos  = destPos + 4;
            node.dataLen  = node.len;
        }


    };


}

#endif //EVIO_6_0_EVENTHEADERPARSER_H