merge andrea-geo: geometry/material/property system features

Merges all work from andrea-geo branch: - Geant material management classes - Serialization enhancements (read-only, NVP/HRP macros) - Transform/assembly system improvements - VTK puppet/viewport updates (orthographic toggle, voxel rendering) - Property grouping, dynamic properties, NotifyPropertiesUpdated - Object type identification via uLibTypeMacro - New tests (PropertyGrouping, ReadOnly, vtkQViewport, PuppetParenting) - Various gcompose UI fixes Conflict resolved in CMakePresets.json: kept both 'fast' (clang/lld) and 'mutom' (stub) presets. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-04-03 08:47:32 +00:00
parent a53b3051de 6396bdfebf
commit 7f6323403d
103 changed files with 3427 additions and 1200 deletions
--- a/src/Core/Archives.h
+++ b/src/Core/Archives.h
@@ -28,6 +28,8 @@

 #include <boost/archive/detail/basic_pointer_iserializer.hpp>
 #include <boost/archive/detail/basic_pointer_oserializer.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <cstring>
 #include <iostream>

 #include <boost/archive/text_iarchive.hpp>
@@ -59,6 +61,8 @@ class xml_iarchive;
 class xml_oarchive;
 class text_iarchive;
 class text_oarchive;
+class hrt_iarchive;
+class hrt_oarchive;
 class log_archive;

 } // namespace Archive
@@ -150,7 +154,7 @@ public:
  Archive *This() { return static_cast<Archive *>(this); }

  template <class T>
-  const basic_pointer_iserializer *register_type(T * = NULL) {
+  const basic_pointer_iserializer *register_type(T * = nullptr) {
    const basic_pointer_iserializer &bpis = boost::serialization::singleton<
        pointer_iserializer<Archive, T>>::get_const_instance();
    this->This()->register_basic_serializer(bpis.get_basic_serializer());
@@ -161,15 +165,36 @@ public:
    return *this->This();
  }

+  template <class T>
+  Archive &operator>>(const boost::serialization::nvp<T> &t) {
+    this->This()->load_override(t);
+    return *this->This();
+  }
+
+  template <class T>
+  Archive &operator>>(const boost::serialization::hrp<T> &t) {
+    this->This()->load_override(const_cast<boost::serialization::hrp<T> &>(t));
+    return *this->This();
+  }
+
  // the & operator
  template <class T> Archive &operator&(T &t) { return *(this->This()) >> t; }

+  template <class T>
+  Archive &operator&(const boost::serialization::nvp<T> &t) {
+    return *(this->This()) >> t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp<T> &t) {
+    return *(this->This()) >> t;
+  }
+
  // the == operator
  template <class T> Archive &operator==(T &t) { return this->operator&(t); }

  // the != operator for human readable access
  template <class T> Archive &operator!=(T &t) {
-    std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
    return *this->This();
  }
 };
@@ -191,7 +216,7 @@ public:
  Archive *This() { return static_cast<Archive *>(this); }

  template <class T>
-  const basic_pointer_oserializer *register_type(const T * = NULL) {
+  const basic_pointer_oserializer *register_type(const T * = nullptr) {
    const basic_pointer_oserializer &bpos = boost::serialization::singleton<
        pointer_oserializer<Archive, T>>::get_const_instance();
    this->This()->register_basic_serializer(bpos.get_basic_serializer());
@@ -215,7 +240,6 @@ public:

  // the != operator for human readable access
  template <class T> Archive &operator!=(T &t) {
-    std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
    return *this->This();
  }
 };
@@ -240,23 +264,22 @@ template <>
 class interface_oarchive<uLib::Archive::text_oarchive>
    : public uLib_interface_oarchive<uLib::Archive::text_oarchive> {};

+template <>
+class interface_iarchive<uLib::Archive::hrt_iarchive>
+    : public uLib_interface_iarchive<uLib::Archive::hrt_iarchive> {};
+
+template <>
+class interface_oarchive<uLib::Archive::hrt_oarchive>
+    : public uLib_interface_oarchive<uLib::Archive::hrt_oarchive> {};
+
+template <>
+class interface_iarchive<uLib::Archive::log_archive>
+    : public uLib_interface_iarchive<uLib::Archive::log_archive> {};
+
 template <>
 class interface_oarchive<uLib::Archive::log_archive>
    : public uLib_interface_oarchive<uLib::Archive::log_archive> {};

-//// Veritical repetition macro // FINIRE !!!!!!!!!!!!!!!!!!!!!!!!!
-// #define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata)           \
-//     template <class TypeSeq>                             \
-//     struct inherit_nofold<TypeSeq,BOOST_PP_INC(vn)> :    \
-//     BOOST_PP_REPEAT(BOOST_PP_INC(vn),_INERIT_NOFOLD_H,~) \
-//     {};
-
-//// Multiple size declaration //
-// BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)
-
-// #undef  _INERIT_NOFOLD_H
-// #undef  _INERIT_NOFOLD_V
-
 } // namespace detail
 } // namespace archive
 } // namespace boost
@@ -275,36 +298,6 @@ class interface_oarchive<uLib::Archive::log_archive>
 namespace boost {
 namespace archive {

-// template<class Archive>
-// inline void load_const_override(Archive & ar, const char *t ){
-//     typedef typename mpl::identity<detail::load_non_pointer_type<Archive>
-//     >::type typex; typex::invoke(ar, t);
-// }
-
-// template<class Archive, class T>
-// inline void load(Archive & ar, T &t){
-//     // if this assertion trips. It means we're trying to load a
-//     // const object with a compiler that doesn't have correct
-//     // funtion template ordering.  On other compilers, this is
-//     // handled below.
-//     //    detail::check_const_loading< T >();
-//     typedef
-//         BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
-//             mpl::identity<detail::load_pointer_type<Archive> >
-//         ,//else
-//         BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
-//             mpl::identity<detail::load_array_type<Archive> >
-//         ,//else
-//         BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
-//             mpl::identity<detail::load_enum_type<Archive> >
-//         ,//else
-//             mpl::identity<detail::load_non_pointer_type<Archive> >
-//         >
-//         >
-//         >::type typex;
-//     typex::invoke(ar, t);
-// }
-
 } // namespace archive
 } // namespace boost

@@ -312,40 +305,38 @@ namespace uLib {

 namespace Archive {

-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// POLYMORPHIC //
-
-// class polymorphic_iarchive :
-//         public boost::archive::polymorphic_iarchive {
-
-// public:
-//     void load_override(const char *t, BOOST_PFTO int)
-//     {
-//         boost::archive::load_const_override(* this->This(),
-//         const_cast<char*>(t));
-//     }
-
-//};

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // XML //

+// ULIB_SERIALIZATION_VERSION should be get from the build system
+#ifndef ULIB_SERIALIZATION_VERSION
+#define ULIB_SERIALIZATION_VERSION "0.0"
+#endif
+
 class xml_iarchive : public boost::archive::xml_iarchive_impl<xml_iarchive> {
  typedef xml_iarchive Archive;
  typedef boost::archive::xml_iarchive_impl<Archive> base;

+  unsigned int m_flags;
+
  // give serialization implementation access to this class
  friend class boost::archive::detail::interface_iarchive<Archive>;
  friend class boost::archive::basic_xml_iarchive<Archive>;
  friend class boost::archive::load_access;
-
 public:
  xml_iarchive(std::istream &is, unsigned int flags = 0)
-      : xml_iarchive_impl<xml_iarchive>(is, flags) {}
+      : boost::archive::xml_iarchive_impl<xml_iarchive>(
+            is, flags | boost::archive::no_header), m_flags(flags) {
+    if (0 == (flags & boost::archive::no_header)) {
+      std::string line;
+      std::getline(is, line); // <?xml ... ?>
+      std::getline(is, line); // <!DOCTYPE ...>
+      std::getline(is, line); // <ulib_serialization ...>
+    }
+  }

  // Anything not an attribute should be a name value pair as nvp or hrp
  typedef boost::archive::detail::common_iarchive<Archive>
@@ -370,17 +361,13 @@ public:
  using base::load_override;

  void load_override(const char *str) {
-    //        StringReader sr(basic_text_iprimitive::is);
-    //        sr >> str;
+    // StringReader sr(basic_text_iprimitive::is);
+    // sr >> str;
  }

-  ~xml_iarchive() {};
+  virtual ~xml_iarchive() {}
 };

-// typedef boost::archive::detail::polymorphic_iarchive_route<
-// boost::archive::xml_iarchive_impl<xml_iarchive>
-//> polymorphic_xml_iarchive;
-
 template <class ArchiveImpl>
 struct polymorphic_iarchive_route
    : boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl> {
@@ -390,31 +377,39 @@ struct polymorphic_iarchive_route
 class polymorphic_xml_iarchive
    : public polymorphic_iarchive_route<
          boost::archive::xml_iarchive_impl<xml_iarchive>> {
-  // give serialization implementation access to this class
-  //    friend class boost::archive::detail::interface_iarchive<Archive>;
-  //    friend class boost::archive::basic_xml_iarchive<Archive>;
-  //    friend class boost::archive::load_access;
 public:
-  virtual void load_override(const char *str) { ; }
+  virtual void load_override(const char *str) {}
 };

 class xml_oarchive : public boost::archive::xml_oarchive_impl<xml_oarchive> {
  typedef xml_oarchive Archive;
  typedef boost::archive::xml_oarchive_impl<Archive> base;

+  unsigned int m_flags;
+
  // give serialization implementation access to this class
  friend class boost::archive::detail::interface_oarchive<Archive>;
  friend class boost::archive::basic_xml_oarchive<Archive>;
  friend class boost::archive::save_access;
-
 public:
  xml_oarchive(std::ostream &os, unsigned int flags = 0)
-      : boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags) {}
+      : boost::archive::xml_oarchive_impl<xml_oarchive>(
+            os, flags | boost::archive::no_header), m_flags(flags) {
+    if (0 == (flags & boost::archive::no_header)) {
+      this->This()->put(
+          "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
+      this->This()->put("<!DOCTYPE ulib_serialization>\n");
+      this->This()->put("<ulib_serialization signature=\"serialization::archive\" ");
+      this->write_attribute("version", (const char *)ULIB_SERIALIZATION_VERSION);
+      this->This()->put(">\n");
+    }
+  }

-  // example of implementing save_override for const char* //
-  //    void save_override(const char *t, int) {
-  //        std::cout << "found char: " << t << "\n";
-  //    }
+  virtual ~xml_oarchive() {
+    if (0 == (m_flags & boost::archive::no_header)) {
+      this->This()->put("</ulib_serialization>\n");
+    }
+  }

  using basic_xml_oarchive::save_override;

@@ -434,10 +429,8 @@ public:

  void save_override(const char *str) {
    // Do not save any human decoration string //
-    //        basic_text_oprimitive::save(str);
+    // basic_text_oprimitive::save(str);
  }
-
-  ~xml_oarchive() {}
 };

 // typedef boost::archive::detail::polymorphic_oarchive_route<
@@ -472,15 +465,11 @@ public:
    sr >> str;
  }

-  ~text_iarchive() {};
+  virtual ~text_iarchive() {}
 };

 typedef text_iarchive naked_text_iarchive;

-// typedef boost::archive::detail::polymorphic_iarchive_route<
-// naked_text_iarchive
-//> polymorphic_text_iarchive;
-
 class text_oarchive : public boost::archive::text_oarchive_impl<text_oarchive> {
  typedef text_oarchive Archive;
  typedef boost::archive::text_oarchive_impl<Archive> base;
@@ -498,13 +487,9 @@ public:

  void save_override(const char *str) { basic_text_oprimitive::save(str); }

-  ~text_oarchive() {}
+  virtual ~text_oarchive() {}
 };

-// typedef boost::archive::detail::polymorphic_oarchive_route<
-// boost::archive::text_oarchive_impl<text_oarchive>
-//> polymorphic_text_oarchive;
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -541,7 +526,7 @@ public:
    sr >> str;
  }

-  ~hrt_iarchive() {};
+  virtual ~hrt_iarchive() {}
 };

 class hrt_oarchive : public boost::archive::text_oarchive_impl<hrt_oarchive> {
@@ -577,7 +562,7 @@ public:
    *this << "\n";
  }

-  ~hrt_oarchive() {}
+  virtual ~hrt_oarchive() {}
 };

 ////////////////////////////////////////////////////////////////////////////////
@@ -606,17 +591,9 @@ public:
  }

  template <class T> void save_override(const T &t) {
-    base::save_override(boost::serialization::make_nvp(NULL, t));
+    base::save_override(boost::serialization::make_nvp(nullptr, t));
  }

-  // activate this if you want to trap non nvp objects //
-  //    template<class T>
-  //    void save_override(T & t)
-  //    {
-  //        BOOST_MPL_ASSERT((boost::serialization::is_wrapper< T >));
-  //        //        this->detail_common_oarchive::save_override(t);
-  //    }
-
  template <class T> void save_override(const boost::serialization::nvp<T> &t) {
    base::save_override(t);
  }
@@ -641,11 +618,9 @@ public:
  log_archive(std::ostream &os, unsigned int flags = 0)
      : boost::archive::xml_oarchive_impl<log_archive>(
            os, flags | boost::archive::no_header) {}
-};

-// typedef boost::archive::detail::polymorphic_oarchive_route<
-// boost::archive::xml_oarchive_impl<log_archive>
-//> polymorphic_log_archive;
+  virtual ~log_archive() {}
+};

 } // namespace Archive

@@ -659,10 +634,4 @@ ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_iarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_oarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::log_archive)

-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)
-
 #endif // U_CORE_ARCHIVES_H
--- a/src/Core/CMakeLists.txt
+++ b/src/Core/CMakeLists.txt
@@ -58,6 +58,7 @@ if(USE_CUDA)
 endif()

 target_link_libraries(${libname} ${LIBRARIES})
+target_compile_definitions(${libname} PUBLIC ULIB_SERIALIZATION_VERSION="${PROJECT_VERSION}")

 install(TARGETS ${libname}
        EXPORT "uLibTargets"
--- a/src/Core/Debug.h
+++ b/src/Core/Debug.h
@@ -38,6 +38,76 @@
 #include <boost/any.hpp>


+
+/**
+ * @file Debug.h
+ * @brief Unified Debugging and Monitoring System for uLib.
+ *
+ * # Debug System Documentation
+ *
+ * The `Debug` system provides a flexible, adapter-based mechanism for monitoring
+ * and outputting internal variables and states without hardcoding output logic
+ * into core classes. 
+ *
+ * ## Architecture
+ * 
+ * The system follows an adapter pattern:
+ * 
+ * - **`DebugAdapterInterface`**: The base interface for all output targets. 
+ *   Subclasses define how primitive types and strings are handled (e.g., printing 
+ *   to `std::cout`, writing to a log file, or updating a real-time UI widget).
+ *
+ * - **`Debug` Class**: The central registry. It stores:
+ *   1.  A list of "Adapters" (`DebugAdapterInterface`).
+ *   2.  A list of "Items" to monitor. Each item is a reference to a variable 
+ *       associated with a name.
+ *
+ * - **Type Safety**: Although variables are stored using `boost::any` (type erasure), 
+ *   the system automatically preserves the original type information via 
+ *   internal template adapters (`AnyCastAdapter`), ensuring that the correct 
+ *   overload of the adapter interface is called.
+ *
+ * ## Core Components
+ * 
+ * | Component | Description |
+ * | :--- | :--- |
+ * | `Debug` | The main controller used to add adapters and register variables. |
+ * | `DebugAdapterInterface` | Virtual base for creating new output methods. |
+ * | `DebugAdapterText` | A simple built-in adapter for `std::ostream` output. |
+ *
+ * ## How to Use
+ *
+ * ### 1. Initialize the Debug Object
+ * ```cpp
+ * uLib::Debug dbg;
+ * ```
+ *
+ * ### 2. Add an Adapter
+ * ```cpp
+ * uLib::DebugAdapterText console(std::cout);
+ * dbg.AddAdapter(console);
+ * ```
+ *
+ * ### 3. Register Variables to Monitor
+ * Use the `operator()` to bind a variable by reference.
+ * ```cpp
+ * int frameCount = 0;
+ * std::string state = "Initializing";
+ * dbg("Frames", frameCount);
+ * dbg("Status", state);
+ * ```
+ *
+ * ### 4. Update
+ * Call `Update()` periodically (e.g., once per frame) to push the current 
+ * values of all registered variables to all connected adapters.
+ * ```cpp
+ * while(running) {
+ *    frameCount++;
+ *    dbg.Update(); // This triggers the output
+ * }
+ * ```
+ */
+
 namespace uLib {


@@ -107,7 +177,6 @@ public:



-
 class Debug {
    typedef detail::DebugAdapterInterface AdapterInterface;
    typedef SmartPointer<detail::DebugAdapterInterface> Adapter;
--- a/src/Core/Object.cpp
+++ b/src/Core/Object.cpp
@@ -79,6 +79,7 @@ void Object::RegisterDynamicProperty(PropertyBase* prop) {
    if (prop) {
        for (auto* existing : d->m_DynamicProperties) {
            if (existing == prop) return;
+            if (existing->GetQualifiedName() == prop->GetQualifiedName()) return;
        }
        d->m_DynamicProperties.push_back(prop);
    }
@@ -90,14 +91,19 @@ const std::vector<PropertyBase*>& Object::GetProperties() const {

 PropertyBase* Object::GetProperty(const std::string& name) const {
    for (auto* p : d->m_Properties) {
-        if (p->GetName() == name) return p;
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
    }
    for (auto* p : d->m_DynamicProperties) {
-        if (p->GetName() == name) return p;
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
    }
    return nullptr;
 }

+void Object::NotifyPropertiesUpdated() {
+    for (auto* p : d->m_Properties) p->Updated();
+    for (auto* p : d->m_DynamicProperties) p->Updated();
+}
+
 // In Object.h, the template serialize needs to be updated to call property serialization.
 // However, since Object::serialize is a template in the header, we might need a helper here.

@@ -110,6 +116,7 @@ void Object::serialize(ArchiveT &ar, const unsigned int version) {
 }

 void Object::Updated() { ULIB_SIGNAL_EMIT(Object::Updated); }
+void Object::PropertyUpdated() { ULIB_SIGNAL_EMIT(Object::PropertyUpdated); }

 template <class ArchiveT>
 void Object::save_override(ArchiveT &ar, const unsigned int version) {}
--- a/src/Core/Object.h
+++ b/src/Core/Object.h
@@ -52,6 +52,7 @@ class polymorphic_oarchive;
 namespace uLib {

 class PropertyBase;
+class ObjectsContext;

 class Version {
 public:
@@ -77,7 +78,8 @@ public:
  Object(const Object &copy);
  virtual ~Object();

-  virtual const char * GetClassName() const { return "Object"; }
+  virtual const char * GetClassName() const { return type_name(); }
+  virtual const char * type_name() const { return "Object"; }

  const std::string& GetInstanceName() const;
  void SetInstanceName(const std::string& name);
@@ -95,12 +97,18 @@ public:
  const std::vector<PropertyBase*>& GetProperties() const;
  PropertyBase* GetProperty(const std::string& name) const;

+  /** @brief Sends an Updated signal for all properties of this object. useful for real-time UI refresh. */
+  void NotifyPropertiesUpdated();
+
  ////////////////////////////////////////////////////////////////////////////
  // PARAMETERS //

  // FIXX !!!
  virtual void DeepCopy(const Object &copy);

+  /** @brief Returns a nested context for children objects, if any. */
+  virtual ObjectsContext* GetChildren() { return nullptr; }
+
  ////////////////////////////////////////////////////////////////////////////
  // SERIALIZATION //

@@ -129,6 +137,7 @@ public:

  signals:
  virtual void Updated();
+  virtual void PropertyUpdated();

  // Qt4 style connector //
  static bool connect(const Object *ob1, const char *signal_name,
--- a/src/Core/ObjectsContext.h
+++ b/src/Core/ObjectsContext.h
@@ -9,12 +9,13 @@ namespace uLib {
 /**
 * @brief ObjectsContext represents a collection of Object instances.
 */
-class ObjectsContext : public Object {
+class ObjectsContext : virtual public Object {
 public:
    ObjectsContext();
    virtual ~ObjectsContext();

-    virtual const char * GetClassName() const { return "ObjectsContext"; }
+    uLibTypeMacro(ObjectsContext, Object)
+    virtual ObjectsContext* GetChildren() override { return this; }

    /**
     * @brief Adds an object to the context.
--- a/src/Core/Property.h
+++ b/src/Core/Property.h
@@ -2,11 +2,16 @@
 #define U_CORE_PROPERTY_H

 #include <string>
+#include <vector>
 #include <sstream>
 #include <typeinfo>
 #include <typeindex> // Added
 #include <boost/serialization/nvp.hpp>
 #include <boost/lexical_cast.hpp>
+#include <vector>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/serialization/serialization.hpp>
 #include "Core/Archives.h"
 #include "Core/Signal.h"
 #include "Core/Object.h"
@@ -29,21 +34,42 @@ public:
      static std::vector<std::string> empty;
      return empty;
  }
+  virtual const std::string& GetGroup() const = 0;
+  virtual void SetGroup(const std::string& group) = 0;
+
+  virtual bool HasRange() const { return false; }
+  virtual double GetMin() const { return 0; }
+  virtual double GetMax() const { return 0; }
+  virtual bool HasDefault() const { return false; }
+  virtual std::string GetDefaultValueAsString() const { return ""; }
+  virtual bool IsReadOnly() const = 0;
+
+  std::string GetQualifiedName() const {
+      if (GetGroup().empty()) return GetName();
+      return GetGroup() + "." + GetName();
+  }

  // Signal support
  signals:
  virtual void Updated() override { ULIB_SIGNAL_EMIT(PropertyBase::Updated); }

  // Serialization support for different uLib archives
-  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::log_archive & ar, const unsigned int version) = 0;
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::log_archive & ar, const unsigned int version) override = 0;
 };

+
+
+
+
+
+
+
 /**
 * @brief Template class for typed properties.
 */
@@ -51,16 +77,18 @@ template <typename T>
 class Property : public PropertyBase {
 public:
  // PROXY: Use an existing variable as back-end storage
-  Property(Object* owner, const std::string& name, T* valuePtr, const std::string& units = "")
-    : m_owner(owner), m_name(name), m_units(units), m_value(valuePtr), m_own(false) {
+  Property(Object* owner, const std::string& name, T* valuePtr, const std::string& units = "", const std::string& group = "")
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(valuePtr), m_own(false),
+      m_HasRange(false), m_HasDefault(false), m_ReadOnly(false) {
      if (m_owner) {
          m_owner->RegisterProperty(this);
      }
  }

  // MANAGED: Create and own internal storage
-  Property(Object* owner, const std::string& name, const T& defaultValue = T(), const std::string& units = "")
-    : m_owner(owner), m_name(name), m_units(units), m_value(new T(defaultValue)), m_own(true) {
+  Property(Object* owner, const std::string& name, const T& defaultValue = T(), const std::string& units = "", const std::string& group = "")
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(new T(defaultValue)), m_own(true),
+      m_HasRange(false), m_HasDefault(true), m_Default(defaultValue), m_ReadOnly(false) {
      if (m_owner) {
          m_owner->RegisterProperty(this);
      }
@@ -76,6 +104,8 @@ public:
  virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(T)); }
  virtual const std::string& GetUnits() const override { return m_units; }
  virtual void SetUnits(const std::string& units) override { m_units = units; }
+  virtual const std::string& GetGroup() const override { return m_group; }
+  virtual void SetGroup(const std::string& group) override { m_group = group; }

  
  std::string GetValueAsString() const override {
@@ -90,15 +120,64 @@ public:

  // Accessors
  const T& Get() const { return *m_value; }
+  template<typename U = T>
+  typename std::enable_if<std::is_arithmetic<U>::value, void>::type
+  ValidateT(T& val) {
+    if (m_HasRange) {
+        if (val < m_Min) val = m_Min;
+        if (val > m_Max) val = m_Max;
+    }
+  }
+
+  template<typename U = T>
+  typename std::enable_if<!std::is_arithmetic<U>::value, void>::type
+  ValidateT(T& val) {
+  }
+
  void Set(const T& value) {
-    if (*m_value != value) {
-      *m_value = value;
+    T val = value;
+    ValidateT<T>(val);
+    if (*m_value != val) {
+      *m_value = val;
      ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged);
      this->Updated();
      if (m_owner) m_owner->Updated();
    }
  }

+  void SetRange(const T& min, const T& max) { m_Min = min; m_Max = max; m_HasRange = true; }
+  void SetDefault(const T& def) { m_Default = def; m_HasDefault = true; }
+  void SetReadOnly(bool ro) { m_ReadOnly = ro; }
+
+  virtual bool IsReadOnly() const override { return m_ReadOnly; }
+
+  virtual bool HasRange() const override { return m_HasRange; }
+
+  template<typename U = T>
+  typename std::enable_if<std::is_arithmetic<U>::value, double>::type
+  GetMinT() const { return (double)m_Min; }
+
+  template<typename U = T>
+  typename std::enable_if<!std::is_arithmetic<U>::value, double>::type
+  GetMinT() const { return 0.0; }
+
+  template<typename U = T>
+  typename std::enable_if<std::is_arithmetic<U>::value, double>::type
+  GetMaxT() const { return (double)m_Max; }
+
+  template<typename U = T>
+  typename std::enable_if<!std::is_arithmetic<U>::value, double>::type
+  GetMaxT() const { return 0.0; }
+
+  virtual double GetMin() const override { return GetMinT<T>(); }
+  virtual double GetMax() const override { return GetMaxT<T>(); }
+
+  virtual bool HasDefault() const override { return m_HasDefault; }
+  virtual std::string GetDefaultValueAsString() const override {
+      try { return boost::lexical_cast<std::string>(m_Default); } 
+      catch (...) { return ""; }
+  }
+
  // Operators for seamless usage
  operator const T&() const { return *m_value; }
  Property& operator=(const T& value) {
@@ -124,12 +203,24 @@ public:
  void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
  void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_impl(ar, v); }

+  virtual void Updated() override {
+      PropertyBase::Updated();
+      this->PropertyChanged();
+  }
+
 private:
  std::string m_name;
  std::string m_units;
+  std::string m_group;
  T* m_value;
  bool m_own;
  Object* m_owner;
+  bool m_HasRange;
+  T m_Min;
+  T m_Max;
+  bool m_HasDefault;
+  T m_Default;
+  bool m_ReadOnly;
 };

 /**
@@ -142,15 +233,16 @@ typedef Property<long>          LongProperty;
 typedef Property<unsigned long> ULongProperty;
 typedef Property<float>         FloatProperty;
 typedef Property<double>        DoubleProperty;
-typedef Property<Bool_t>      BoolProperty;
+typedef Property<Bool_t>        BoolProperty;
+

 /**
 * @brief Property specialized for enumerations, providing labels for GUI representations.
 */
 class EnumProperty : public Property<int> {
 public:
-  EnumProperty(Object* owner, const std::string& name, int* valuePtr, const std::vector<std::string>& labels, const std::string& units = "")
-    : Property<int>(owner, name, valuePtr, units), m_Labels(labels) {}
+  EnumProperty(Object* owner, const std::string& name, int* valuePtr, const std::vector<std::string>& labels, const std::string& units = "", const std::string& group = "")
+    : Property<int>(owner, name, valuePtr, units, group), m_Labels(labels) {}

  const std::vector<std::string>& GetEnumLabels() const override { return m_Labels; }
  const char* GetTypeName() const override { return "Enum"; }
@@ -160,6 +252,16 @@ private:
  std::vector<std::string> m_Labels;
 };

+
+
+
+
+
+
+
+
+
+
 /**
 * @brief Macro to simplify property declaration within a class.
 * Usage: ULIB_PROPERTY(float, Width, 1.0f)
@@ -209,11 +311,41 @@ public:
        boost::archive::detail::common_oarchive<property_register_archive>(boost::archive::no_header),
        m_Object(obj) {}
    
+    std::string GetCurrentGroup() const {
+        std::string group;
+        for (const auto& g : m_GroupStack) {
+            if (!group.empty()) group += ".";
+            group += g;
+        }
+        return group;
+    }
+
    // Core logic: encounter HRP -> Create Dynamic Property
    template<class T>
    void save_override(const boost::serialization::hrp<T> &t) {
        if (m_Object) {
-            Property<T>* p = new Property<T>(m_Object, t.name(), &const_cast<boost::serialization::hrp<T>&>(t).value(), t.units() ? t.units() : "");
+            Property<T>* p = new Property<T>(m_Object, t.name(), &const_cast<boost::serialization::hrp<T>&>(t).value(), t.units() ? t.units() : "", GetCurrentGroup());
+            if (t.has_range()) p->SetRange(t.min_val(), t.max_val());
+            if (t.has_default()) p->SetDefault(t.default_val());
+            p->SetReadOnly(t.is_read_only());
+            m_Object->RegisterDynamicProperty(p);
+        }
+    }
+
+    template<class T>
+    void save_override(const boost::serialization::hrp_val<T> &t) {
+        if (m_Object) {
+            // Note: hrp_val stores by value. Property usually points to existing data.
+            // But here we are registering properties from HRP wrappers.
+            // If it's hrp_val, it means it's an rvalue from a getter. 
+            // The hrp_val wrapper itself owns the value.
+            // However, the property_register_archive is temporary.
+            // This is a bit tricky. Usually HRP(rvalue) is meant for read-only display.
+            // Let's use the address of the value in the wrapper, but mark it read-only.
+            Property<T>* p = new Property<T>(m_Object, t.name(), &const_cast<boost::serialization::hrp_val<T>&>(t).value(), t.units() ? t.units() : "", GetCurrentGroup());
+            if (t.has_range()) p->SetRange(t.min_val(), t.max_val());
+            if (t.has_default()) p->SetDefault(t.default_val());
+            p->SetReadOnly(t.is_read_only());
            m_Object->RegisterDynamicProperty(p);
        }
    }
@@ -221,7 +353,17 @@ public:
    template<class T>
    void save_override(const boost::serialization::hrp_enum<T> &t) {
        if (m_Object) {
-            EnumProperty* p = new EnumProperty(m_Object, t.name(), (int*)&const_cast<boost::serialization::hrp_enum<T>&>(t).value(), t.labels(), t.units() ? t.units() : "");
+            EnumProperty* p = new EnumProperty(m_Object, t.name(), (int*)&const_cast<boost::serialization::hrp_enum<T>&>(t).value(), t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
+            p->SetReadOnly(t.is_read_only());
+            m_Object->RegisterDynamicProperty(p);
+        }
+    }
+
+    template<class T>
+    void save_override(const boost::serialization::hrp_enum_val<T> &t) {
+        if (m_Object) {
+            EnumProperty* p = new EnumProperty(m_Object, t.name(), (int*)&const_cast<boost::serialization::hrp_enum_val<T>&>(t).value(), t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
+            p->SetReadOnly(t.is_read_only());
            m_Object->RegisterDynamicProperty(p);
        }
    }
@@ -229,11 +371,24 @@ public:
    // Handle standard NVPs by recursing (important for base classes)
    template<class T>
    void save_override(const boost::serialization::nvp<T> &t) {
-        boost::archive::detail::common_oarchive<property_register_archive>::save_override(t.const_value());
+        if (t.name()) m_GroupStack.push_back(t.name());
+        this->save_helper(t.const_value(), typename boost::is_class<T>::type());
+        if (t.name()) m_GroupStack.pop_back();
    }

-    // Ignore everything else
-    template<class T> void save_override(const T &t) {}
+    // Recursion for nested classes, ignore primitives
+    template<class T>
+    void save_override(const T &t) {
+        this->save_helper(t, typename boost::is_class<T>::type());
+    }
+
+    template<class T>
+    void save_helper(const T &t, boost::mpl::true_) {
+        boost::serialization::serialize_adl(*this, const_cast<T&>(t), 0);
+    }
+
+    template<class T>
+    void save_helper(const T &t, boost::mpl::false_) {}

    // Required attribute overrides for common_oarchive
    void save_override(const boost::archive::object_id_type & t) {}
@@ -244,14 +399,39 @@ public:
    void save_override(const boost::archive::class_id_reference_type & t) {}
    void save_override(const boost::archive::class_name_type & t) {}
    void save_override(const boost::archive::tracking_type & t) {}
+
+private:
+    std::vector<std::string> m_GroupStack;
 };

+
+
 /**
- * @brief Convenience macro to automatically activate and register all HRP members 
+ * @brief Convenience macro to automatically activate and register all HRP members
 * as uLib properties. Usage: ULIB_ACTIVATE_PROPERTIES(obj)
 */
 #define ULIB_ACTIVATE_PROPERTIES(obj) \
-    { uLib::Archive::property_register_archive _ar_tmp(&(obj)); (obj).serialize(_ar_tmp, 0); }
+    { uLib::Archive::property_register_archive _ar_tmp(&(obj)); _ar_tmp & (obj); }
+
+/**
+ * @brief Declares a private member that automatically calls ULIB_ACTIVATE_PROPERTIES
+ * in every constructor of the class. Place this macro as the last declaration
+ * inside the class body (before the closing brace).
+ *
+ * Usage: ULIB_DECLARE_PROPERTIES(ClassName)
+ *
+ * This replaces per-constructor ULIB_ACTIVATE_PROPERTIES(*this) calls.
+ * RegisterDynamicProperty deduplicates by qualified name, so re-registration
+ * from inherited activators in a hierarchy is safe.
+ */
+#define ULIB_DECLARE_PROPERTIES(SelfType) \
+private: \
+    struct _PropActivator { \
+        _PropActivator(SelfType* self) { \
+            uLib::Archive::property_register_archive _ar(self); \
+            _ar & *self; \
+        } \
+    } _prop_activator{this};

 } // namespace Archive
 } // namespace uLib
--- a/src/Core/Serializable.h
+++ b/src/Core/Serializable.h
@@ -71,21 +71,39 @@ namespace serialization {
 // ACCESS 2 //
 template <class T> struct access2 {};

-// NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------
 template <class T>
 class hrp : public boost::serialization::wrapper_traits<hrp<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(const char *name_, T &t, const char* units_ = nullptr) : m_name(name_), m_units(units_), m_value(t) {}
+  explicit hrp(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& range(const T& min_val, const T& max_val) { m_min = min_val; m_max = max_val; m_has_range = true; return *this; }
+  hrp& 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 false; }
+
  BOOST_SERIALIZATION_SPLIT_MEMBER()

  template <class Archivex>
@@ -99,47 +117,159 @@ public:
  }
 };

+template <class T>
+class hrp_enum : public boost::serialization::wrapper_traits<hrp_enum<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(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& 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 false; }
+
+  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 */) {
+    ar >> boost::serialization::make_nvp(m_name, m_value);
+  }
+};
+
+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>
-class hrp_enum : public boost::serialization::wrapper_traits<hrp_enum<T>> {
-  const char *m_name;
-  const char *m_units;
-  T &m_value;
-  std::vector<std::string> m_labels;
-
-public:
-  explicit hrp_enum(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) {}
-
-  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; }
-
-  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 */) {
-    ar >> boost::serialization::make_nvp(m_name, m_value);
-  }
-};
+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);
 }

-#define HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
-#define HRPU(name, units) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name, 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
 } // namespace boost
@@ -159,7 +289,41 @@ namespace uLib {

 #define _AR_OP(r, data, elem) data &BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);

-#define NVP(data) BOOST_SERIALIZATION_NVP(data)
+// NAME VALUE PAIR //
+#define NVP_GET_MACRO(_1, _2, _3, NAME, ...) NAME
+#define NVP(...) NVP_GET_MACRO(__VA_ARGS__, NVP3, NVP2, NVP1)(__VA_ARGS__)
+
+#define NVP1(data) BOOST_SERIALIZATION_NVP(data)
+#define NVP2(name, data) boost::serialization::make_nvp(name, data)
+#define NVP3(name, data, units) boost::serialization::make_nvp(name, data, units)
+
+
+// HUMAN READABLE PROPERTY //
+#define HRP_GET_MACRO(_1, _2, _3, _4, _5, _6, NAME, ...) NAME
+#define HRP(...) HRP_GET_MACRO(__VA_ARGS__, HRP6, HRP5, HRP4, HRP3, HRP2, HRP1)(__VA_ARGS__)
+
+#define HRP1(data) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(data), data)
+#define HRP2(name, data) boost::serialization::make_hrp(name, data)
+#define HRP3(name, data, units) boost::serialization::make_hrp(name, data, units)
+#define HRP4(name, data, units, default) boost::serialization::make_hrp(name, data, units).set_default(default)
+#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)
+
+#define HRPE(name, data, labels) boost::serialization::make_hrp_enum(name, data, labels)
+
+// 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
+

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -187,7 +351,7 @@ namespace uLib {
 #define ULIB_SERIALIZE_OBJECT(_Ob, ...)                                        \
  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
 #define AR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
-#define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
+#define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_HR_(_name)
 #endif

 #define ULIB_SERIALIZE_ACCESS                                                  \
@@ -200,14 +364,14 @@ namespace uLib {
 #define ULIB_CLASS_EXPORT_OBJECT_KEY(_FullNamespaceClass)                      \
  BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)

-#define _SERIALIZE_IMPL_SEQ                                                                   \
-  (uLib::Archive::text_iarchive)(uLib::Archive::text_oarchive)(                               \
-      uLib::Archive::                                                                         \
-          hrt_iarchive)(uLib::Archive::                                                       \
-                            hrt_oarchive)(uLib::Archive::                                     \
-                                              xml_iarchive)(uLib::Archive::                   \
-                                                                xml_oarchive)(uLib::Archive:: \
-                                                                                  log_archive)
+#define _SERIALIZE_IMPL_SEQ  \
+  (uLib::Archive::text_iarchive) \
+  (uLib::Archive::text_oarchive) \
+  (uLib::Archive::hrt_iarchive)  \
+  (uLib::Archive::hrt_oarchive)  \
+  (uLib::Archive::xml_iarchive)  \
+  (uLib::Archive::xml_oarchive)  \
+  (uLib::Archive::log_archive)

 /** Solving virtual class check problem */
 #define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base, _Derived)               \
@@ -278,6 +442,11 @@ namespace uLib {
  template <class ArchiveT>                                                    \
  void _Ob::save_override(ArchiveT &ar, const unsigned int version)

+
+
+
+
+  
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -382,7 +551,8 @@ namespace uLib {
  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {        \
    /* PP  serialize */ BOOST_PP_SEQ_FOR_EACH(                                 \
        _UNAR_OP, ob, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));                   \
-  /* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>(uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ }                                                          \
+  /* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>                     \
+  (uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ }\
  template <class ArchiveT>                                                    \
  inline void load_construct_data(ArchiveT &ar, _Ob *ob,                       \
                                  const unsigned int file_version) {           \
@@ -405,10 +575,18 @@ namespace uLib {
                        _SERIALIZE_IMPL_SEQ)                                   \
  template <class ArchiveT>                                                    \
  void boost::serialization::access2<_Ob>::save_override(                      \
-      ArchiveT &ar, _Ob &ob, const unsigned int version)
+      ArchiveT &ar, _Ob &ob, const unsigned int version) 

+    
 #define _ULIB_DETAIL_UNINTRUSIVE_AR_(name)                                     \
  boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), ob.name)
+#define _ULIB_DETAIL_UNINTRUSIVE_HR_(name)                                     \
+  boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), ob.name)
+
+
+
+
+

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
--- a/src/Core/Signal.h
+++ b/src/Core/Signal.h
@@ -95,6 +95,8 @@ namespace uLib {

 typedef boost::signals2::signal_base SignalBase;
 typedef boost::signals2::connection Connection;
+typedef boost::signals2::shared_connection_block ConnectionBlock;
+

 template <typename T> struct Signal {
  typedef boost::signals2::signal<T> type;
--- a/src/Core/testing/CMakeLists.txt
+++ b/src/Core/testing/CMakeLists.txt
@@ -23,11 +23,13 @@ set( TESTS
        VectorMetaAllocatorTest
        PropertyTypesTest
        HRPTest
+        PropertyGroupingTest
        MutexTest
        ThreadsTest
        OpenMPTest
        TeamTest
        AffinityTest
+        ReadOnlyPropertyTest
 )

 set(LIBRARIES
--- a/src/Core/testing/PropertiesTest.cpp
+++ b/src/Core/testing/PropertiesTest.cpp
@@ -23,74 +23,138 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
-
 #include <iostream>
-
-#include <boost/signals2/signal.hpp>
-
+#include <fstream>
+#include <string>

 #include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Archives.h"
+#include "Core/Serializable.h"
 #include "testing-prototype.h"

-#define emit
-
-
-
-
-template <typename T, bool copyable = true>
-class property
-{
-    typedef boost::signals2::signal<void(const property<T>& )> signal_t;
+using namespace uLib;

+/**
+ * @brief A test class to demonstrate property registration via SERIALIZE_OBJECT.
+ */
+class TestObject : public Object {
 public:
-    property() : m_changed(new signal_t) {}
-    property(const T in) : value(in) , m_changed(new signal_t) {}
+    uLibTypeMacro(TestObject, Object)

-    inline operator T const & () const { return value; }
-    inline operator T & () { return value; }
-    inline T & operator = (const T &i) { value = i; return value; }
-    template <typename T2> T2 & operator = (const T2 &i) { T2 &guard = value; }    // Assign exact identical types only.
-    inline signal_t & valueChanged() { return *m_changed; }
+    TestObject() : m_Value(10.5f), m_Status("Initialized"), m_Counter(0) {}
+
+    float m_Value;
+    std::string m_Status;
+    int m_Counter;
+
+    // Static properties (registered in constructor/initializer)
+    ULIB_PROPERTY(int, StaticProp, 42)
+
+    ULIB_SERIALIZE_ACCESS
+
+    template <typename Ar>
+    void serialize(Ar& ar, unsigned int version) {
+        ar & HRP("value", m_Value, "mm").range(0, 100).set_default(1.);
+        ar & HRP("status", m_Status);
+        ar & HRP("counter", m_Counter);
+    }

-private:
-    T value;
-    boost::shared_ptr<signal_t> m_changed;
 };


-//template <typename T>
-//class property <T,false> {
-//    typedef boost::signals2::signal<void( T )> signal_t;
+class TestObject2 : public TestObject {
+public:
+    uLibTypeMacro(TestObject2, TestObject)

-//public:
-//    property() : m_changed() {}
-//    property(const T in) : value(in) , m_changed() {}
+    TestObject2() : TestObject(), m_Value2(20.5f) {}

-//    inline operator T const & () const { return value; }
-//    inline operator T & () { valueChanged()(value); return value; }
-//    inline T & operator = (const T &i) { value = i; valueChanged()(value); return value; }
-//    template <typename T2> T2 & operator = (const T2 &i) { T2 &guard = value; }     // Assign exact identical types only.
-//    inline signal_t &valueChanged() { return m_changed; }
-
-//private:
-//    property(const property<T> &);
-//    property<T> &operator = (const property<T>&);
-
-//    T value;
-//    signal_t m_changed;
-//};
-
-// test generic void function slot //
-void PrintSlot(const property<int> &i) { std::cout << "slot called, new value = " << i << "!\n"; }
-
-
-
-
-
-int main()
-{    
+    float m_Value2;

+    ULIB_SERIALIZE_ACCESS
+};

+ULIB_SERIALIZABLE_OBJECT(TestObject2)
+ULIB_SERIALIZE_OBJECT(TestObject2, TestObject) { 
+    std::cout << "Serializing TestObject2" << std::endl;
+    // ar & boost::serialization::make_hrp("value2", ob.m_Value2, "mm").set_default(1.);
+    ar & HRP("value2", ob.m_Value2, "mm").set_default(1.);
+}
+
+
+int main() {
+    BEGIN_TESTING(Properties Serialization)
+
+    TestObject obj;
+    
+    // 1. Initial state: check static property
+    ASSERT_EQUAL(obj.StaticProp, 42);
+    
+    // 2. Activate dynamic properties via the property_register_archive
+    // This calls the serialize method with a special archive that populates m_DynamicProperties
+    ULIB_ACTIVATE_PROPERTIES(obj);
+    
+    const auto& props = obj.GetProperties();
+    // This is problematic because GetProperties currently returns d->m_Properties (only static) 
+    
+    // For now, let's just assert on the dynamic property presence if possible
+    PropertyBase* pVal = obj.GetProperty("value");
+    ASSERT_NOT_NULL(pVal);
+    ASSERT_EQUAL(pVal->GetValueAsString(), "10.5");
+    ASSERT_EQUAL(pVal->GetUnits(), "mm");
+
+    // Check other dynamic properties
+    ASSERT_NOT_NULL(obj.GetProperty("status"));
+    ASSERT_NOT_NULL(obj.GetProperty("counter"));
+
+    // 4. Serialization round-trip (XML)
+    {
+        std::ofstream ofs("test_props.xml");
+        Archive::xml_oarchive(ofs) << NVP("test_obj", obj);
+    }
+
+    TestObject obj2;
+    obj2.m_Value = 0;
+    obj2.m_Status = "";
+    {
+        std::ifstream ifs("test_props.xml");
+        Archive::xml_iarchive(ifs) >> NVP("test_obj", obj2);
+    }
+
+    ASSERT_EQUAL(obj2.m_Value, 10.5f);
+    ASSERT_EQUAL(obj2.m_Status, "Initialized");
+
+    TestObject2 obj3;
+    obj3.m_Value = 12.5;
+    obj3.m_Status = "Initialized";
+    obj3.m_Value2 = 22.5;
+
+    ULIB_ACTIVATE_PROPERTIES(obj3);
+
+    PropertyBase* pVal3 = obj3.GetProperty("value2");
+    ASSERT_NOT_NULL(pVal3);
+    ASSERT_EQUAL(pVal3->GetValueAsString(), "22.5");
+    ASSERT_EQUAL(pVal3->GetUnits(), "mm");
+
+    // 5. Serialization round-trip (XML)
+    {   
+        std::ofstream ofs("test_props2.xml");
+        Archive::xml_oarchive(ofs) << NVP("test_obj2", obj3);
+    }
+
+    TestObject2 obj4;
+    obj4.m_Value = 0;
+    obj4.m_Status = "";
+    obj4.m_Value2 = 0;
+    ULIB_ACTIVATE_PROPERTIES(obj4);
+    {   
+        std::ifstream ifs("test_props2.xml");
+        Archive::xml_iarchive(ifs) >> NVP("test_obj2", obj4);
+    }
+    ASSERT_EQUAL(obj4.m_Value, 12.5f);
+    ASSERT_EQUAL(obj4.m_Status, "Initialized");
+    ASSERT_EQUAL(obj4.m_Value2, 22.5f);
+
+
+    END_TESTING
 }
--- a/src/Core/testing/PropertyGroupingTest.cpp
+++ b/src/Core/testing/PropertyGroupingTest.cpp
@@ -0,0 +1,78 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cassert>
+#include "Core/Object.h"
+#include "Core/Property.h"
+
+using namespace uLib;
+
+struct Nested {
+    float x = 1.0f;
+    float y = 2.0f;
+
+    ULIB_SERIALIZE_ACCESS
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & HRP(x);
+        ar & HRP(y);
+    }
+};
+
+class GroupObject : public Object {
+    uLibTypeMacro(GroupObject, Object)
+public:
+    Nested position;
+    Nested orientation;
+    float weight = 50.0f;
+
+    ULIB_SERIALIZE_ACCESS
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & boost::serialization::make_nvp("Position", position);
+        ar & boost::serialization::make_nvp("Orientation", orientation);
+        ar & HRP(weight);
+    }
+};
+
+int main() {
+    std::cout << "Testing Property Grouping..." << std::endl;
+
+    GroupObject obj;
+    ULIB_ACTIVATE_PROPERTIES(obj);
+
+    auto props = obj.GetProperties();
+    std::cout << "Registered " << props.size() << " properties." << std::endl;
+
+    for (auto* p : props) {
+        std::cout << "Prop: " << p->GetName() 
+                  << " Group: " << p->GetGroup() 
+                  << " Qualified: " << p->GetQualifiedName() << std::endl;
+    }
+
+    // Check if nested properties are registered
+    PropertyBase* p1 = obj.GetProperty("Position.x");
+    PropertyBase* p2 = obj.GetProperty("Position.y");
+    PropertyBase* p3 = obj.GetProperty("Orientation.x");
+    PropertyBase* p4 = obj.GetProperty("Orientation.y");
+    PropertyBase* p5 = obj.GetProperty("weight");
+
+    assert(p1 != nullptr && "Position.x not found");
+    assert(p2 != nullptr && "Position.y not found");
+    assert(p3 != nullptr && "Orientation.x not found");
+    assert(p4 != nullptr && "Orientation.y not found");
+    assert(p5 != nullptr && "weight not found");
+
+    assert(p1->GetGroup() == "Position");
+    assert(p2->GetGroup() == "Position");
+    assert(p3->GetGroup() == "Orientation");
+    assert(p4->GetGroup() == "Orientation");
+    assert(p5->GetGroup() == "");
+
+    assert(p1->GetQualifiedName() == "Position.x");
+    assert(p5->GetQualifiedName() == "weight");
+
+    std::cout << "Property Grouping Tests PASSED!" << std::endl;
+
+    return 0;
+}
--- a/src/Core/testing/PropertySystemTest.cpp
+++ b/src/Core/testing/PropertySystemTest.cpp
@@ -8,13 +8,12 @@ using namespace uLib;

 class TestObject : public Object {
 public:
+  uLibTypeMacro(TestObject, Object)
  TestObject() : Object(), 
    IntProp(this, "IntProp", 10),
    StringProp(this, "StringProp", "Initial") 
  {}

-  virtual const char* GetClassName() const override { return "TestObject"; }
-
  Property<int> IntProp;
  Property<std::string> StringProp;
 };
--- a/src/Core/testing/PropertyTypesTest.cpp
+++ b/src/Core/testing/PropertyTypesTest.cpp
@@ -9,10 +9,9 @@ using namespace uLib;

 class TestObject : public Object {
 public:
+  uLibTypeMacro(TestObject, Object)
  TestObject() : Object() {}

-  virtual const char* GetClassName() const override { return "TestObject"; }
-
  // Use new typedefs
  StringProperty  StringProp = StringProperty(this, "StringProp", "Initial");
  IntProperty     IntProp    = IntProperty(this, "IntProp", 42);
--- a/src/Core/testing/ReadOnlyPropertyTest.cpp
+++ b/src/Core/testing/ReadOnlyPropertyTest.cpp
@@ -0,0 +1,82 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cassert>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Serializable.h"
+
+#include "Core/Serializable.h"
+
+using namespace uLib;
+
+class ReadOnlyTestObject : public Object {
+public:
+    int m_value;
+    int getValue() const { return m_value; }
+    
+    enum State { State1, State2 };
+    State m_state;
+    State getState() const { return m_state; }
+
+    ReadOnlyTestObject() : m_value(10), m_state(State1) {
+        ULIB_ACTIVATE_PROPERTIES(*this);
+    }
+
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        // Lvalue reference - should be NOT read-only
+        ar & HRP("lvalue_prop", m_value);
+        
+        // Rvalue from getter - should be read-only
+        ar & HRP("rvalue_prop", getValue());
+        
+        // Enum lvalue - should be NOT read-only
+        ar & boost::serialization::make_hrp_enum("lvalue_enum", (int&)m_state, {"State1", "State2"});
+        
+        // Enum rvalue - should be read-only
+        ar & boost::serialization::make_hrp_enum("rvalue_enum", (int)getState(), {"State1", "State2"});
+    }
+};
+
+int main() {
+    std::cout << "Testing Read-Only Property Feature..." << std::endl;
+    
+    ReadOnlyTestObject obj;
+    const auto& props = obj.GetProperties();
+    
+    std::cout << "Registered Properties in ReadOnlyTestObject:" << std::endl;
+    bool found_lvalue = false;
+    bool found_rvalue = false;
+    bool found_lvalue_enum = false;
+    bool found_rvalue_enum = false;
+
+    for (auto* p : props) {
+        bool ro = p->IsReadOnly();
+        std::cout << "  - Name: " << p->GetName() 
+                  << " | Type: " << p->GetTypeName() 
+                  << " | ReadOnly: " << (ro ? "YES" : "NO") << std::endl;
+        
+        if (p->GetName() == "lvalue_prop") {
+            if (ro) { std::cerr << "FAIL: lvalue_prop should NOT be read-only" << std::endl; return 1; }
+            found_lvalue = true;
+        } else if (p->GetName() == "rvalue_prop") {
+            if (!ro) { std::cerr << "FAIL: rvalue_prop SHOULD be read-only" << std::endl; return 1; }
+            found_rvalue = true;
+        } else if (p->GetName() == "lvalue_enum") {
+            if (ro) { std::cerr << "FAIL: lvalue_enum should NOT be read-only" << std::endl; return 1; }
+            found_lvalue_enum = true;
+        } else if (p->GetName() == "rvalue_enum") {
+            if (!ro) { std::cerr << "FAIL: rvalue_enum SHOULD be read-only" << std::endl; return 1; }
+            found_rvalue_enum = true;
+        }
+    }
+    
+    if (found_lvalue && found_rvalue && found_lvalue_enum && found_rvalue_enum) {
+        std::cout << "TEST PASSED SUCCESSFULLY!" << std::endl;
+        return 0;
+    } else {
+        std::cerr << "TEST FAILED: Some properties were not found!" << std::endl;
+        return 1;
+    }
+}
--- a/src/Core/testing/SerializeDreadDiamondTest.cpp
+++ b/src/Core/testing/SerializeDreadDiamondTest.cpp
@@ -40,7 +40,7 @@ struct A : Object {
 };

 ULIB_SERIALIZABLE_OBJECT(A)
-ULIB_SERIALIZE_OBJECT(A, Object) { ar &AR(numa); }
+ULIB_SERIALIZE_OBJECT(A, Object) { ar & AR(numa); }

 struct B : virtual Object {
  uLibTypeMacro(B, Object) B() : numb(5552369) {}
@@ -48,7 +48,7 @@ struct B : virtual Object {
 };

 ULIB_SERIALIZABLE_OBJECT(B)
-ULIB_SERIALIZE_OBJECT(B, Object) { ar &AR(numb); }
+ULIB_SERIALIZE_OBJECT(B, Object) { ar & AR(numb); }

 struct C : B {
  uLibTypeMacro(C, B) C() : numc(5552370) {}
@@ -56,7 +56,7 @@ struct C : B {
 };

 ULIB_SERIALIZABLE_OBJECT(C)
-ULIB_SERIALIZE_OBJECT(C, B) { ar &AR(numc); }
+ULIB_SERIALIZE_OBJECT(C, B) { ar & AR(numc); }

 struct D : A, B {
  uLibTypeMacro(D, A, B)
@@ -67,10 +67,33 @@ struct D : A, B {
 };

 ULIB_SERIALIZABLE_OBJECT(D)
-ULIB_SERIALIZE_OBJECT(D, A, B) { ar &AR(numd); }
+ULIB_SERIALIZE_OBJECT(D, A, B) { ar & AR(numd); }

 int main() {
-  A o;
-
-  Archive::xml_oarchive(std::cout) << NVP(o);
+  BEGIN_TESTING(DreadDiamond Serialization)
+  
+  D o;
+  C c;
+  c.numb = 123;
+  {
+    std::ofstream file("test.xml");
+    Archive::xml_oarchive(file) << NVP("dd_test", o) << NVP("c", c);
+  }
+  {
+    D o2;
+    C c2;
+    std::ifstream file("test.xml");
+    Archive::xml_iarchive(file) >> NVP("dd_test", o2) >> NVP("c", c2);
+    
+    // D //
+    ASSERT_EQUAL(o.numa, o2.numa);
+    ASSERT_EQUAL(o.numb, o2.numb);
+    ASSERT_EQUAL(o.numd, o2.numd);
+    
+    // C //
+    ASSERT_EQUAL(c.numb, c2.numb);
+    ASSERT_EQUAL(c.numc, c2.numc);
+  }
+  
+  END_TESTING
 }
--- a/src/Core/testing/SerializeTest.cpp
+++ b/src/Core/testing/SerializeTest.cpp
@@ -143,22 +143,19 @@ int testing_hrt_class() {
  }
  a.a() = 0;
  a.p_a = "zero string";
-  {
-    // ERRORE FIX !
-    //        std::ifstream file("test.xml");
-    //        Archive::hrt_iarchive(file) >> NVP(a);
-  }

  Archive::hrt_oarchive(std::cout) << NVP(a);
  return (a.a() == 5552368 && a.p_a == "A property string");
 }

+
+
 int main() {
  BEGIN_TESTING(Serialize Test);

  TEST1(test_V3f());
  TEST1(testing_xml_class());
-  //    testing_hrt_class(); ///// << ERRORE in HRT with properties
+  // TEST1(testing_hrt_class());

  END_TESTING;
 }
--- a/src/Core/testing/testing-prototype.h
+++ b/src/Core/testing/testing-prototype.h
@@ -33,5 +33,7 @@ printf("..:: Testing " #name " ::..\n");

 #define TEST1(val) _fail += (val)==0
 #define TEST0(val) _fail += (val)!=0
+#define ASSERT_EQUAL(a,b) if((a)!=(b)) { printf("Assertion failed: " #a " != " #b " at line %d\n", __LINE__); _fail++; }
+#define ASSERT_NOT_NULL(ptr) if((ptr)==NULL) { printf("Assertion failed: " #ptr " is NULL at line %d\n", __LINE__); _fail++; }
 #define END_TESTING return _fail;