StructureTransformer.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_STRUCTURETRANSFORMER_H
#define EVIO_6_0_STRUCTURETRANSFORMER_H


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


#include "BankHeader.h"
#include "SegmentHeader.h"
#include "TagSegmentHeader.h"
#include "DataType.h"
#include "EvioBank.h"
#include "EvioSegment.h"
#include "EvioTagSegment.h"


namespace evio {

    class StructureTransformer {

    public:

        // Segment --> Bank

        static std::shared_ptr<EvioBank> transform(std::shared_ptr<EvioSegment> const & segment, uint8_t num) {
            // Copy over header & create new EvioBank
            auto const & segHeader = segment->getHeader();
            auto bank = EvioBank::getInstance(segHeader->getTag(), segHeader->getDataType(), num);
            auto const & bankHeader = bank->getHeader();
            bankHeader->setLength(segHeader->getLength() + 1);
            bankHeader->setPadding(segHeader->getPadding());

            // Copy over the data (take care of padding)
            bank->transform(segment);
            return bank;
        }

        static void copy(std::shared_ptr<EvioBank> const & bank,
                         std::shared_ptr<EvioSegment> const & segment,
                         uint8_t num) {

            // Copy over header
            auto const & segHeader  = segment->getHeader();
            auto const & bankHeader = bank->getHeader();
            bankHeader->copy(segHeader);
            bankHeader->setNumber(num);
            bankHeader->setLength(segHeader->getLength() + 1);
            bankHeader->setPadding(segHeader->getPadding());

            // Copy over the data (take care of padding)
            bank->transform(segment);
        }

        // TagSegment --> Bank

        static std::shared_ptr<EvioBank> transform(std::shared_ptr<EvioTagSegment> const & tagsegment, uint8_t num) {
            auto const & tagsegHeader = tagsegment->getHeader();
            auto bank = EvioBank::getInstance(tagsegHeader->getTag(), tagsegHeader->getDataType(), num);
            auto const & bankHeader = bank->getHeader();
            bankHeader->setLength(tagsegHeader->getLength() + 1);

            bank->transform(tagsegment);
            return bank;
        }

        static void copy(std::shared_ptr<EvioBank> const & bank,
                         std::shared_ptr<EvioTagSegment> const & tagsegment,
                         uint8_t num) {

            auto const & tagsegHeader = tagsegment->getHeader();
            auto const & bankHeader = bank->getHeader();
            bankHeader->copy(tagsegHeader);
            bankHeader->setNumber(num);
            bankHeader->setLength(tagsegHeader->getLength() + 1);

            bank->transform(tagsegment);
        }

        // Segment --> TagSegment

        static std::shared_ptr<EvioTagSegment> transform(std::shared_ptr<EvioSegment> const & segment) {
            auto const & segHeader = segment->getHeader();
            auto ts = EvioTagSegment::getInstance(segHeader->getTag(), segHeader->getDataType());
            auto const & tsHeader = ts->getHeader();
            tsHeader->setLength(segHeader->getLength());
            tsHeader->setPadding(segHeader->getPadding());

            // Change 6 bit content type to 4 bits. Do this by changing
            // BANK to ALSOBANK, SEGMENT to ALSOSEGMENT
            DataType const & segType = segHeader->getDataType();
            if (segType == DataType::BANK) {
                tsHeader->setDataType(DataType::ALSOBANK);
            }
            else if (segType == DataType::SEGMENT) {
                tsHeader->setDataType(DataType::ALSOSEGMENT);
            }

            ts->transform(segment);
            return ts;
        }

        static void copy(std::shared_ptr<EvioTagSegment> const & tagsegment,
                         std::shared_ptr<EvioSegment> const & segment) {

            auto const & segHeader = segment->getHeader();
            auto const & tsHeader  = tagsegment->getHeader();
            tsHeader->copy(segHeader);

            // Change 6 bit content type to equivalent 4 bits
            DataType const & segType = segHeader->getDataType();
            if (segType == DataType::BANK) {
                tsHeader->setDataType(DataType::ALSOBANK);
            }
            else if (segType == DataType::SEGMENT) {
                tsHeader->setDataType(DataType::ALSOSEGMENT);
            }

            tagsegment->transform(segment);
        }

        // TagSegment --> Segment

        static std::shared_ptr<EvioSegment> transform(std::shared_ptr<EvioTagSegment> const & tagsegment) {
            auto const & tsHeader = tagsegment->getHeader();
            auto seg = EvioSegment::getInstance(tsHeader->getTag(), tsHeader->getDataType());
            auto const & segHeader = seg->getHeader();
            segHeader->setLength(tsHeader->getLength());

            seg->transform(tagsegment);
            return seg;
        }

        static void copy(std::shared_ptr<EvioSegment> const & segment,
                         std::shared_ptr<EvioSegment> const & tagsegment) {

            auto const & tsHeader  = tagsegment->getHeader();
            auto const & segHeader = segment->getHeader();
            segHeader->copy(tsHeader);
            tagsegment->transform(segment);
        }

        // Bank -> Segment

        static std::shared_ptr<EvioSegment> transform(std::shared_ptr<EvioBank> const & bank) {
            auto const & bankHeader = bank->getHeader();
            size_t bankLen = bankHeader->getLength();
            if (bankLen > 65535) {
                throw new EvioException("Bank is too long to transform into segment");
            }
            auto segment = EvioSegment::getInstance(bankHeader->getTag(), bankHeader->getDataType());
            auto const & segHeader = segment->getHeader();
            segHeader->setLength(bankLen - 1);
            segHeader->setPadding(bankHeader->getPadding());
            segHeader->setNumber(bankHeader->getNumber());

            segment->transform(bank);
            return segment;
        }


        static void copy(std::shared_ptr<EvioSegment> const & segment,
                         std::shared_ptr<EvioBank> const & bank) {

            auto const & bankHeader = bank->getHeader();
            size_t bankLen = bankHeader->getLength();
            if (bankLen > 65535) {
                throw new EvioException("Bank is too long to transform into segment");
            }
            auto const & segHeader = segment->getHeader();
            segHeader->copy(bankHeader);
            segHeader->setLength(bankLen - 1);

            segment->transform(bank);
        }

        // Bank -> TagSegment

        static std::shared_ptr<EvioTagSegment> transform(std::shared_ptr<EvioBank> const & bank,
                                                         int dummy) {
            auto const & bankHeader = bank->getHeader();
            if (bankHeader->getLength() > 65535) {
                throw new EvioException("Bank is too long to transform into segment");
            }
            auto ts = EvioTagSegment::getInstance(bankHeader->getTag(), bankHeader->getDataType());
            auto const & tsHeader = ts->getHeader();
            tsHeader->setLength(bankHeader->getLength() - 1);
            tsHeader->setPadding(bankHeader->getPadding());
            tsHeader->setNumber(bankHeader->getNumber());

            DataType const & tsType = tsHeader->getDataType();
            if (tsType == DataType::BANK) {
                tsHeader->setDataType(DataType::ALSOBANK);
            }
            else if (tsType == DataType::SEGMENT) {
                tsHeader->setDataType(DataType::ALSOSEGMENT);
            }

            ts->transform(bank);
            return ts;
        }


        static void copy(std::shared_ptr<EvioTagSegment> const & tagsegment,
                         std::shared_ptr<EvioBank> const & bank) {

            auto const & bankHeader = bank->getHeader();
            size_t bankLen = bankHeader->getLength();
            if (bankLen > 65535) {
                throw new EvioException("Bank is too long to transform into tagsegment");
            }
            auto const & tsHeader = tagsegment->getHeader();
            tsHeader->copy(bankHeader);
            tsHeader->setLength(bankLen - 1);

            DataType const & bankType = bankHeader->getDataType();
            if (bankType == DataType::BANK) {
                tsHeader->setDataType(DataType::ALSOBANK);
            }
            else if (bankType == DataType::SEGMENT) {
                tsHeader->setDataType(DataType::ALSOSEGMENT);
            }

            tagsegment->transform(bank);
        }


    };



}

#endif //EVIO_6_0_STRUCTURETRANSFORMER_H