RawEventV0.cpp

Go to the documentation of this file.

#include "DAQDataFormats/RawEventV0.h"
#include "DAQDataFormats/RawEventHeader.h"
#include "DAQDataFormats/RawEventTail.h"
#include "DAQDataFormats/RawDataBlock.h"
#include "DAQDataFormats/RawTrigger.h"
#include "DAQDataFormats/RawEvent.h"

#include <boost/format.hpp>
/// It is requred to
///   1. include DAQDataFormats/DataFormatFirst.inc
///   2. define CURRENT_CLASS
///   3.    define CURRENT_CLASS_VERSION for version of the class
///      OR define LAST_CLASS_VERSION    for the main structure of the class
///   4. (optional) define CURRENT_FIELDS_SUB_NAMESPACE
///   5. include DAQDataFormats/DataFormatLast.inc
/// before the declaration of the DataFormat version class in the header.
#include "DAQDataFormats/DataFormatFirst.inc"
#define  CURRENT_CLASS                RawEvent
#define  CURRENT_CLASS_VERSION        0
#define  CURRENT_FIELDS_SUB_NAMESPACE rawevent
#include "DAQDataFormats/DataFormatLast.inc"

namespace daqdataformats{
namespace VERSION_NAMESPACE{

//------------------------------------------------------------------------------
// Default constructor
RawEvent::RawEvent(const version_t version):
     RawDAQData(version, true, (sizeofdata_t) &RawEvent::getPredefinedSize)
    ,ZEROOUT_FUNCTION(addDataBlock         )
    ,ZEROOUT_FUNCTION(addDataBlockWithSize )
    ,ZEROOUT_FUNCTION(close                 )
    ,ZEROOUT_FUNCTION(setTrigger1            )
    ,ZEROOUT_FUNCTION(setTrigger2             )
    ,ZEROOUT_FUNCTION(setFloatingDataBlockToBufferSource)
    ,ZEROOUT_FUNCTION(nextEvent)
    ,ZEROOUT_FUNCTION(setAppropriateMCFlag)
    ,ZEROOUT_FUNCTION(getHeader                         )
    ,ZEROOUT_FUNCTION(getTail                           )
    ,ZEROOUT_FUNCTION(getTrigger                        )
    ,ZEROOUT_FUNCTION(getFloatingDataBlock              )
    ,ZEROOUT_FUNCTION(getHeaderConst                    )
    ,ZEROOUT_FUNCTION(getTailConst                      )
    ,ZEROOUT_FUNCTION(getTriggerConst                   )
    ,ZEROOUT_FUNCTION(getFloatingDataBlockConst         )
    ,ZEROOUT_FUNCTION(getHeaderMarkerLeft               )
    ,ZEROOUT_FUNCTION(getHeaderMarkerRight              )
    ,ZEROOUT_FUNCTION(getVersion                        )
    ,ZEROOUT_FUNCTION(getDataLoggerID                   )
    ,ZEROOUT_FUNCTION(getRunNumber                      )
    ,ZEROOUT_FUNCTION(getRunType                        )
    ,ZEROOUT_FUNCTION(getConfigIDX                      )
    ,ZEROOUT_FUNCTION(getPartition                      )
    ,ZEROOUT_FUNCTION(getSubrun                         )
    ,ZEROOUT_FUNCTION(getEventNumberLo                  )
    ,ZEROOUT_FUNCTION(getEventNumberHi                  )
    ,ZEROOUT_FUNCTION(getEventNumber                    )
    ,ZEROOUT_FUNCTION(getEventType                      )
    ,ZEROOUT_FUNCTION(getEventSize                      )
    ,ZEROOUT_FUNCTION(getDataBlockNumber                )
    ,ZEROOUT_FUNCTION(isEventIncomplete                 )
    ,ZEROOUT_FUNCTION(getMonteCarloFlag                 )
    ,ZEROOUT_FUNCTION(isCRCCalculationUsed              )
    ,ZEROOUT_FUNCTION(setTriggerPointer                 )
    ,ZEROOUT_FUNCTION(setDataLoggerID                   )
    ,ZEROOUT_FUNCTION(setRunNumber                      )
    ,ZEROOUT_FUNCTION(setRunType                        )
    ,ZEROOUT_FUNCTION(setConfigIDX                      )
    ,ZEROOUT_FUNCTION(setPartition                      )
    ,ZEROOUT_FUNCTION(setSubrun                         )
    ,ZEROOUT_FUNCTION(setEventNumberLo                  )
    ,ZEROOUT_FUNCTION(setEventNumberHi                  )
    ,ZEROOUT_FUNCTION(setEventNumber                    )
    ,ZEROOUT_FUNCTION(setEventType                      )
    ,ZEROOUT_FUNCTION(setEventIncomplete                )
    ,ZEROOUT_FUNCTION(setMonteCarloFlag                 )
    ,ZEROOUT_FUNCTION(setFloatingDataBlock              )
    ,_Header                  (NULL)
    ,_Tail                    (NULL)
    ,_Trigger                 (NULL)
    ,_FloatingDataBlock       (NULL)
    ,_FloatingDataBlockNumber (-1)
    ,_triggerVersion          (rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
    ,_datablockVersion        (rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
    ,_mcFlag                  (rawevent::MC_FLAG_UNKNOWN)
    ,_mcFlagBool              (false)
    ,_tailSize                (getTailSize(version))
{ }

//------------------------------------------------------------------------------
RawEvent::RawEvent(const RawEvent& copyin):
     RawDAQData(copyin)
    ,DEEPCOPY_FUNCTION(addDataBlock         )
    ,DEEPCOPY_FUNCTION(addDataBlockWithSize )
    ,DEEPCOPY_FUNCTION(close                 )
    ,DEEPCOPY_FUNCTION(setTrigger1            )
    ,DEEPCOPY_FUNCTION(setTrigger2             )
    ,DEEPCOPY_FUNCTION(setFloatingDataBlockToBufferSource)
    ,DEEPCOPY_FUNCTION(nextEvent)
    ,DEEPCOPY_FUNCTION(setAppropriateMCFlag)
    ,DEEPCOPY_FUNCTION(getHeader                         )
    ,DEEPCOPY_FUNCTION(getTail                           )
    ,DEEPCOPY_FUNCTION(getTrigger                        )
    ,DEEPCOPY_FUNCTION(getFloatingDataBlock              )
    ,DEEPCOPY_FUNCTION(getHeaderConst                    )
    ,DEEPCOPY_FUNCTION(getTailConst                      )
    ,DEEPCOPY_FUNCTION(getTriggerConst                   )
    ,DEEPCOPY_FUNCTION(getFloatingDataBlockConst         )
    ,DEEPCOPY_FUNCTION(getHeaderMarkerLeft               )
    ,DEEPCOPY_FUNCTION(getHeaderMarkerRight              )
    ,DEEPCOPY_FUNCTION(getVersion                        )
    ,DEEPCOPY_FUNCTION(getDataLoggerID                   )
    ,DEEPCOPY_FUNCTION(getRunNumber                      )
    ,DEEPCOPY_FUNCTION(getRunType                        )
    ,DEEPCOPY_FUNCTION(getConfigIDX                      )
    ,DEEPCOPY_FUNCTION(getPartition                      )
    ,DEEPCOPY_FUNCTION(getSubrun                         )
    ,DEEPCOPY_FUNCTION(getEventNumberLo                  )
    ,DEEPCOPY_FUNCTION(getEventNumberHi                  )
    ,DEEPCOPY_FUNCTION(getEventNumber                    )
    ,DEEPCOPY_FUNCTION(getEventType                      )
    ,DEEPCOPY_FUNCTION(getEventSize                      )
    ,DEEPCOPY_FUNCTION(getDataBlockNumber                )
    ,DEEPCOPY_FUNCTION(isEventIncomplete                 )
    ,DEEPCOPY_FUNCTION(getMonteCarloFlag                 )
    ,DEEPCOPY_FUNCTION(isCRCCalculationUsed              )
    ,DEEPCOPY_FUNCTION(setTriggerPointer                 )
    ,DEEPCOPY_FUNCTION(setDataLoggerID                   )
    ,DEEPCOPY_FUNCTION(setRunNumber                      )
    ,DEEPCOPY_FUNCTION(setRunType                        )
    ,DEEPCOPY_FUNCTION(setConfigIDX                      )
    ,DEEPCOPY_FUNCTION(setPartition                      )
    ,DEEPCOPY_FUNCTION(setSubrun                         )
    ,DEEPCOPY_FUNCTION(setEventNumberLo                  )
    ,DEEPCOPY_FUNCTION(setEventNumberHi                  )
    ,DEEPCOPY_FUNCTION(setEventNumber                    )
    ,DEEPCOPY_FUNCTION(setEventType                      )
    ,DEEPCOPY_FUNCTION(setEventIncomplete                )
    ,DEEPCOPY_FUNCTION(setMonteCarloFlag                 )
    ,DEEPCOPY_FUNCTION(setFloatingDataBlock              )
    ,_Header                  (NULL)
    ,_Tail                    (NULL)
    ,_Trigger                 (NULL)
    ,_FloatingDataBlock       (NULL)
    ,_FloatingDataBlockNumber (-1)
    ,_triggerVersion          (copyin._triggerVersion)
    ,_datablockVersion        (copyin._datablockVersion)
    ,_mcFlag                  (copyin._mcFlag)
    ,_mcFlagBool              (copyin._mcFlagBool)
    ,_tailSize                (copyin._tailSize)
{ }

//------------------------------------------------------------------------------
// Destructor
RawEvent::~RawEvent() {
    if(_Header)            delete _Header;
    if(_FloatingDataBlock) delete _FloatingDataBlock;
    if(_Tail)              delete _Tail;
    if(_Trigger)           delete _Trigger;
}


//------------------------------------------------------------------------------
// Initialization of Data members
void RawEvent::init(){

  PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" Header size:"<<_Header->sizeofdata());

    /// Header + CRC
    uint32_t size_of_data = _Header->sizeofdata() + 1;

    if(_Trigger){

         size_of_data += _Trigger->sizeofdata();

         if(_shouldBufferBeInternal){
             resizeInternalBuffer(size_of_data);
             /// Check pointers after each read or resize buffer
             checkBufferInternalness();
         }

         _Trigger->init();
    }
    else {

         if(_shouldBufferBeInternal){
             resizeInternalBuffer(size_of_data);
             /// Check pointers after each read or resize buffer
             checkBufferInternalness();
         }
    }

    if(!_Tail) _Tail = new daqdataformats::RawEventTail(_Header->getTailVersion());

    _Header->init();
    _Header->setEventSize(size_of_data);

    // Initialize the _FloatingDataBlockNumber
    _FloatingDataBlockNumber = -1;
}

//------------------------------------------------------------------------------
// Add a MicroSlice of a known size into the RawEvent changing the RawEvent Header appropriately
// The method should be identical to RawMicroSlice::readData() (except for not reading the MicroSlice Timing marker)
// If check_mc_flag = true, the method checks whether the DataBlock is MC generated
// and adds an appropriate flag to the Event Header.
bool RawEvent::addDataBlock(const void* datablock_buffer){
    const daqdataformats::RawDataBlockHeader temp_datablock_header(datablock_buffer, _datablockVersion);
    RETURN_FUNCTION(addDataBlockWithSize)(datablock_buffer, temp_datablock_header.getDataSize());
}

//------------------------------------------------------------------------------
// Add a MicroSlice of a known size into the RawEvent changing the RawEvent Header appropriately
// The method should be identical to RawMicroSlice::readData() (except for not reading the MicroSlice Timing marker)
// If check_mc_flag = true, the method checks whether the DataBlock is MC generated
// and adds an appropriate flag to the Event Header.
bool RawEvent::addDataBlockWithSize(const void* datablock_buffer, const uint32_t datablock_size){

    const uint32_t current_size = EXECUTE_FUNCTION(sizeofdata)(); //remember current buffer position

    //PRINT_ON_DEBUG("DataBlock size="<<datablock_size)
    //EXECUTE_ON_DEBUG(printHex(_Buffer, current_size);)

    //PRINT_ON_DEBUG("DataBlock size="<<datablock_size)

    //EXECUTE_ON_DEBUG(printHex(datablock_buffer, datablock_size);)


    // Setup the RawEventHeader Header
    // Advance the RawEvent DataBlock number and the size
    _Header->addEventSize(datablock_size);
    _Header->advanceDataBlockNumber();

    /// Add the DataBlock the RawEvent _Buffer starting from the last _Buffer size position - 1
    /// -1 because we reserve one word to CRC
    readDataGeneral(datablock_buffer, datablock_size, current_size - 1);

    /// Check pointers after each read or resize buffer
    checkBufferInternalness();

    //PRINT_ON_DEBUG("Final size"<<sizeofdata())
    //EXECUTE_ON_DEBUG(printHex(_Buffer, sizeofdata());)

    RETURN_FUNCTION(setAppropriateMCFlag)(datablock_buffer);
}

//------------------------------------------------------------------------------
bool RawEvent::setAppropriateMCFlag(const void* datablock_buffer){

    // Check if the DataBlock is the MC generated
    // If it is, set the appropriate MicroSlice MC flag
    if(_mcFlag == rawevent::MC_FLAG_UNKNOWN){
        daqdataformats::RawDataBlock temp_datablock(datablock_buffer, _datablockVersion);
        _mcFlagBool       = temp_datablock.getMonteCarloFlag();
        _mcFlag           = 1;
        _datablockVersion = temp_datablock.getVersion();
    }

    return setMonteCarloFlag(_mcFlagBool);
}

//------------------------------------------------------------------------------
// Usually just packs the Header leaving the rest of the _Buffer unchanged.
// Also, puts the Header in the tail as well. Puts CRC in the very end.
bool RawEvent::close(const bool produce_crc){

    const uint32_t old_event_size = EXECUTE_FUNCTION(sizeofdata)();

    /// Add the size of the tail
    const uint32_t new_event_size = old_event_size + _Tail->sizeofdata();

    _Header->setEventSize(new_event_size);

    /// Resize the internal event buffer by adding Tail + CRC
    if(_shouldBufferBeInternal){
        resizeInternalBuffer(new_event_size);
        /// Check pointers after each read or resize buffer
        checkBufferInternalness();
    }
    
    _Tail->setBufferSource(&RAWBUFF32[old_event_size - 1]);

    _Tail->init();
    _Tail->setEventNumberLo(_Header->getEventNumberLo());
    _Tail->setEventNumberHi(_Header->getEventNumberHi());
    _Tail->setEventSize    (_Header->getEventSize());

    /// Finally, add CRC in the very end of _Buffer
    if(produce_crc){
        _Header->setCRCCalculationUsed(true);
        addCheckSum();
    }

    return true;
}

//------------------------------------------------------------------------------
//Getters
daqdataformats::RawEventTail*   RawEvent::getTail()   {
        uint32_t* pointer = &RAWBUFF32[sizeofdata() - _Tail->sizeofdata() - 1];
        _Tail->setBufferSource(pointer);
        return _Tail;
}
daqdataformats::RawEventTail*   RawEvent::getTailConst() const  {
        uint32_t* pointer = &RAWBUFF32[sizeofdata() - _Tail->sizeofdata() - 1];
        _Tail->setBufferSource(pointer);
        return _Tail;
}

//------------------------------------------------------------------------------
daqdataformats::RawEventHeader* RawEvent::getHeader()   const    { return _Header; }
daqdataformats::RawTrigger*     RawEvent::getTrigger()           { return _Trigger; }
daqdataformats::RawDataBlock*   RawEvent::getFloatingDataBlock() { return _FloatingDataBlock; }

daqdataformats::RawEventHeader* RawEvent::getHeaderConst()            const { return _Header; }
daqdataformats::RawTrigger*     RawEvent::getTriggerConst()           const { return _Trigger; }
daqdataformats::RawDataBlock*   RawEvent::getFloatingDataBlockConst() const { return _FloatingDataBlock; }

uint32_t        RawEvent::getHeaderMarkerLeft()  const { return _Header->getMarkerLeft();}
uint32_t        RawEvent::getHeaderMarkerRight() const { return _Header->getMarkerRight();}
uint32_t        RawEvent::getVersion()           const { return _Header->getVersion();}
uint32_t        RawEvent::getDataLoggerID()      const { return _Header->getDataLoggerID();}
uint32_t        RawEvent::getRunNumber()         const { return _Header->getRunNumber();}
uint32_t        RawEvent::getRunType()           const { return _Header->getRunType();}
uint32_t        RawEvent::getConfigIDX()         const { return _Header->getConfigIDX();}
uint32_t        RawEvent::getPartition()         const { return _Header->getPartition();}
uint32_t        RawEvent::getSubrun()            const { return _Header->getSubrun();}
uint32_t        RawEvent::getEventNumberLo()     const { return _Header->getEventNumberLo();}
uint32_t        RawEvent::getEventNumberHi()     const { return _Header->getEventNumberHi();}
uint32_t        RawEvent::getEventType()         const { return _Header->getEventType();}
uint32_t        RawEvent::getEventSize()         const { return _Header->getEventSize();}
uint32_t        RawEvent::getDataBlockNumber()   const { return _Header->getDataBlockNumber();}
bool            RawEvent::isEventIncomplete()    const { return _Header->isEventIncomplete();}
bool            RawEvent::getMonteCarloFlag()    const { return _Header->getMonteCarloFlag();}
bool            RawEvent::isCRCCalculationUsed() const { return _Header->isCRCCalculationUsed();}
uint64_t        RawEvent::getEventNumber()       const { return _Header->getEventNumber();}


//------------------------------------------------------------------------------
// Setters
// Different setters for the trigger
bool RawEvent::setTrigger1       (const daqdataformats::RawTrigger&  trigger){ RETURN_FUNCTION(setTrigger2)(trigger.getBuffer());}
bool RawEvent::setTrigger2       (const void*  pointer) {

        EXECUTE_FUNCTION(setTriggerPointer)(pointer);

        /// New Trigger, so resize the Event Size
        _Header->setEventSize(_Header->sizeofdata() + _Trigger->sizeofdata() + 1);

        if(_shouldBufferBeInternal){
             resizeInternalBuffer(EXECUTE_FUNCTION(sizeofdata)());
             /// Check pointers after each read or resize buffer
             checkBufferInternalness();
        }

        /// read Trigger
        readDataGeneral(pointer, _Trigger->sizeofdata(), _Header->sizeofdata());

        EXECUTE_FUNCTION(setTriggerPointer)(&(RAWBUFF32[_Header->sizeofdata()]));

        return true;
}

//------------------------------------------------------------------------------
bool RawEvent::setTriggerPointer(const void* pointer){

        if(_Trigger){
            _Trigger->setBufferSource(pointer);
            PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<"0");
        }
        else{
            _triggerVersion = daqdataformats::RawTrigger::figureOutTheVersionStatic(pointer);
            PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<"1"<<"version = "<<_triggerVersion);
            _Trigger        = new daqdataformats::RawTrigger(pointer, _triggerVersion);
        }
        
        return true;
}

//------------------------------------------------------------------------------
bool RawEvent::setDataLoggerID   (const uint32_t inp) {return _Header->setDataLoggerID  (inp);}
bool RawEvent::setRunNumber      (const uint32_t inp) {return _Header->setRunNumber     (inp);}
bool RawEvent::setRunType        (const uint32_t inp) {return _Header->setRunType       (inp);}
bool RawEvent::setConfigIDX      (const uint32_t inp) {return _Header->setConfigIDX     (inp);}
bool RawEvent::setPartition      (const uint32_t inp) {return _Header->setPartition     (inp);}
bool RawEvent::setSubrun         (const uint32_t inp) {return _Header->setSubrun        (inp);}
bool RawEvent::setEventNumberLo  (const uint32_t inp) {return _Header->setEventNumberLo (inp);}
bool RawEvent::setEventNumberHi  (const uint32_t inp) {return _Header->setEventNumberHi (inp);}
bool RawEvent::setEventType      (const uint32_t inp) {return _Header->setEventType     (inp);}
bool RawEvent::setEventIncomplete(const bool tf)      {return _Header->setEventIncomplete(tf);}
bool RawEvent::setMonteCarloFlag (const bool tf)      {return _Header->setMonteCarloFlag(tf);}
bool RawEvent::setEventNumber    (const uint64_t evnt){return _Header->setEventNumber(evnt);}

//------------------------------------------------------------------------------
bool RawEvent::setFloatingDataBlockToBufferSource(const void* internal_buffer_pointer) const {
            /// If it exists, just set its buffer
            if(_FloatingDataBlock)
                return _FloatingDataBlock->setBufferSource(internal_buffer_pointer);

            /// Otherwise, create new Floating MicroSlice pointing to the buffer
            _FloatingDataBlock = new daqdataformats::RawDataBlock(internal_buffer_pointer, _datablockVersion);

            return true;
}

//------------------------------------------------------------------------------
bool RawEvent::setFloatingDataBlock(const uint32_t idatablock) const {

        const int32_t idatablock_int = (int32_t)idatablock;

        /// If it's already the same, nothing needs to be done
        if(idatablock_int == _FloatingDataBlockNumber)
            return true;

        /// Pointer that we are going to use
        uint32_t* pointer = NULL;

        /// If microslice number is greater than current floating Microslice number, then no need
        /// to loop over all MicroSlices, just start from the current floating MicroSlice
        if(idatablock_int > _FloatingDataBlockNumber && _FloatingDataBlockNumber > -1){
            pointer = (uint32_t*)_FloatingDataBlock->getBuffer();
        }
        else{
            /// Otherwise, start from scratch
            /// First point to the first MicroSlice
            pointer = ((uint32_t*)_Buffer) + _Header->sizeofdata() + _Trigger->sizeofdata();


            /// Set floating MicroSlice to pointer
            /// If it doesn't exist, create it
            EXECUTE_FUNCTION(setFloatingDataBlockToBufferSource)(pointer);
            _FloatingDataBlockNumber = 0;

        }// end of setting the first floating MicroSlice


        /// Pointer to the end of the buffer for checks
        const uint32_t* end_of_buffer_pointer = &RAWBUFF32[sizeofdata()];

        /// Start loop over microslices
        for(; _FloatingDataBlockNumber < idatablock_int; ++_FloatingDataBlockNumber){
            pointer += _FloatingDataBlock->sizeofdata();

            /// Check if the pointer is not valid
            if (pointer >= end_of_buffer_pointer)
                return false;

            _FloatingDataBlock->setBufferSource(pointer);
        }// end of loop over microslices

        return true;
}

//------------------------------------------------------------------------------
bool RawEvent::nextEvent(){
    
    // Advance event number
    _Header->advanceEventNumber();
    //reset DataBlock number
    _Header->setDataBlockNumber(0);
    //reset the size
    _Header->setEventSize(_Trigger->sizeofdata() + _Header->sizeofdata() + 1);

    // reset the _FloatingDataBlockNumber
    _FloatingDataBlockNumber = -1;

    return true;

}

//------------------------------------------------------------------------------
// Printing the RawEvent structure
void RawEvent::print(std::ostream& os) const {

    os<<boost::format("---RawEvent---------------------------------------------size = %u\n")
            % sizeofdata();

    printBuffer(os);

    /// Copy of the event
    daqdataformats::RawEvent event_copy(_Buffer, _version);

    event_copy.getHeader()->print(os);

    /// Print the Trigger Block
    if(_Trigger){

        RawTrigger* tr = event_copy.getTrigger();
        tr->print(os);

        const uint32_t n_datablocks = event_copy.getDataBlockNumber();
        os<<"Number of datablocks="<<n_datablocks<<std::endl;

        /// Print all DataBlocks. Can only print them when there is a Trigger
        for(uint32_t idatablock = 0; idatablock < n_datablocks; ++idatablock){
            event_copy.setFloatingDataBlock(idatablock);
            event_copy.getFloatingDataBlock()->print(os);
        }

    }
    else{
        os<<"There is no trigger right now\n";
    }
    return;

    const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();

    os<<"\nRAW:";
    for(uint32_t i = 0; i < size_of_data; ++i){
        printWord(i, false, os);
        os<<" ";
    }

    os<<"\nRAW:";
    for(uint32_t i = 0; i < size_of_data; ++i){
            os<<"    ";
            printWord(i, true, os);
            os<<std::endl;
            }
 
    os<<boost::format("---end of RawEvent---------------------------------------size = %u\n")
        % size_of_data;

}

//------------------------------------------------------------------------------
// Size of the RawEvent _Buffer in words
uint32_t RawEvent::sizeofdata()const  { return _Header->getEventSize(); }

//------------------------------------------------------------------------------
// Read an entire DataBlock from datablock_buffer into _Buffer
void* RawEvent::readData(const void* datablock_buffer){

  PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" Reading "<<_Header->sizeofdata());

    const uint32_t header_size = _Header->sizeofdata();

    if(_shouldBufferBeInternal){
             resizeInternalBuffer(header_size + 1);
             /// Check pointers after each read or resize buffer
             checkBufferInternalness();
    }

    /// Read the header
    void* datablock_buffer_new = readDataGeneral(datablock_buffer, header_size, 0);

    if(_shouldBufferBeInternal){
             resizeInternalBuffer(EXECUTE_FUNCTION(sizeofdata)());
             /// Check pointers after each read or resize buffer
             checkBufferInternalness();
    }

    /// Read the rest of the event
    datablock_buffer_new = readDataGeneral(datablock_buffer_new, EXECUTE_FUNCTION(sizeofdata)() - header_size, header_size);

    /// Check pointers after each read or resize buffer
    checkBufferInternalness();

    /// Need to assign trigger if it's not constructed yet
    if(!_Trigger){
        EXECUTE_FUNCTION(setTriggerPointer)(&RAWBUFF32[header_size]);
    }

    return datablock_buffer_new;
}



//------------------------------------------------------------------------------
bool RawEvent::setBufferSource(const void* pointer){

  PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<"version = "<<_version);

        _Buffer  = (void*)pointer;

        _shouldBufferBeInternal = isInternalBuffer();

        /// If Header is already defined, then set its buffer source
        /// Otherwise, need to construct it
        if(_Header){
            _Header->setBufferSource(pointer);

            /// Once we set the header, then try to set Trigger and then if we succed, set Tail
            if(tryToSetTrigger())
                tryToSetTail();

            return true;
        }/// end of if there is Header

        /// So, the header is not constructed. Construct it now

        PRINT_ON_DEBUG("Setting Header "<<"version = "<<_version);
        _Header = new daqdataformats::RawEventHeader(_Buffer, _version); ///< version of the EventHeader equals the version of the Event

        /// Once header is constructed, we can read size of data
        _function_sizeofdata = (sizeofdata_t) &VERSION_NAMESPACE::CURRENT_CLASS::sizeofdata;

        /// Once we set the header, then try to set Trigger and then if we succed, set Tail
        if(tryToSetTrigger())
                tryToSetTail();

        return true;
}

//------------------------------------------------------------------------------
// Attempt to set the trigger to the pointer
bool RawEvent::tryToSetTrigger(){
    /// If header is not instanciated, no way to set the Trigger
    if(!_Header) return false;

    /// If header is not set appropriately, no way we can se the trigger.
    if(_Header->getMarkerLeft()  != daqdataformats::raweventhdr::Marker_value[0]) return false;
    if(_Header->getMarkerRight() != daqdataformats::raweventhdr::Marker_value[1]) return false;

    /// Can't do anything if version is unknown
    if(isVersionUnknown()) return false;

    /// See if we can even read TriggerHeader in case the buffer is internal
    /// som trigger header of version 0
    daqdataformats::RawTriggerHeader header_v0((version_t)0);

    /// if the size is too small, can't even set the TriggerHeader,
    /// much less trigger
    if(EXECUTE_FUNCTION(sizeofdata)() - _Header->sizeofdata() < header_v0.sizeofdata())
        return false;

    /// pointer to the trigger
    const void* pointer = &RAWBUFF32[_Header->sizeofdata()];
    
    /// Set Trigger header to that pointer
    header_v0.setBufferSource(pointer);

    /// Check Delimiter
    /// If it's not valid, ca't set it
    if(header_v0.getDelimiter() != daqdataformats::triggerheader::TriggerHeaderDelimiter)
        return false;

    /// Finally, check if we can se the trigger
    try{
        const daqdataformats::RawTrigger trigger_try((version_t)header_v0.getVersion());

        /// if the size is too small, can't even set the TriggerHeader,
        /// much less trigger
        if(EXECUTE_FUNCTION(sizeofdata)() - _Header->sizeofdata() < trigger_try.sizeofdata())
            return false;
    }
    catch(...){
        return false;
    }

    /// At this point, should be able to set Trigger

    RETURN_FUNCTION(setTriggerPointer)(pointer);
}

//------------------------------------------------------------------------------
// Attempt to set the Event Tail to the pointer
bool RawEvent::tryToSetTail(){

    /// If header or triggeris not instanciated, no way to set the Tail
    if(!_Header)  return false;
    if(!_Trigger) return false;

    /// If header is not set appropriately, no way we can se the trigger.
    if(_Header->getMarkerLeft()  != daqdataformats::raweventhdr::Marker_value[0]) return false;
    if(_Header->getMarkerRight() != daqdataformats::raweventhdr::Marker_value[1]) return false;

    if(_Trigger->getTriggerHeader()->getDelimiter() != daqdataformats::triggerheader::TriggerHeaderDelimiter) return false;

    /// Can't do anything if version is unknown
    if(isVersionUnknown()) return false;

    /// Get version of the tail from the header
    const version_t tail_version = _Header->getTailVersion();

    /// Once header is of a known version, then everything should be fine as _tailVersion is fixed
    try{
        daqdataformats::RawEventTail tail_0(tail_version);


        const uint32_t event_tail_size = tail_0.sizeofdata();

        /// if the size is too small, can't set Tail
        if(EXECUTE_FUNCTION(sizeofdata)() - _Header->sizeofdata() - _Trigger->sizeofdata() < tail_0.sizeofdata())
            return false;

        /// Pointer should point to the end of event minus tail size and crc
        const void* pointer = &RAWBUFF32[sizeofdata() - event_tail_size - 1];

        /// trying to read markers
        tail_0.setBufferSource(pointer);
        
        if(tail_0.getMarker()      != daqdataformats::raweventtail::Marker_value[0]) return false;
        if(tail_0.getMarkerLeft()  != daqdataformats::raweventtail::Marker_value[1]) return false;
        if(tail_0.getMarkerRight() != daqdataformats::raweventtail::Marker_value[2]) return false;

        /// At this point should be able to read tail

        /// If tail exists, just assign the buffer source
        if(_Tail)
            _Tail->setBufferSource(pointer);
        else
            _Tail = new daqdataformats::RawEventTail(pointer, tail_version);
    }
    catch(...){
        return false;
    }



    
    return true;
}


}}