feat: implement serialization read_only

src/Core/Serializable.h

@@ -102,6 +102,8 @@ public:
   bool has_default() const { return m_has_default; }
   const T& default_val() const { return m_default; }
 
+  static constexpr bool is_read_only() { return false; }
+
   BOOST_SERIALIZATION_SPLIT_MEMBER()
 
   template <class Archivex>
@@ -115,11 +117,6 @@ public:
   }
 };
 
-template <class T>
-inline hrp<T> make_hrp(const char *name, T &t, const char* units = nullptr) {
-  return hrp<T>(name, t, units);
-}
-
 template <class T>
 class hrp_enum : public boost::serialization::wrapper_traits<hrp_enum<T>> {
   const char *m_name;
@@ -143,6 +140,8 @@ public:
   bool has_default() const { return m_has_default; }
   const T& default_val() const { return m_default; }
 
+  static constexpr bool is_read_only() { return false; }
+
   BOOST_SERIALIZATION_SPLIT_MEMBER()
 
   template <class Archivex>
@@ -156,16 +155,120 @@ public:
   }
 };
 
+template <class T>
+class hrp_val : public boost::serialization::wrapper_traits<hrp_val<T>> {
+  const char *m_name;
+  const char *m_units;
+  T m_value;
+  bool m_has_range;
+  T m_min, m_max;
+  bool m_has_default;
+  T m_default;
+  
+public:
+  explicit hrp_val(const char *name_, T t, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_has_range(false), m_has_default(false) {}
+
+  hrp_val& range(const T& min_val, const T& max_val) { m_min = min_val; m_max = max_val; m_has_range = true; return *this; }
+  hrp_val& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
+
+  const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const T &const_value() const { return this->m_value; }
+
+  bool has_range() const { return m_has_range; }
+  const T& min_val() const { return m_min; }
+  const T& max_val() const { return m_max; }
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return true; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archivex>
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
+  }
+
+  template <class Archivex>
+  void load(Archivex &ar, const unsigned int /* version */) {
+    // Only for output archives
+  }
+};
+
+template <class T>
+class hrp_enum_val : public boost::serialization::wrapper_traits<hrp_enum_val<T>> {
+  const char *m_name;
+  const char *m_units;
+  T m_value;
+  std::vector<std::string> m_labels;
+  bool m_has_default;
+  T m_default;
+
+public:
+  explicit hrp_enum_val(const char *name_, T t, const std::vector<std::string>& labels, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_labels(labels), m_has_default(false) {}
+
+  hrp_enum_val& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
+
+  const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const std::vector<std::string>& labels() const { return m_labels; }
+
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return true; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archivex>
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
+  }
+
+  template <class Archivex>
+  void load(Archivex &ar, const unsigned int /* version */) {
+    // Only for output archives
+  }
+};
+
+template <class T>
+inline hrp<T> make_hrp(const char *name, T &t, const char* units = nullptr) {
+  return hrp<T>(name, t, units);
+}
+
+// Specialization for rvalues (value-based storage)
+template <class T>
+inline hrp_val<T> make_hrp(const char *name, T &&t, const char* units = nullptr) {
+  return hrp_val<T>(name, t, units);
+}
+
 template <class T>
 inline hrp_enum<T> make_hrp_enum(const char *name, T &t, const std::vector<std::string>& labels, const char* units = nullptr) {
   return hrp_enum<T>(name, t, labels, units);
 }
 
+// Specialization for rvalues (value-based storage)
+template <class T>
+inline hrp_enum_val<T> make_hrp_enum(const char *name, T &&t, const std::vector<std::string>& labels, const char* units = nullptr) {
+  return hrp_enum_val<T>(name, t, labels, units);
+}
+
 template <class T>
 inline hrp<T> make_nvp(const char *name, T &t, const char* units) {
   return hrp<T>(name, t, units);
 }
 
+// Specialization for rvalues (value-based storage)
+template <class T>
+inline hrp_val<T> make_nvp(const char *name, T &&t, const char* units) {
+  return hrp_val<T>(name, t, units);
+}
+
 
 
 } // namespace serialization
@@ -206,8 +309,20 @@ namespace uLib {
 #define HRP5(name, data, units, min, max) boost::serialization::make_hrp(name, data, units).range(min, max)
 #define HRP6(name, data, units, default, min, max) boost::serialization::make_hrp(name, data, units).set_default(default).range(min, max)
 
+// LEFT FOR BACKWARD COMPATIBILITY
 #define HRPU(name, units) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name, units)
 
+
+
+
+
+namespace serialization {
+using boost::serialization::make_nvp;
+using boost::serialization::make_hrp;
+using boost::serialization::make_hrp_enum;
+} // serialization
+
+
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////