fixed size_t for consistencies, done everything except array of ns and map

include/aare/Hdf5File.hpp

@@ -46,7 +46,8 @@ class H5Handles {
   void get_data_into(size_t frame_index, std::byte *frame_buffer, size_t n_frames = 1) {
     seek(frame_index);
     count[0] = static_cast<hsize_t>(n_frames);
-    //std::cout << "offset:" << offset << " count:" << count << std::endl;
+    // std::cout << "offset:" << ToString(offset) << " count:" <<
+    // ToString(count) << std::endl;
     dataspace.selectHyperslab(H5S_SELECT_SET, count.data(), offset.data());
     dataset.read(frame_buffer, datatype, *memspace, dataspace);
   }
@@ -54,7 +55,8 @@ class H5Handles {
   void get_header_into(size_t frame_index, int part_index, std::byte *header_buffer) {
     seek(frame_index);
     offset[1] = static_cast<hsize_t>(part_index);
-    //std::cout << "offset:" << offset << " count:" << count << std::endl;
+    // std::cout << "offset:" << ToString(offset) << " count:" <<
+    // ToString(count) << std::endl;
     dataspace.selectHyperslab(H5S_SELECT_SET, count.data(), offset.data());
     dataset.read(header_buffer, datatype, *memspace, dataspace);
   }

include/aare/Hdf5MasterFile.hpp

@@ -58,37 +58,37 @@ class Hdf5MasterFile {
     size_t m_max_frames_per_file{};
     FrameDiscardPolicy m_frame_discard_policy{};
     size_t m_frame_padding{};
-    std::optional<ScanParameters> m_scan_parameters;
+    std::optional<ScanParameters> m_scan_parameters{};
     size_t m_total_frames_expected{};
     std::optional<ns> m_exptime{};
     std::optional<ns> m_period{};
-    std::optional<BurstMode> m_burst_mode;
-    std::optional<size_t> m_number_of_udp_interfaces;
+    std::optional<BurstMode> m_burst_mode{};
+    std::optional<size_t> m_number_of_udp_interfaces{};
     size_t m_bitdepth{};
-    std::optional<size_t> m_ten_giga;
-    std::optional<size_t> m_threshold_energy;
-    // thresholdall energy
+    std::optional<size_t> m_ten_giga{};
+    std::optional<size_t> m_threshold_energy{};
+    std::optional<std::vector<size_t>> m_threshold_energy_all{};
     std::optional<ns> m_subexptime{};
     std::optional<ns> m_subperiod{};
-    std::optional<uint8_t> m_quad;
-    std::optional<size_t> m_number_of_rows;
-    // ratecorr
-    uint32_t m_adc_mask{}; // TODO! implement reading
+    std::optional<uint8_t> m_quad{};
+    std::optional<size_t> m_number_of_rows{};
+    std::optional<std::vector<size_t>> m_rate_corrections{};
+    size_t m_adc_mask{};
     uint8_t m_analog_flag{};
-    std::optional<size_t> m_analog_samples;
+    std::optional<size_t> m_analog_samples{};
     uint8_t m_digital_flag{};
-    std::optional<size_t> m_digital_samples;
-    std::optional<size_t> m_dbit_offset;
-    // dbitlist
-    std::optional<size_t> m_transceiver_mask;
+    std::optional<size_t> m_digital_samples{};
+    std::optional<size_t> m_dbit_offset{};
+    std::optional<size_t> m_dbit_list{};
+    std::optional<size_t> m_transceiver_mask{};
     uint8_t m_transceiver_flag{};
-    std::optional<size_t> m_transceiver_samples;
+    std::optional<size_t> m_transceiver_samples{};
     // g1 roi
-    std::optional<ROI> m_roi;
-    std::optional<size_t> m_counter_mask;
+    std::optional<ROI> m_roi{};
+    std::optional<size_t> m_counter_mask{};
     // exptimearray
     // gatedelay array
-    // gates
+    std::optional<size_t> m_gates{};
     // additional json header
     size_t m_frames_in_file{};
 
@@ -125,19 +125,19 @@ class Hdf5MasterFile {
     size_t bitdepth() const;
     std::optional<size_t> ten_giga() const;
     std::optional<size_t> threshold_energy() const;
-    // thresholdall energy
+    std::optional<std::vector<size_t>> threshold_energy_all() const;
     std::optional<ns> subexptime() const;
     std::optional<ns> subperiod() const;
     std::optional<uint8_t> quad() const;
     std::optional<size_t> number_of_rows() const;
-    // ratecorr
-    std::optional<uint32_t> adc_mask() const; // TODO! implement reading
+    std::optional<std::vector<size_t>> rate_corrections() const;
+    std::optional<size_t> adc_mask() const;
     std::optional<uint8_t> analog_flag() const;
     std::optional<size_t> analog_samples() const;
     std::optional<uint8_t> digital_flag() const;
     std::optional<size_t> digital_samples() const;
     std::optional<size_t> dbit_offset() const;
-    // dbitlist
+    std::optional<size_t> dbit_list() const;
     std::optional<size_t> transceiver_mask() const; 
     std::optional<uint8_t> transceiver_flag() const;
     std::optional<size_t> transceiver_samples() const;
@@ -146,7 +146,7 @@ class Hdf5MasterFile {
     std::optional<size_t> counter_mask() const;
     // exptimearray
     // gatedelay array
-    // gates
+    std::optional<size_t> gates() const;
     // additional json header
     size_t frames_in_file() const;
     size_t n_modules() const;

include/aare/defs.hpp

@@ -3,19 +3,20 @@
 #include "aare/Dtype.hpp"
 #include "aare/type_traits.hpp"
 
+#include <algorithm>
 #include <array>
-#include <stdexcept>
 #include <cassert>
+#include <chrono>
 #include <cstdint>
 #include <cstring>
+#include <iostream>
+#include <optional>
+#include <sstream>
+#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <variant>
 #include <vector>
-#include <iostream>
-#include <sstream>  
-#include <optional>
-#include <chrono>
 
 /**
  * @brief LOCATION macro to get the current location in the code
@@ -377,9 +378,45 @@ T StringTo(const std::string &t) {
 template <typename T, std::enable_if_t<!is_duration<T>::value, int> = 0 > 
 T StringTo(const std::string &arg) { return T(arg); }
 
+// so that StringTo<std::vector<size_t>> below doesnt complain about the above
+// generic overload
+template <> inline size_t StringTo(const std::string &arg) {
+    return std::stoi(arg);
+}
+
+template <> inline std::vector<size_t> StringTo(const std::string &s) {
+    std::vector<size_t> result;
+    std::string str = s;
+    // Remove brackets and spaces
+    str.erase(std::remove_if(str.begin(), str.end(),
+                             [](unsigned char c) {
+                                 return c == '[' || c == ']' || std::isspace(c);
+                             }),
+              str.end());
+    std::stringstream ss(str);
+    std::string item;
+    while (std::getline(ss, item, ',')) {
+        if (!item.empty())
+            result.push_back(StringTo<size_t>(item));
+    }
+    return result;
+}
+
 template <class T, typename = std::enable_if_t<!is_duration<T>::value>> 
 std::string ToString(T arg) { return T(arg); }
 
+template <typename T> std::string ToString(const std::vector<T> &vec) {
+    std::ostringstream oss;
+    oss << "[";
+    for (size_t i = 0; i < vec.size(); ++i) {
+        oss << vec[i];
+        if (i != vec.size() - 1)
+            oss << ", ";
+    }
+    oss << "]";
+    return oss.str();
+}
+
 template <> DetectorType StringTo(const std::string & /*name*/);
 template <> std::string ToString(DetectorType arg);
 
@@ -399,19 +436,8 @@ template <> std::string ToString(ScanParameters arg);
 std::ostream &operator<<(std::ostream &os, const ROI &roi);
 template <> std::string ToString(ROI arg);
 
-
-using DataTypeVariants = std::variant<uint16_t, uint32_t>;
-
-template <typename T>
-std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
-    os << "[";
-    for (size_t i = 0; i < vec.size(); ++i) {
-        os << vec[i];
-        if (i != vec.size() - 1)
-            os << ", ";
-    }
-    os << "]";
-    return os;
+template <class T> std::string ToString(const std::optional<T> &opt) {
+    return opt ? ToString(*opt) : "nullopt";
 }
 
 template <typename T>
@@ -423,15 +449,6 @@ std::ostream &operator<<(std::ostream &os, const std::optional<T> &opt) {
     return os;
 }
 
-
-template <class T>
-std::string ToString(const std::optional<T>& opt)
-{
-    return opt ? ToString(*opt) : "nullopt";
-}
-
-
-
-
+using DataTypeVariants = std::variant<uint16_t, uint32_t>;
 
 } // namespace aare