UDPFragmentWriter.hh

#ifndef artdaq_ots_Overlays_UDPFragmentWriter_hh
#define artdaq_ots_Overlays_UDPFragmentWriter_hh
 
 
#include "artdaq-core/Data/Fragment.hh"
#include "artdaq-ots/Overlays/UDPFragment.hh"
 
#include <iostream>
 
namespace ots
{
class UDPFragmentWriter;
}
 
class ots::UDPFragmentWriter : public ots::UDPFragment
{
  public:
    UDPFragmentWriter(artdaq::Fragment& f);
 
    uint8_t* dataBegin();
    uint8_t* dataEnd();
 
    Header* header_()
    {
        assert(artdaq_Fragment_.dataSizeBytes() >= sizeof(Header));
        return reinterpret_cast<Header*>(artdaq_Fragment_.dataBeginBytes());
    }
 
    void set_hdr_type(Header::data_type_t dataType) { header_()->type = dataType & 0xF; }
 
    void resize(size_t nBytes);
 
  private:
    size_t calc_event_size_words_(size_t nBytes);
 
    static size_t bytes_to_words_(size_t nBytes);
 
    artdaq::Fragment& artdaq_Fragment_;
};
 
ots::UDPFragmentWriter::UDPFragmentWriter(artdaq::Fragment& f)
    : UDPFragment(f)
    , artdaq_Fragment_(f)
{
    if(!f.hasMetadata() || f.dataSizeBytes() > 0)
    {
        throw cet::exception(
            "Error in UDPFragmentWriter: Raw artdaq::Fragment object does not appear to "
            "consist of (and only of) its own header + the UDPFragment::Metadata object");
    }
 
    artdaq_Fragment_.resizeBytes(sizeof(Header));
}
 
inline uint8_t* ots::UDPFragmentWriter::dataBegin()
{
    assert(artdaq_Fragment_.dataSizeBytes() >=
           sizeof(Header) + sizeof(artdaq::Fragment::value_type));
    return reinterpret_cast<uint8_t*>(header_() + 1);
}
 
inline uint8_t* ots::UDPFragmentWriter::dataEnd()
{
    return dataBegin() + udp_data_words();
}
 
inline void ots::UDPFragmentWriter::resize(size_t nBytes)
{
    artdaq_Fragment_.resizeBytes(sizeof(Header::data_t) * calc_event_size_words_(nBytes));
    header_()->event_size = calc_event_size_words_(nBytes);
}
 
inline size_t ots::UDPFragmentWriter::calc_event_size_words_(size_t nBytes)
{
    return bytes_to_words_(nBytes) + hdr_size_words();
}
 
inline size_t ots::UDPFragmentWriter::bytes_to_words_(size_t nBytes)
{
    auto mod(nBytes % bytes_per_word_());
    return (mod == 0) ? nBytes / bytes_per_word_() : nBytes / bytes_per_word_() + 1;
}
 
#endif /* artdaq_demo_Overlays_UDPFragmentWriter_hh */