RawDataEvent.hh

#ifndef EUDAQ_INCLUDED_RawDataEvent
#define EUDAQ_INCLUDED_RawDataEvent

#include <sstream>

#include <vector>
#include "eudaq/Event.hh"
#include "eudaq/Platform.hh"
namespace eudaq {

  class DLLEXPORT RawDataEvent : public Event {
    EUDAQ_DECLARE_EVENT(RawDataEvent);

  public:
    typedef unsigned char byte_t;
    typedef std::vector<byte_t> data_t;
    struct DLLEXPORT block_t : public Serializable {
      block_t(unsigned id, const data_t& data)
          : id(id), data(data) {}
      block_t(unsigned id, data_t&& data)
    : id(id), data(std::move(data)) {}
      block_t()
    : id(-1), data(data_t()) {}
      block_t(Deserializer &);
      void Serialize(Serializer &) const;
      void Append(const data_t &data);
      unsigned id;
      data_t data;
    };

    RawDataEvent(std::string type, unsigned run, unsigned event);
    RawDataEvent(Deserializer &);

    size_t AddBlock(unsigned id) {
      m_blocks.push_back(block_t(id, data_t()));
      return m_blocks.size() - 1;
    }

    template <typename T>
    size_t AddBlock(unsigned id, const std::vector<T> &data) {
      m_blocks.push_back(block_t(id, make_vector(data)));
      return m_blocks.size() - 1;
    }

    template <typename T>
    size_t AddBlock(unsigned id, const T *data, size_t bytes) {
      m_blocks.push_back(block_t(id, make_vector(data, bytes)));
      return m_blocks.size() - 1;
    }

    template <typename T>
    void AppendBlock(size_t index, const std::vector<T> &data) {
      m_blocks[index].Append(make_vector(data));
    }

    template <typename T>
    void AppendBlock(size_t index, const T *data, size_t bytes) {
      m_blocks[index].Append(make_vector(data, bytes));
    }

    unsigned GetID(size_t i) const;
    const data_t &GetBlock(size_t i) const;
    byte_t GetByte(size_t block, size_t index) const;

    size_t NumBlocks() const { return m_blocks.size(); }

    virtual void Print(std::ostream &) const;
    static RawDataEvent BORE(std::string type, unsigned run) {
      return RawDataEvent(type, run, (unsigned)-1, Event::FLAG_BORE);
    }
    static RawDataEvent *newBORE(std::string type, unsigned run) {

      return new RawDataEvent(type, run, (unsigned)-1, Event::FLAG_BORE);
    }
    static RawDataEvent EORE(std::string type, unsigned run, unsigned event) {
      return RawDataEvent(type, run, event, Event::FLAG_EORE);
    }
    static RawDataEvent *newEORE(std::string type, unsigned run,
                                 unsigned event) {

      return new RawDataEvent(type, run, event, Event::FLAG_EORE);
    }
    virtual void Serialize(Serializer &) const;

    virtual std::string GetSubType() const { return m_type; }

  private:
    // private constructor to create BORE and EORE
    // make sure that event number is 0 for BORE
    RawDataEvent(std::string type, unsigned run, unsigned event,
                 Event::Flags flag)
        : Event(run, event, NOTIMESTAMP, flag), m_type(type) {}

    template <typename T>
    static data_t make_vector(const T *data, size_t bytes) {
      const unsigned char *ptr = reinterpret_cast<const byte_t *>(data);
      return data_t(ptr, ptr + bytes);
    }

    template <typename T>
    static data_t make_vector(const std::vector<T> &data) {
      const unsigned char *ptr = reinterpret_cast<const byte_t *>(&data[0]);
      return data_t(ptr, ptr + data.size() * sizeof(T));
    }

    std::string m_type;
    std::vector<block_t> m_blocks;
  };
}

#endif // EUDAQ_INCLUDED_RawDataEvent