TriggerRecordHeader.hpp

Go to the documentation of this file.

 
#ifndef DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_TRIGGERRECORDHEADER_HPP_
#define DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_TRIGGERRECORDHEADER_HPP_
 
#include "daqdataformats/ComponentRequest.hpp"
#include "daqdataformats/SourceID.hpp"
#include "daqdataformats/TriggerRecordHeaderData.hpp"
#include "daqdataformats/Types.hpp"
 
#include <bitset>
#include <cstddef>
#include <cstring>
#include <new>
#include <ostream>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace dunedaq::daqdataformats {
 
class TriggerRecordHeader
{
public:
  inline explicit TriggerRecordHeader(const std::vector<ComponentRequest>& components);
 
  inline explicit TriggerRecordHeader(void* existing_trigger_record_header_buffer, bool copy_from_buffer = false);
 
  inline TriggerRecordHeader(TriggerRecordHeader const& other);
  inline TriggerRecordHeader& operator=(TriggerRecordHeader const& other);
 
  TriggerRecordHeader(TriggerRecordHeader&& other)
  {
    m_alloc = other.m_alloc;
    other.m_alloc = false;
    m_data_arr = other.m_data_arr;
  }
  TriggerRecordHeader& operator=(TriggerRecordHeader&& other)
  {
    m_alloc = other.m_alloc;
    other.m_alloc = false;
    m_data_arr = other.m_data_arr;
    return *this;
  }
 
  ~TriggerRecordHeader()
  {
    if (m_alloc)
      free(m_data_arr);
  }
 
  TriggerRecordHeaderData get_header() const { return *header_(); }
 
  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; }
  timestamp_t get_trigger_timestamp() const { return header_()->trigger_timestamp; }
  void set_trigger_timestamp(timestamp_t trigger_timestamp) { header_()->trigger_timestamp = trigger_timestamp; }
 
  uint64_t get_num_requested_components() const // NOLINT(build/unsigned)
  {
    return header_()->num_requested_components;
  }
 
  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; }
 
  std::bitset<32> get_error_bits() const { return header_()->error_bits; }
  void set_error_bits(std::bitset<32> bits) { header_()->error_bits = bits.to_ulong(); }
  bool get_error_bit(TriggerRecordErrorBits bit) const { return get_error_bits()[static_cast<size_t>(bit)]; }
  void set_error_bit(TriggerRecordErrorBits bit, bool value)
  {
    auto bits = get_error_bits();
    bits[static_cast<size_t>(bit)] = value;
    set_error_bits(bits);
  }
 
  trigger_type_t get_trigger_type() const { return header_()->trigger_type; }
  void set_trigger_type(trigger_type_t trigger_type) { header_()->trigger_type = trigger_type; }
 
  trigger_number_t get_sequence_number() const { return header_()->sequence_number; }
  void set_sequence_number(sequence_number_t number) { header_()->sequence_number = number; }
 
  trigger_number_t get_max_sequence_number() const { return header_()->max_sequence_number; }
  void set_max_sequence_number(sequence_number_t number) { header_()->max_sequence_number = number; }
 
  SourceID get_element_id() const { return header_()->element_id; }
  void set_element_id(SourceID source_id) { header_()->element_id = source_id; }
 
  size_t get_total_size_bytes() const
  {
    return header_()->num_requested_components * sizeof(ComponentRequest) + sizeof(TriggerRecordHeaderData);
  }
  const void* get_storage_location() const { return m_data_arr; }
 
  inline ComponentRequest at(size_t idx) const;
 
  inline ComponentRequest& operator[](size_t idx);
 
  inline ComponentRequest const& get_component_for_source_id(SourceID const& source_id) const;
 
private:
  TriggerRecordHeaderData* header_() const { return static_cast<TriggerRecordHeaderData*>(m_data_arr); }
 
  void* m_data_arr{
    nullptr
  };                     
  bool m_alloc{ false }; 
};
 
//------
 
TriggerRecordHeader::TriggerRecordHeader(const std::vector<ComponentRequest>& components)
{
  size_t size = sizeof(TriggerRecordHeaderData) + components.size() * sizeof(ComponentRequest);
 
  m_data_arr = malloc(size); // NOLINT(build/unsigned)
  if (m_data_arr == nullptr) {
    throw std::bad_alloc();
  }
  m_alloc = true;
 
  TriggerRecordHeaderData header;
  header.num_requested_components = components.size();
  std::memcpy(m_data_arr, &header, sizeof(header));
 
  size_t offset = sizeof(header);
  for (auto const& component : components) {
    std::memcpy(static_cast<uint8_t*>(m_data_arr) + offset, &component, sizeof(component)); // NOLINT
    offset += sizeof(component);
  }
}
 
TriggerRecordHeader::TriggerRecordHeader(void* existing_trigger_record_header_buffer, bool copy_from_buffer)
{
  if (!copy_from_buffer) {
    m_data_arr = existing_trigger_record_header_buffer;
  } else {
    auto header = reinterpret_cast<TriggerRecordHeaderData*>(existing_trigger_record_header_buffer); // NOLINT
    size_t size = header->num_requested_components * sizeof(ComponentRequest) + sizeof(TriggerRecordHeaderData);
 
    m_data_arr = malloc(size);
    if (m_data_arr == nullptr) {
      throw std::bad_alloc();
    }
    m_alloc = true;
    std::memcpy(m_data_arr, existing_trigger_record_header_buffer, size);
  }
}
 
TriggerRecordHeader::TriggerRecordHeader(TriggerRecordHeader const& other)
  : TriggerRecordHeader(other.m_data_arr, true)
{}
 
TriggerRecordHeader&
TriggerRecordHeader::operator=(TriggerRecordHeader const& other)
{
  if (&other == this)
    return *this;
 
  if (m_alloc) {
    free(m_data_arr);
  }
  m_data_arr = malloc(other.get_total_size_bytes());
  if (m_data_arr == nullptr) {
    throw std::bad_alloc();
  }
  m_alloc = true;
  std::memcpy(m_data_arr, other.m_data_arr, other.get_total_size_bytes());
  return *this;
}
 
ComponentRequest
TriggerRecordHeader::at(size_t idx) const
{
  if (idx >= header_()->num_requested_components) {
    throw std::range_error("Supplied ComponentRequest index is larger than the maximum index.");
  }
  // Increment header pointer by one to skip header
  return *(reinterpret_cast<ComponentRequest*>(header_() + 1) + idx); // NOLINT
}
 
ComponentRequest&
TriggerRecordHeader::operator[](size_t idx)
{
  if (idx >= header_()->num_requested_components) {
    throw std::range_error("Supplied ComponentRequest index is larger than the maximum index.");
  }
  // Increment header pointer by one to skip header
  return *(reinterpret_cast<ComponentRequest*>(header_() + 1) + idx); // NOLINT
}
 
ComponentRequest const&
TriggerRecordHeader::get_component_for_source_id(SourceID const& source_id) const
{
  for (uint64_t idx = 0; idx < get_num_requested_components(); ++idx) {
    ComponentRequest const& component_obj = *(reinterpret_cast<ComponentRequest*>(header_() + 1) + idx); // NOLINT
    if (source_id == component_obj.component) {
      return component_obj;
    }
  }
  throw std::invalid_argument("Supplied SourceID (" + source_id.to_string() + ") was not found in the ComponentRequest list.");
}
 
} // namespace dunedaq::daqdataformats
 
#endif // DAQDATAFORMATS_INCLUDE_DAQDATAFORMATS_TRIGGERRECORDHEADER_HPP_