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 {
 
namespace daqdataformats {
 
class Fragment
{
public:
  enum class BufferAdoptionMode
  {
    kReadOnlyMode,   
    kTakeOverBuffer, 
    kCopyFromBuffer  
  };
 
  inline explicit Fragment(const std::vector<std::pair<void*, size_t>>& pieces);
  inline Fragment(void* buffer, size_t size);
  inline explicit Fragment(void* existing_fragment_buffer, BufferAdoptionMode adoption_mode);
 
  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;
  }
 
  inline ~Fragment();
  FragmentHeader get_header() const { return *header_(); }
  inline void set_header_fields(const FragmentHeader& header);
 
  const void* get_storage_location() const { return m_data_arr; }
 
  // Header setters and getters
  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; }
 
  void set_detector_id(const uint16_t& detector_id) noexcept { header_()->detector_id = detector_id; }
 
 
  std::bitset<32> get_error_bits() const { return header_()->error_bits; }
  void set_error_bits(std::bitset<32> error_bits) { header_()->error_bits = error_bits.to_ulong(); }
  bool get_error_bit(FragmentErrorBits bit) const { return get_error_bits()[static_cast<size_t>(bit)]; }
 
  inline void set_error_bit(FragmentErrorBits 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
  }
 
private:
  FragmentHeader* header_() const { return static_cast<FragmentHeader*>(m_data_arr); }
  void* m_data_arr{ nullptr }; 
  bool m_alloc{ false };       
};
 
// ------
 
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; });
 
  if (size < sizeof(FragmentHeader)) {
    throw std::length_error("The Fragment size is smaller than the Fragment header size.");
  }
 
  m_data_arr = malloc(size); // NOLINT(build/unsigned)
  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(FragmentHeader);
  for (auto& piece : pieces) {
    if (piece.first == nullptr) {
      throw std::invalid_argument("The Fragment buffer point to NULL.");
    }
    memcpy(static_cast<uint8_t*>(m_data_arr) + offset, piece.first, piece.second); // NOLINT(build/unsigned)
    offset += piece.second;
  }
}
 
Fragment::Fragment(void* buffer, size_t size)
  : Fragment({ std::make_pair(buffer, size) })
{}
 
Fragment::Fragment(void* existing_fragment_buffer, BufferAdoptionMode adoption_mode)
{
  if (adoption_mode == BufferAdoptionMode::kReadOnlyMode) {
    m_data_arr = existing_fragment_buffer;
  } else 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);
    if (m_data_arr == nullptr) {
      throw std::bad_alloc();
    }
    m_alloc = true;
    memcpy(m_data_arr, existing_fragment_buffer, header->size);
  }
}
 
Fragment::~Fragment()
{
  if (m_alloc)
    free(m_data_arr);
}
 
void
Fragment::set_header_fields(const FragmentHeader& header)
{
  header_()->trigger_number = header.trigger_number;
  header_()->trigger_timestamp = header.trigger_timestamp;
  header_()->window_begin = header.window_begin;
  header_()->window_end = header.window_end;
  header_()->run_number = header.run_number;
  header_()->element_id = header.element_id;
  header_()->detector_id = header.detector_id;
  header_()->error_bits = header.error_bits;
  header_()->fragment_type = header.fragment_type;
  header_()->sequence_number = header.sequence_number;
}
 
void
Fragment::set_error_bit(FragmentErrorBits bit, bool value)
 
{
  auto bits = get_error_bits();
  bits[static_cast<size_t>(bit)] = value;
  set_error_bits(bits);
}
 
} // namespace daqdataformats
} // namespace dunedaq
 
#endif // DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_FRAGMENT_HPP_