Fragment.hpp

Go to the documentation of this file.

 
#ifndef DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_FRAGMENT_HPP_
#define DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_FRAGMENT_HPP_
 
#include "daqdataformats/FragmentHeader.hpp"
#include "daqdataformats/SourceID.hpp"
#include "daqdataformats/Types.hpp"
 
#include <bitset>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <new>
#include <numeric>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace dunedaq::daqdataformats {

class Fragment
{
public:
  enum class BufferAdoptionMode
  {
    kTakeOverBuffer, 
    kCopyFromBuffer  
  };

  explicit Fragment(const std::vector<std::pair<void*, size_t>>& pieces);
  Fragment(void* buffer, size_t size);
  explicit Fragment(void* existing_fragment_buffer, BufferAdoptionMode adoption_mode);
 
  FragmentHeader get_header() const { return *header_(); }

  void set_header_fields(const FragmentHeader& header);

  const void* get_storage_location() const { return m_data_arr; }
 
  trigger_number_t get_trigger_number() const { return header_()->trigger_number; }
  void set_trigger_number(trigger_number_t trigger_number) { header_()->trigger_number = trigger_number; }
 
  run_number_t get_run_number() const { return header_()->run_number; }
  void set_run_number(run_number_t run_number) { header_()->run_number = run_number; }
 
  timestamp_t get_trigger_timestamp() const { return header_()->trigger_timestamp; }
  void set_trigger_timestamp(timestamp_t trigger_timestamp) { header_()->trigger_timestamp = trigger_timestamp; }
 
  timestamp_t get_window_begin() const { return header_()->window_begin; }
  void set_window_begin(timestamp_t window_begin) { header_()->window_begin = window_begin; }
 
  timestamp_t get_window_end() const { return header_()->window_end; }
  void set_window_end(timestamp_t window_end) { header_()->window_end = window_end; }

  SourceID get_element_id() const { return header_()->element_id; }

  void set_element_id(SourceID element_id) { header_()->element_id = element_id; }
 
  uint16_t get_detector_id() const noexcept { return header_()->detector_id; }                         // NOLINT
  void set_detector_id(const uint16_t& detector_id) noexcept { header_()->detector_id = detector_id; } // NOLINT

  std::bitset<32> get_status_bits() const { return header_()->status_bits; }
  void set_status_bits(std::bitset<32> status_bits) { header_()->status_bits = status_bits.to_ulong(); }
  bool get_status_bit(FragmentStatusBits bit) const { return get_status_bits()[static_cast<size_t>(bit)]; }

  void set_status_bit(FragmentStatusBits bit, bool value);

  fragment_type_t get_fragment_type_code() const { return header_()->fragment_type; }
  FragmentType get_fragment_type() const { return static_cast<FragmentType>(get_fragment_type_code()); }
  void set_type(FragmentType fragment_type) { header_()->fragment_type = static_cast<fragment_type_t>(fragment_type); }
 
  sequence_number_t get_sequence_number() const { return header_()->sequence_number; }
  void set_sequence_number(sequence_number_t number) { header_()->sequence_number = number; }

  fragment_size_t get_size() const { return header_()->size; }

  fragment_size_t get_data_size() const { return header_()->size - sizeof(FragmentHeader); }

  void* get_data() const
  {
    // Increment header pointer by one to skip header
    return static_cast<void*>(header_() + 1); // NOLINT
  }
 
  Fragment(Fragment const&) = delete;
  Fragment& operator=(Fragment const&) = delete;
  Fragment(Fragment&& other)
  {
    m_alloc = other.m_alloc;
    other.m_alloc = false;
    m_data_arr = other.m_data_arr;
  }
  Fragment& operator=(Fragment&& other)
  {
    m_alloc = other.m_alloc;
    other.m_alloc = false;
    m_data_arr = other.m_data_arr;
    return *this;
  }
 
  ~Fragment();
 
private:
  FragmentHeader* header_() const { return static_cast<FragmentHeader*>(m_data_arr); }
  void* m_data_arr{ nullptr }; 
  bool m_alloc{ false };       
};
 
inline Fragment::Fragment(const std::vector<std::pair<void*, size_t>>& pieces)
{
 
  size_t size =
    sizeof(FragmentHeader) +
    std::accumulate(pieces.begin(), pieces.end(), 0ULL, [](const size_t& a, const std::pair<void*, size_t>& b) {
      return a + b.second;
    });
 
  m_data_arr = malloc(size); // NOLINT
  if (m_data_arr == nullptr) {
    throw std::bad_alloc();
  }
  m_alloc = true;
 
  FragmentHeader header;
  header.size = size;
  memcpy(m_data_arr, &header, sizeof(header));
 
  size_t offset = sizeof(header);
  for (auto& piece : pieces) {
    if (piece.first == nullptr) {
      free(m_data_arr); // NOLINT
      throw std::invalid_argument("The Fragment buffer points to NULL.");
    }
    memcpy(static_cast<uint8_t*>(m_data_arr) + offset, piece.first, piece.second); // NOLINT
    offset += piece.second;
  }
}
 
inline Fragment::Fragment(void* buffer, size_t size)
  : Fragment({ std::make_pair(buffer, size) })
{
}
 
inline Fragment::Fragment(void* existing_fragment_buffer, BufferAdoptionMode adoption_mode)
{
  if (adoption_mode == BufferAdoptionMode::kTakeOverBuffer) {
    m_data_arr = existing_fragment_buffer;
    m_alloc = true;
  } else if (adoption_mode == BufferAdoptionMode::kCopyFromBuffer) {
    auto header = reinterpret_cast<FragmentHeader*>(existing_fragment_buffer); // NOLINT
    m_data_arr = malloc(header->size);                                         // NOLINT
    if (m_data_arr == nullptr) {
      throw std::bad_alloc();
    }
    m_alloc = true;
    memcpy(m_data_arr, existing_fragment_buffer, header->size);
  }
}
 
inline Fragment::~Fragment()
{
  if (m_alloc)
    free(m_data_arr); // NOLINT
}
 
inline void
Fragment::set_header_fields(const FragmentHeader& header)
{
  FragmentHeader* header_ptr{ header_() };
  fragment_size_t orig_size{ header_ptr->size };
 
  *header_ptr = header;
  header_ptr->size = orig_size;
}
 
inline void
Fragment::set_status_bit(FragmentStatusBits bit, bool value)
 
{
  auto bits = get_status_bits();
  bits[static_cast<size_t>(bit)] = value;
  set_status_bits(bits);
}
 
} // namespace dunedaq::daqdataformats
 
#endif // DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_FRAGMENT_HPP_