pyxcp 0.23.3__cp312-cp312-win_arm64.whl → 0.25.6__cp312-cp312-win_arm64.whl

pyxcp/recorder/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

pyxcp/recorder/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
+</project>

pyxcp/recorder/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/recorder.iml" filepath="$PROJECT_DIR$/.idea/recorder.iml" />
+    </modules>
+  </component>
+</project>

pyxcp/recorder/.idea/recorder.iml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module classpath="CMake" type="CPP_MODULE" version="4">
+  <component name="SonarLintModuleSettings">
+    <option name="uniqueId" value="ce2142a1-5ccc-4675-8d23-c6ee960ba851" />
+  </component>
+</module>

pyxcp/recorder/.idea/sonarlint/issuestore/3/8/3808afc69ac1edb9d760000a2f137335b1b99728

@@ -0,0 +1,7 @@
+
+T	cpp:S5028"8Replace this macro by "const", "constexpr" or an "enum".(����8�󓀹1
+	cpp:S3806""^non-portable path to file '<windows.h>'; specified path differs in case from file name on disk(��������
8�����1
+Tcpp:S954�
"8Move these 3 #include directives to the top of the file.(���8ﴔ��1
+T	cpp:S5028"8Replace this macro by "const", "constexpr" or an "enum".(����8帔��1
+	cpp:S3806""^non-portable path to file '<windows.h>'; specified path differs in case from file name on disk(��������
8�Ӕ��1
+Tcpp:S954�
"8Move these 3 #include directives to the top of the file.(���8�Ԕ��1

pyxcp/recorder/.idea/sonarlint/issuestore/index.pb

@@ -0,0 +1,7 @@
+
+>
+CMakeLists.txt,9\a\9a2aa4db38d3115ed60da621e012c0efc0172aae
+8
+wrap.cpp,b\4\b49006702b459496a8e8c94ebe60947108361b91
+<
+rekorder.hpp,3\8\3808afc69ac1edb9d760000a2f137335b1b99728

pyxcp/recorder/.idea/sonarlint/securityhotspotstore/index.pb

@@ -0,0 +1,7 @@
+
+>
+CMakeLists.txt,9\a\9a2aa4db38d3115ed60da621e012c0efc0172aae
+8
+wrap.cpp,b\4\b49006702b459496a8e8c94ebe60947108361b91
+<
+rekorder.hpp,3\8\3808afc69ac1edb9d760000a2f137335b1b99728

pyxcp/recorder/.idea/vcs.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lz4" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/mio" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/simde" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/simdjson" vcs="Git" />
+  </component>
+</project>

pyxcp/recorder/__init__.py

@@ -1,11 +1,10 @@
 #!/usr/bin/env python
-"""XCP Frame Recording Facility.
-"""
+"""XCP Frame Recording Facility."""
 
 from dataclasses import dataclass
 from typing import Union
 
-from pyxcp.types import FrameCategory
+from pyxcp.transport.base import FrameCategory
 
 
 try:
@@ -16,13 +15,9 @@ else:
     HAS_PANDAS = True
 
 from pyxcp.recorder.rekorder import DaqOnlinePolicy  # noqa: F401
-from pyxcp.recorder.rekorder import (
-    DaqRecorderPolicy,      # noqa: F401
-    Deserializer,           # noqa: F401
-    MeasurementParameters,  # noqa: F401
-    ValueHolder,            # noqa: F401
-)
-from pyxcp.recorder.rekorder import XcpLogFileDecoder as _XcpLogFileDecoder
+from pyxcp.recorder.rekorder import DaqRecorderPolicy  # noqa: F401
+from pyxcp.recorder.rekorder import Deserializer  # noqa: F401
+from pyxcp.recorder.rekorder import MeasurementParameters  # noqa: F401
 from pyxcp.recorder.rekorder import _PyXcpLogFileReader, _PyXcpLogFileWriter, data_types
 
 

pyxcp/recorder/converter/__init__.py

@@ -1,5 +1,6 @@
 """Convert pyXCPs .xmraw files to common data formats."""
 
+from contextlib import suppress
 import csv
 import logging
 import os
@@ -119,10 +120,8 @@ class XcpLogFileDecoder(_XcpLogFileDecoder):
         self.out_file_suffix = out_file_suffix
         self.target_type_map = target_type_map or {}
         if remove_file:
-            try:
+            with suppress(FileNotFoundError):
                 os.unlink(self.out_file_name)
-            except FileNotFoundError:
-                pass
 
     def initialize(self) -> None:
         self.on_initialize()
@@ -154,7 +153,6 @@ class XcpLogFileDecoder(_XcpLogFileDecoder):
 
 
 class CollectRows:
-
     def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
         storage_container = self.tables[daq_list_num]
         storage_container.timestamp0.append(timestamp0)
@@ -214,7 +212,6 @@ class ArrowConverter(CollectRows, XcpLogFileDecoder):
 
 
 class CsvConverter(XcpLogFileDecoder):
-
     def __init__(self, recording_file_name: str, target_file_name: str = ""):
         super().__init__(
             recording_file_name=recording_file_name, out_file_suffix=".csv", remove_file=False, target_file_name=target_file_name
@@ -242,7 +239,6 @@ class CsvConverter(XcpLogFileDecoder):
 
 
 class ExcelConverter(XcpLogFileDecoder):
-
     def __init__(self, recording_file_name: str, target_file_name: str = ""):
         super().__init__(recording_file_name=recording_file_name, out_file_suffix=".xlsx", target_file_name=target_file_name)
 
@@ -273,7 +269,6 @@ class ExcelConverter(XcpLogFileDecoder):
 
 
 class HdfConverter(CollectRows, XcpLogFileDecoder):
-
     def __init__(self, recording_file_name: str, target_file_name: str = ""):
         super().__init__(recording_file_name=recording_file_name, out_file_suffix=".h5", target_file_name=target_file_name)
 
@@ -296,7 +291,6 @@ class HdfConverter(CollectRows, XcpLogFileDecoder):
 
 
 class MdfConverter(CollectRows, XcpLogFileDecoder):
-
     def __init__(self, recording_file_name: str, target_file_name: str = ""):
         super().__init__(
             recording_file_name=recording_file_name,
@@ -367,8 +361,8 @@ class SqliteConverter(XcpLogFileDecoder):
         self.create_table(sc)
         self.logger.info(f"Creating table {sc.name!r}.")
         self.insert_stmt[sc.name] = (
-            f"""INSERT INTO {sc.name}({', '.join(['timestamp0', 'timestamp1'] + [r.name for r in sc.arr])})"""
-            f""" VALUES({', '.join(["?" for _ in range(len(sc.arr) + 2)])})"""
+            f"""INSERT INTO {sc.name}({", ".join(["timestamp0", "timestamp1"] + [r.name for r in sc.arr])})"""
+            f""" VALUES({", ".join(["?" for _ in range(len(sc.arr) + 2)])})"""
         )
 
     def on_finalize(self) -> None:

pyxcp/recorder/reader.hpp

@@ -47,7 +47,6 @@ class XcpLogFileReader {
             read_bytes(m_offset, sizeof(std::size_t), reinterpret_cast<blob_t *>(&metadata_length));
 
             std::copy(ptr(data_start), ptr(data_start + metadata_length), std::back_inserter(m_metadata));
-            // std::cout << "Metadata: " << m_metadata << std::endl;
             m_offset += (metadata_length + sizeof(std::size_t));
         }
     }

pyxcp/recorder/reco.py

@@ -12,6 +12,7 @@ See
 
 -  ``_ for reading.
 """
+
 import enum
 import mmap
 import struct

pyxcp/recorder/unfolder.hpp

@@ -13,6 +13,7 @@
     #include <stdfloat>
 #endif
 #include <variant>
+#include <memory>
 
 #include "daqlist.hpp"
 #include "helper.hpp"
@@ -324,7 +325,7 @@ struct Getter {
         }
     }
 
-    void set_first_pids(const std::vector<DaqList>& daq_lists, const std::vector<std::uint16_t>& first_pids) {
+    void set_first_pids(const std::vector<std::shared_ptr<DaqListBase>>& daq_lists, const std::vector<std::uint16_t>& first_pids) {
         m_first_pids = first_pids;
 
         if (m_id_size == 1) {
@@ -333,7 +334,7 @@ struct Getter {
             for (const auto& daq_list : daq_lists) {
                 auto first_pid = m_first_pids[daq_list_num];
 
-                for (std::uint16_t idx = first_pid; idx < daq_list.get_odt_count() + first_pid; ++idx) {
+                for (std::uint16_t idx = first_pid; idx < daq_list->get_odt_count() + first_pid; ++idx) {
                     m_odt_to_daq_map[idx] = { daq_list_num, (idx - first_pid) };
                 }
                 daq_list_num++;
@@ -540,7 +541,7 @@ struct MeasurementParameters {
     explicit MeasurementParameters(
         std::uint8_t byte_order, std::uint8_t id_field_size, bool timestamps_supported, bool ts_fixed, bool prescaler_supported,
         bool selectable_timestamps, double ts_scale_factor, std::uint8_t ts_size, std::uint16_t min_daq,
-        const TimestampInfo& timestamp_info, const std::vector<DaqList>& daq_lists, const std::vector<std::uint16_t>& first_pids
+        const TimestampInfo& timestamp_info, const std::vector<std::shared_ptr<DaqListBase>>& daq_lists, const std::vector<std::uint16_t>& first_pids
     ) :
         m_byte_order(byte_order),
         m_id_field_size(id_field_size),
@@ -578,7 +579,7 @@ struct MeasurementParameters {
         ////
 
         for (const auto& daq_list : m_daq_lists) {
-            ss << daq_list.dumps();
+            ss << daq_list->dumps();
         }
 
         std::size_t fp_count = m_first_pids.size();
@@ -675,7 +676,7 @@ struct MeasurementParameters {
     std::uint8_t               m_ts_size;
     std::uint16_t              m_min_daq;
     TimestampInfo              m_timestamp_info;
-    std::vector<DaqList>       m_daq_lists;
+    std::vector<std::shared_ptr<DaqListBase>> m_daq_lists;
     std::vector<std::uint16_t> m_first_pids;
 };
 
@@ -696,7 +697,7 @@ class Deserializer {
         std::uint8_t               ts_size;
         std::uint16_t              min_daq;
         std::size_t                dl_count;
-        std::vector<DaqList>       daq_lists;
+        std::vector<std::shared_ptr<DaqListBase>> daq_lists;
         std::size_t                fp_count;
         std::uint64_t              timestamp_ns;
         std::int16_t               utc_offset;
@@ -716,20 +717,21 @@ class Deserializer {
         min_daq               = from_binary<std::uint16_t>();
         dl_count              = from_binary<std::size_t>();
 
-        ////
         timestamp_ns = from_binary<std::uint64_t>();
-        // std::cout << "TS: " << timestamp_ns << std::endl;
         timezone = from_binary_str();
-        // std::cout << "TZ: " << timezone << std::endl;
         utc_offset = from_binary<std::int16_t>();
-        // std::cout << "UTC:" << utc_offset << std::endl;
         dst_offset = from_binary<std::int16_t>();
-        // std::cout << "DST:" << dst_offset << std::endl;
 
         TimestampInfo timestamp_info{ timestamp_ns, timezone, utc_offset, dst_offset };
 
         for (std::size_t i = 0; i < dl_count; i++) {
-            daq_lists.push_back(create_daq_list());
+			auto discr = from_binary<std::uint8_t>();
+
+			if (discr == 1) {
+				daq_lists.push_back(create_daq_list());
+			} else if (discr == 2) {
+				daq_lists.push_back(create_predefined_daq_list());
+			}
         }
 
         fp_count = from_binary<std::size_t>();
@@ -745,9 +747,10 @@ class Deserializer {
 
    protected:
 
-    DaqList create_daq_list() {
+    std::shared_ptr<DaqListBase> create_daq_list() {
         std::string              name;
         std::uint16_t            event_num;
+        std::uint16_t            prescaler;
         bool                     stim;
         bool                     enable_timestamps;
         std::vector<McObject>    measurements;
@@ -766,6 +769,8 @@ class Deserializer {
         event_num         = from_binary<std::uint16_t>();
         stim              = from_binary<bool>();
         enable_timestamps = from_binary<bool>();
+        std::uint8_t priority = from_binary<std::uint8_t>();
+        prescaler         = from_binary<std::uint8_t>();
 
         odt_count     = from_binary<std::uint16_t>();  // not used
         total_entries = from_binary<std::uint16_t>();  // not used
@@ -773,7 +778,6 @@ class Deserializer {
 
         std::size_t meas_size = from_binary<std::size_t>();
         for (std::size_t i = 0; i < meas_size; ++i) {
-            // name, address, ext, dt_name
             auto meas = create_mc_object();
             measurements.push_back(meas);
             initializer_list.push_back({ meas.get_name(), meas.get_address(), meas.get_ext(), meas.get_data_type() });
@@ -790,38 +794,68 @@ class Deserializer {
             header_names.push_back(header);
         }
 
-        auto odts = create_flatten_odts();
-
-        auto result = DaqList(name, event_num, stim, enable_timestamps, initializer_list);
-        result.set_measurements_opt(measurements_opt);
-        return result;
+        auto dl = std::make_shared<DaqList>(name, event_num, stim, enable_timestamps, initializer_list, priority, prescaler);
+        dl->set_measurements_opt(measurements_opt);
+        return dl;
     }
 
-    flatten_odts_t create_flatten_odts() {
-        std::string   name;
-        std::uint32_t address;
-        std::uint8_t  ext;
-        std::uint16_t size;
-        std::int16_t  type_index;
-
-        flatten_odts_t odts;
-
-        std::size_t odt_count = from_binary<std::size_t>();
-        for (std::size_t i = 0; i < odt_count; ++i) {
-            std::vector<std::tuple<std::string, std::uint32_t, std::uint8_t, std::uint16_t, std::int16_t>> flatten_odt{};
-            std::size_t odt_entry_count = from_binary<std::size_t>();
-            for (std::size_t j = 0; j < odt_entry_count; ++j) {
-                name       = from_binary_str();
-                address    = from_binary<std::uint32_t>();
-                ext        = from_binary<std::uint8_t>();
-                size       = from_binary<std::uint16_t>();
-                type_index = from_binary<std::int16_t>();
-                flatten_odt.push_back(std::make_tuple(name, address, ext, size, type_index));
+    std::shared_ptr<DaqListBase> create_predefined_daq_list() {
+        std::string              name;
+        std::uint16_t            event_num;
+        std::uint8_t             priority;
+        std::uint8_t             prescaler;
+        bool                     stim;
+        bool                     enable_timestamps;
+        std::vector<Bin>         measurements_opt;
+        std::vector<std::string> header_names;
+        PredefinedDaqList::predefined_daq_list_initializer_t odts;
+        std::uint16_t odt_count;
+        std::uint16_t total_entries;
+        std::uint16_t total_length;
+
+        name              = from_binary_str();
+        event_num         = from_binary<std::uint16_t>();
+        stim              = from_binary<bool>();
+        enable_timestamps = from_binary<bool>();
+        priority          = from_binary<std::uint8_t>();
+        prescaler         = from_binary<std::uint8_t>();
+
+        odt_count     = from_binary<std::uint16_t>();  // not used
+        total_entries = from_binary<std::uint16_t>();  // not used
+        total_length  = from_binary<std::uint16_t>();  // not used
+
+        std::size_t meas_opt_size = from_binary<std::size_t>();
+        for (std::size_t i = 0; i < meas_opt_size; ++i) {
+            measurements_opt.emplace_back(create_bin());
+        }
+
+        std::size_t hname_size = from_binary<std::size_t>();
+        for (std::size_t i = 0; i < hname_size; ++i) {
+            auto header = from_binary_str();
+            header_names.push_back(header);
+        }
+
+        // Build `odts` from `measurements_opt` so the constructor is properly initialized
+        odts.clear();
+        odts.reserve(measurements_opt.size());
+        for (const auto& bin : measurements_opt) {
+            PredefinedDaqList::odt_initializer_t odt_init;
+            for (const auto& mc_obj : bin.get_entries()) {
+                const auto& comps = mc_obj.get_components();
+                if (comps.empty()) {
+                    odt_init.emplace_back(mc_obj.get_name(), mc_obj.get_data_type());
+                } else {
+                    for (const auto& component : comps) {
+                        odt_init.emplace_back(component.get_name(), component.get_data_type());
+                    }
+                }
             }
-            odts.push_back(flatten_odt);
+            odts.emplace_back(std::move(odt_init));
         }
 
-        return odts;
+        auto dl = std::make_shared<PredefinedDaqList>(name, event_num, stim, enable_timestamps, odts, priority, prescaler);
+        dl->set_measurements_opt(measurements_opt);
+        return dl;
     }
 
     McObject create_mc_object() {
@@ -1057,8 +1091,8 @@ class DAQProcessor {
         m_getter = Getter(requires_swap(params.m_byte_order), params.m_id_field_size, params.m_ts_size);
         for (std::uint16_t idx = 0; idx < params.m_daq_lists.size(); ++idx) {
             m_state.emplace_back(DaqListState(
-                idx, params.m_daq_lists[idx].get_odt_count(), params.m_daq_lists[idx].get_total_entries(),
-                params.m_daq_lists[idx].get_enable_timestamps(), params.m_id_field_size, params.m_daq_lists[idx].get_flatten_odts(),
+                idx, params.m_daq_lists[idx]->get_odt_count(), params.m_daq_lists[idx]->get_total_entries(),
+                params.m_daq_lists[idx]->get_enable_timestamps(), params.m_id_field_size, params.m_daq_lists[idx]->get_flatten_odts(),
                 m_getter, params
             ));
         }
@@ -1109,8 +1143,9 @@ class DaqRecorderPolicy : public DAQPolicyBase {
     }
 
     void feed(std::uint8_t frame_cat, std::uint16_t counter, std::uint64_t timestamp, const std::string& payload) override {
-        if (frame_cat != static_cast<std::uint8_t>(FrameCategory::DAQ)) {
+        if (frame_cat != static_cast<std::uint8_t>(FrameCategory::DAQ) || (!m_initialized)) {
             // Only record DAQ frames for now.
+			// also make sure policy is initialized.
             return;
         }
         m_writer->add_frame(frame_cat, counter, timestamp, static_cast<std::uint16_t>(payload.size()), payload.c_str());
@@ -1139,6 +1174,42 @@ class DaqRecorderPolicy : public DAQPolicyBase {
     bool                              m_initialized{ false };
 };
 
+class DaqTimeTracker {
+public:
+
+    DaqTimeTracker(std::uint64_t overflow_value) : m_overflow_value(overflow_value), m_overflow_counter(0ULL), m_previous_timestamp(0ULL) {
+		m_ts_base_set=false;
+		m_ts0_base=0ULL; m_ts1_base=0ULL;
+		//std::cout << "\tOverflow value: " << overflow_value << "\n";
+	}
+
+    std::pair<std::uint64_t,std::uint64_t> normalize(std::uint64_t ts0, std::uint64_t ts1) noexcept {
+
+		if (m_previous_timestamp > ts1) {
+			m_overflow_counter++;
+		}
+		m_previous_timestamp = ts1;
+
+        if (!m_ts_base_set) {
+            m_ts0_base = ts0;
+            m_ts1_base = ts1;
+            m_ts_base_set = true;
+			// std::cout << "\tSet ts0: " << ts0 << " ts1:" << ts1 << "\n";
+        }
+		// std::cout << "\t\tts0: " << ts0 << " Base: " << m_ts0_base << "  ts1: " << ts1 << " Base: " << m_ts1_base << "\n";
+        return {ts0 - m_ts0_base, (ts1 - m_ts1_base) + (m_overflow_value * m_overflow_counter) };
+    }
+private:
+
+    std::uint64_t m_overflow_value{};
+    std::uint64_t m_overflow_counter{};
+    std::uint64_t m_previous_timestamp{};
+    bool m_ts_base_set{false};
+    std::uint64_t m_ts0_base{0ULL};
+    std::uint64_t m_ts1_base{0ULL};
+};
+
+
 class DaqOnlinePolicy : public DAQPolicyBase {
    public:
 
@@ -1149,6 +1220,9 @@ class DaqOnlinePolicy : public DAQPolicyBase {
 
     void set_parameters(const MeasurementParameters& params) noexcept {
         m_decoder = std::make_unique<DAQProcessor>(params);
+		for (auto idx=0; idx < params.get_daq_lists().size(); ++idx) {
+            m_overflows.emplace_back(DaqTimeTracker(params.get_overflow_value()));
+        }
         DAQPolicyBase::set_parameters(params);
     }
 
@@ -1164,7 +1238,11 @@ class DaqOnlinePolicy : public DAQPolicyBase {
         auto result = m_decoder->feed(timestamp, payload);
         if (result) {
             const auto& [daq_list, ts0, ts1, meas] = *result;
-            on_daq_list(daq_list, ts0, ts1, meas);
+			auto& overflow = m_overflows[daq_list];
+
+            auto [norm_ts0, norm_ts1] = overflow.normalize(ts0, ts1);
+
+			on_daq_list(daq_list, norm_ts0, norm_ts1, meas);
         }
     }
 
@@ -1177,58 +1255,9 @@ class DaqOnlinePolicy : public DAQPolicyBase {
    private:
 
     std::unique_ptr<DAQProcessor> m_decoder;
+	std::vector<DaqTimeTracker>   m_overflows;
 };
 
-struct ValueHolder {
-    ValueHolder()                   = delete;
-    ValueHolder(const ValueHolder&) = default;
-
-    ValueHolder(const std::any& value) : m_value(value) {
-    }
-
-    ValueHolder(std::any&& value) : m_value(std::move(value)) {
-    }
-
-    std::any get_value() const noexcept {
-        return m_value;
-    }
-
-   private:
-
-    std::any m_value;
-};
-
-class Overflow {
-public:
-
-    Overflow(std::uint64_t overflow_value) : m_overflow_value(overflow_value), m_overflow_counter(0ULL), m_previous_timestamp(0ULL) {
-    }
-
-    auto get_previous_timestamp() const noexcept {
-        return m_previous_timestamp;
-    }
-
-    void set_previous_timestamp(std::uint64_t timestamp) noexcept {
-        m_previous_timestamp = timestamp;
-    }
-
-    void inc_overflow_counter() noexcept {
-        m_overflow_counter++;
-    }
-
-    auto get_overflow_counter() const noexcept {
-        return m_overflow_counter;
-    }
-
-    auto get_value() const noexcept {
-        return m_overflow_value * m_overflow_counter;
-    }
-
-private:
-    std::uint64_t m_overflow_value{};
-    std::uint64_t m_overflow_counter{};
-    std::uint64_t m_previous_timestamp{};
-};
 
 class XcpLogFileDecoder {
    public:
@@ -1240,12 +1269,12 @@ class XcpLogFileDecoder {
             m_params  = des.run();
 
             for (auto idx=0; idx < m_params.get_daq_lists().size(); ++idx) {
-                m_overflows.emplace_back(Overflow(m_params.get_overflow_value()));
+                m_overflows.emplace_back(DaqTimeTracker(m_params.get_overflow_value()));
             }
 
             m_decoder = std::make_unique<DAQProcessor>(m_params);
         } else {
-            // cannot proceed!!!
+            throw std::runtime_error("XcpLogFileDecoder: missing metadata.");
         }
     }
 
@@ -1286,18 +1315,11 @@ class XcpLogFileDecoder {
                 auto result = m_decoder->feed(timestamp, str_data);
                 if (result) {
                     const auto& [daq_list, ts0, ts1, meas] = *result;
-
                     auto& overflow = m_overflows[daq_list];
 
-                    if (overflow.get_previous_timestamp() > ts1) {
-                        overflow.inc_overflow_counter();
-                        // Maybe on debug-level?
-                        // std::cout << "Overflow detected, counter: " << overflow.get_overflow_counter() << " " << overflow.get_previous_timestamp() << " " << ts1 << std::endl;
-                    }
-
-                    on_daq_list(daq_list, ts0, ts1 + overflow.get_value(), meas);
+                    auto [norm_ts0, norm_ts1] = overflow.normalize(ts0, ts1);
 
-                    overflow.set_previous_timestamp(ts1);
+                    on_daq_list(daq_list, norm_ts0, norm_ts1, meas);
                 }
             }
         }
@@ -1326,7 +1348,7 @@ class XcpLogFileDecoder {
     XcpLogFileReader              m_reader;
     std::unique_ptr<DAQProcessor> m_decoder;
     MeasurementParameters         m_params;
-    std::vector<Overflow>           m_overflows;
+    std::vector<DaqTimeTracker>   m_overflows;
 };
 
 #endif  // RECORDER_UNFOLDER_HPP

pyxcp/recorder/wrap.cpp

@@ -3,6 +3,7 @@
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
+#include <memory>
 
 #include <cstdint>
 
@@ -11,7 +12,6 @@
 namespace py = pybind11;
 using namespace pybind11::literals;
 
-PYBIND11_MAKE_OPAQUE(ValueHolder);
 
 class PyDaqOnlinePolicy : public DaqOnlinePolicy {
    public:
@@ -112,7 +112,7 @@ PYBIND11_MODULE(rekorder, m) {
     py::class_<MeasurementParameters>(m, "MeasurementParameters")
         .def(py::init<
              std::uint8_t, std::uint8_t, bool, bool, bool, bool, double, std::uint8_t, std::uint16_t, const TimestampInfo&,
-             const std::vector<DaqList>&, const std::vector<std::uint16_t>&>())
+             const std::vector<std::shared_ptr<DaqListBase>>&, const std::vector<std::uint16_t>&>())
         .def("dumps", [](const MeasurementParameters& self) { return py::bytes(self.dumps()); })
         .def(
             "__repr__",
@@ -131,7 +131,7 @@ PYBIND11_MODULE(rekorder, m) {
                 ss << "timestamp_info=" << self.get_timestamp_info().to_string() << ", ";
                 ss << "daq_lists=[\n";
                 for (const auto& dl : self.m_daq_lists) {
-                    ss << dl.to_string() << ",\n";
+                    ss << dl->to_string() << ",\n";
                 }
                 ss << "],\n";
                 ss << "first_pids=[";
@@ -181,9 +181,4 @@ PYBIND11_MODULE(rekorder, m) {
         .def("get_header", &XcpLogFileDecoder::get_header)
         .def("initialize", &XcpLogFileDecoder::initialize)
         .def("finalize", &XcpLogFileDecoder::finalize);
-
-    py::class_<ValueHolder>(m, "ValueHolder")
-        //.def(py::init<const ValueHolder&>())
-        .def(py::init<const std::any&>())
-        .def_property_readonly("value", &ValueHolder::get_value);
 }

pyxcp/scripts/xcp_fetch_a2l.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Fetch A2L file from XCP slave (if supported).
-"""
+"""Fetch A2L file from XCP slave (if supported)."""
+
 import sys
 from pathlib import Path