Line data    Source code

       1              : /**
       2              :  * @file timeslice.cpp
       3              :  *
       4              :  * This is part of the DUNE DAQ Software Suite, copyright 2020.
       5              :  * Licensing/copyright details are in the COPYING file that you should have
       6              :  * received with this code.
       7              :  */
       8              : 
       9              : #include "daqdataformats/TimeSlice.hpp"
      10              : #include "daqdataformats/TimeSliceHeader.hpp"
      11              : 
      12              : #include <pybind11/pybind11.h>
      13              : #include <pybind11/stl.h>
      14              : 
      15              : #include <memory>
      16              : #include <sstream>
      17              : #include <vector>
      18              : 
      19              : namespace py = pybind11;
      20              : 
      21              : namespace dunedaq::daqdataformats::python {
      22              : 
      23              : void
      24            0 : register_timeslice(py::module& m)
      25              : {
      26            0 :   py::class_<TimeSliceHeader>(m, "TimeSliceHeader")
      27            0 :     .def(py::init<>())
      28            0 :     .def_property_readonly_static("s_timeslice_header_marker",
      29            0 :                                   [](const py::object&) -> uint32_t { // NOLINT(build/unsigned)
      30              :                                     return TimeSliceHeader::s_timeslice_header_marker;
      31              :                                   })
      32            0 :     .def_property_readonly_static("s_timeslice_header_version",
      33            0 :                                   [](const py::object&) -> uint32_t { // NOLINT(build/unsigned)
      34              :                                     return TimeSliceHeader::s_timeslice_header_version;
      35              :                                   })
      36            0 :     .def_property_readonly("timeslice_header_marker",
      37            0 :                            [](const TimeSliceHeader& self) -> uint32_t { // NOLINT(build/unsigned)
      38            0 :                              return self.timeslice_header_marker;
      39              :                            })
      40            0 :     .def_property_readonly(
      41            0 :       "version", [](const TimeSliceHeader& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
      42            0 :     .def_property_readonly("timeslice_number",
      43            0 :                            [](const TimeSliceHeader& self) -> timeslice_number_t { return self.timeslice_number; })
      44            0 :     .def_property_readonly("run_number", [](const TimeSliceHeader& self) -> run_number_t { return self.run_number; })
      45            0 :     .def_property_readonly("element_id", [](const TimeSliceHeader& self) -> SourceID { return self.element_id; })
      46            0 :     .def("__str__",
      47            0 :          [](const TimeSliceHeader& hdr) {
      48            0 :            std::ostringstream oss;
      49            0 :            oss << hdr;
      50            0 :            return oss.str();
      51            0 :          })
      52            0 :     .def("__repr__", [](const TimeSliceHeader& hdr) {
      53            0 :       std::ostringstream oss;
      54            0 :       oss << "<daqdataformats::TimeSliceHeader " << hdr << ">";
      55            0 :       return oss.str();
      56            0 :     });
      57              : 
      58            0 :   py::class_<TimeSlice> py_timeslice(m, "TimeSlice", pybind11::buffer_protocol());
      59            0 :   py_timeslice.def(py::init<TimeSliceHeader const&>())
      60            0 :     .def(py::init<timeslice_number_t, run_number_t>())
      61            0 :     .def(
      62            0 :       "get_header", [](TimeSlice& self) { return self.get_header(); }, py::return_value_policy::reference_internal)
      63              :     //    .def("set_header", &TimeSlice::set_header)
      64            0 :     .def(
      65              :       "get_fragments_ref",
      66            0 :       [](TimeSlice& self) {
      67            0 :         auto fragments = py::list();
      68            0 :         for (auto& fragment : self.get_fragments_ref()) {
      69            0 :           auto py_fragment = py::cast(*fragment, py::return_value_policy::reference);
      70            0 :           fragments.append(py_fragment);
      71            0 :         }
      72            0 :         return fragments;
      73            0 :       },
      74            0 :       py::return_value_policy::reference_internal)
      75            0 :     .def("get_total_size_bytes", &TimeSlice::get_total_size_bytes)
      76            0 :     .def("get_sum_of_fragment_payload_sizes", &TimeSlice::get_sum_of_fragment_payload_sizes);
      77            0 : } // NOLINT
      78              : 
      79              : } // namespace dunedaq::daqdataformats::python