AsciiFragment.hh

#ifndef artdaq_demo_Overlays_AsciiFragment_hh
#define artdaq_demo_Overlays_AsciiFragment_hh

#include "artdaq-core/Data/Fragment.hh"
#include "cetlib_except/exception.h"

#include <ostream>
#include <vector>

// Implementation of "AsciiFragment", an artdaq::Fragment overlay class
// used for pedagogical purposes

namespace demo {
class AsciiFragment;

std::ostream& operator<<(std::ostream&, AsciiFragment const&);
}  // namespace demo

class demo::AsciiFragment
{
public:
    struct Metadata
    {
        typedef char data_t;
        typedef uint32_t chars_in_line_t;

        chars_in_line_t charsInLine;  

        static size_t const size_words = 4ul;  
    };

    static_assert(sizeof(Metadata) == Metadata::size_words * sizeof(Metadata::data_t),
                  "AsciiFragment::Metadata size changed");

    struct Header
    {
        typedef char data_t;  

        typedef uint64_t event_size_t;   
        typedef uint64_t line_number_t;  

        event_size_t event_size : 28;  
        event_size_t unused_1 : 36;    

        line_number_t line_number;  

        static size_t const size_words = 16ul;  
    };

    static_assert(sizeof(Header) == Header::size_words * sizeof(Header::data_t), "AsciiFragment::Header size changed");

    explicit AsciiFragment(artdaq::Fragment const& f)
        : artdaq_Fragment_(f) {}

    // const getter functions for the data in the header

    Header::event_size_t hdr_event_size() const { return header_()->event_size; }
    Header::line_number_t hdr_line_number() const { return header_()->line_number; }
    static constexpr size_t hdr_size_words() { return Header::size_words; }

    size_t total_line_characters() const { return (hdr_event_size() - hdr_size_words()) * chars_per_word_(); }

    char const* dataBegin() const
    {
        return reinterpret_cast<char const*>(header_() + 1);  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-bounds-pointer-arithmetic)
    }

    char const* dataEnd() const { return dataBegin() + total_line_characters(); }  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)

protected:
    static constexpr size_t chars_per_word_() { return sizeof(Header::data_t) / sizeof(char); }  // NOLINT(bugprone-sizeof-expression)

    Header const* header_() const
    {
        return reinterpret_cast<AsciiFragment::Header const*>(artdaq_Fragment_.dataBeginBytes());  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
    }

private:
    artdaq::Fragment const& artdaq_Fragment_;
};

#endif /* artdaq_demo_Overlays_AsciiFragment_hh */