time_slice.cpp

Go to the documentation of this file.

 
#include "daqdataformats/TimeSlice.hpp"
#include "daqdataformats/TimeSliceHeader.hpp"
 
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
 
#include <memory>
#include <sstream>
#include <vector>
 
namespace py = pybind11;
 
namespace dunedaq::daqdataformats::python {
 
void
register_timeslice(py::module& m)
{
  py::class_<TimeSliceHeader>(m, "TimeSliceHeader")
    .def(py::init<>())
    .def_property_readonly_static("s_timeslice_header_marker",
                                  [](const py::object&) -> uint32_t { // NOLINT(build/unsigned)
                                    return TimeSliceHeader::s_timeslice_header_marker;
                                  })
    .def_property_readonly_static("s_timeslice_header_version",
                                  [](const py::object&) -> uint32_t { // NOLINT(build/unsigned)
                                    return TimeSliceHeader::s_timeslice_header_version;
                                  })
    .def_property_readonly("timeslice_header_marker",
                           [](const TimeSliceHeader& self) -> uint32_t { // NOLINT(build/unsigned)
                             return self.timeslice_header_marker;
                           })
    .def_property_readonly(
      "version", [](const TimeSliceHeader& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
    .def_property_readonly("timeslice_number",
                           [](const TimeSliceHeader& self) -> timeslice_number_t { return self.timeslice_number; })
    .def_property_readonly("run_number", [](const TimeSliceHeader& self) -> run_number_t { return self.run_number; })
    .def_property_readonly("element_id", [](const TimeSliceHeader& self) -> SourceID { return self.element_id; })
    .def("__str__",
         [](const TimeSliceHeader& hdr) {
           std::ostringstream oss;
           oss << hdr;
           return oss.str();
         })
    .def("__repr__", [](const TimeSliceHeader& hdr) {
      std::ostringstream oss;
      oss << "<daqdataformats::TimeSliceHeader " << hdr << ">";
      return oss.str();
    });
 
  py::class_<TimeSlice> py_timeslice(m, "TimeSlice", pybind11::buffer_protocol());
  py_timeslice.def(py::init<TimeSliceHeader const&>())
    .def(py::init<timeslice_number_t, run_number_t>())
    .def(
      "get_header", [](TimeSlice& self) { return self.get_header(); }, py::return_value_policy::reference_internal)
    //    .def("set_header", &TimeSlice::set_header)
    .def(
      "get_fragments_ref",
      [](TimeSlice& self) {
        auto fragments = py::list();
        for (auto& fragment : self.get_fragments_ref()) {
          auto py_fragment = py::cast(*fragment, py::return_value_policy::reference);
          fragments.append(py_fragment);
        }
        return fragments;
      },
      py::return_value_policy::reference_internal)
    .def("get_total_size_bytes", &TimeSlice::get_total_size_bytes)
    .def("get_sum_of_fragment_payload_sizes", &TimeSlice::get_sum_of_fragment_payload_sizes);
} // NOLINT
 
} // namespace dunedaq::daqdataformats::python