fix serialization for properties unintrusive

app/gcompose/src/PropertyWidgets.cpp

@@ -36,6 +36,8 @@ PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent)
     m_Label = new QLabel(labelText, this);
     m_Label->setMinimumWidth(120);
     m_Layout->addWidget(m_Label);
+
+    this->setEnabled(!prop->IsReadOnly());
 }
 PropertyWidgetBase::~PropertyWidgetBase() {
     m_Connection.disconnect();
@@ -150,7 +152,7 @@ DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* pare
     m_Edit->setValue(prop->Get());
     m_Layout->addWidget(m_Edit, 1);
     connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); });
-    m_Connection = uLib::Object::connect(m_Prop, &Property<double>::PropertyChanged, [this](){
+    m_Connection = uLib::Object::connect(m_Prop, &Property<double>::Updated, [this](){
         m_Edit->setValue(m_Prop->Get());
     });
 }
@@ -168,7 +170,7 @@ FloatPropertyWidget::FloatPropertyWidget(Property<float>* prop, QWidget* parent)
     m_Edit->setValue(prop->Get());
     m_Layout->addWidget(m_Edit, 1);
     connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((float)val); });
-    m_Connection = uLib::Object::connect(m_Prop, &Property<float>::PropertyChanged, [this](){
+    m_Connection = uLib::Object::connect(m_Prop, &Property<float>::Updated, [this](){
         m_Edit->setValue((double)m_Prop->Get());
     });
 }
@@ -187,7 +189,7 @@ IntPropertyWidget::IntPropertyWidget(Property<int>* prop, QWidget* parent)
     m_Edit->setValue(prop->Get());
     m_Layout->addWidget(m_Edit, 1);
     connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((int)val); });
-    m_Connection = uLib::Object::connect(m_Prop, &Property<int>::PropertyChanged, [this](){
+    m_Connection = uLib::Object::connect(m_Prop, &Property<int>::Updated, [this](){
         m_Edit->setValue((double)m_Prop->Get());
     });
 }
@@ -198,7 +200,7 @@ BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
     m_CheckBox->setChecked(prop->Get());
     m_Layout->addWidget(m_CheckBox, 1);
     connect(m_CheckBox, &QCheckBox::toggled, [this](bool val){ if (m_Prop->Get() != val) m_Prop->Set(val); });
-    m_Connection = uLib::Object::connect(m_Prop, &Property<bool>::PropertyChanged, [this](){
+    m_Connection = uLib::Object::connect(m_Prop, &Property<bool>::Updated, [this](){
         if (m_CheckBox->isChecked() != m_Prop->Get()) {
             QSignalBlocker blocker(m_CheckBox);
             m_CheckBox->setChecked(m_Prop->Get());
@@ -222,7 +224,7 @@ RangePropertyWidget::RangePropertyWidget(Property<double>* prop, QWidget* parent
     connect(m_Slider, &QSlider::valueChanged, this, &RangePropertyWidget::onSliderChanged);
     connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); });
     
-    m_Connection = uLib::Object::connect(m_Prop, &Property<double>::PropertyChanged, [this](){
+    m_Connection = uLib::Object::connect(m_Prop, &Property<double>::Updated, [this](){
         this->updateUi();
     });
     updateUi();
@@ -252,7 +254,7 @@ ColorPropertyWidget::ColorPropertyWidget(Property<Vector3d>* prop, QWidget* pare
     m_Layout->addWidget(m_Button, 0, ::Qt::AlignRight);
     
     connect(m_Button, &QPushButton::clicked, this, &ColorPropertyWidget::onClicked);
-    m_Connection = uLib::Object::connect(m_Prop, &Property<Vector3d>::PropertyChanged, [this](){
+    m_Connection = uLib::Object::connect(m_Prop, &Property<Vector3d>::Updated, [this](){
         this->updateButtonColor();
     });
 }
@@ -286,7 +288,7 @@ StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget*
         std::string val = m_LineEdit->text().toStdString();
         if (m_Prop->Get() != val) m_Prop->Set(val);
     });
-    m_Connection = uLib::Object::connect(m_Prop, &Property<std::string>::PropertyChanged, [this](){
+    m_Connection = uLib::Object::connect(m_Prop, &Property<std::string>::Updated, [this](){
         if (m_LineEdit->text().toStdString() != m_Prop->Get()) {
             QSignalBlocker blocker(m_LineEdit);
             m_LineEdit->setText(QString::fromStdString(m_Prop->Get()));
@@ -334,7 +336,7 @@ public:
                 p->Set(index);
             });
             // Store connection in base m_Connection so it's auto-disconnected on destruction.
-            m_Connection = uLib::Object::connect(p, &Property<int>::PropertyChanged, [this, p](){
+            m_Connection = uLib::Object::connect(p, &Property<int>::Updated, [this, p](){
                 if (m_Combo->currentIndex() != p->Get()) {
                     QSignalBlocker blocker(m_Combo);
                     m_Combo->setCurrentIndex(p->Get());

app/gcompose/src/PropertyWidgets.h

@@ -115,6 +115,7 @@ public:
             if (!prefSuffix.isEmpty()) {
                m_Edits[i]->setUnits(prefSuffix, factor);
             }
+            m_Edits[i]->setEnabled(!prop->IsReadOnly());
             m_Layout->addWidget(m_Edits[i], 1);
             
             connect(m_Edits[i], &UnitLineEdit::valueManualChanged, [this, i](double val){
@@ -124,7 +125,7 @@ public:
             });
         }
         updateEdits();
-        m_Connection = uLib::Object::connect(m_Prop, &Property<VecT>::PropertyChanged, [this](){
+        m_Connection = uLib::Object::connect(m_Prop, &Property<VecT>::Updated, [this](){
             updateEdits();
         });
     }

docs/archives.md

@@ -0,0 +1,84 @@
+# Serialization and Archives Internals
+
+This document explains the internal design of the `uLib` serialization system, which is built on top of **Boost.Serialization**. It provides custom archive implementations for various formats (XML, Text, Logging) and introduces **Human Readable Pairs (HRP)** for metadata-rich serialization.
+
+---
+
+## Architecture Overview
+
+The `uLib` archive system extends the standard `boost::archive` templates to add domain-specific features. The main components are:
+
+1.  **Custom Interface Layer**: Extends the default Boost archive API with additional operators and utilities.
+2.  **Specialized Archive Implementations**: Specialized classes for XML, Text, and Logging.
+3.  **HRP Support**: First-class support for `hrp` (Human Readable Pair) wrappers, which carry units, ranges, and descriptions.
+4.  **Static Registration System**: Macros and explicit instantiations to handle polymorphic types and compilation isolation.
+
+---
+
+## Custom Interface Layer
+
+All `uLib` archives use a custom interface defined in `Archives.h` via `uLib_interface_iarchive` and `uLib_interface_oarchive`. These templates add several key features:
+
+| Feature | Operator/Method | Description |
+|---|---|---|
+| **Mapping Operator** | `operator==` | Aliased to `operator&` (Boost's standard mapping operator). |
+| **Trace Operator** | `operator!=` | Used for trace/debug output of strings during serialization. |
+| **Type Registration** | `register_type<T>()` | Registers a class type with the archive's internal serializer map. |
+| **Standard IO** | `operator<<` / `operator>>` | Standard redirect for saving and loading. |
+
+These interfaces are applied to the archives using template specialization of `boost::archive::detail::interface_iarchive` and `interface_oarchive`.
+
+---
+
+## Archive Variants
+
+### XML Archives (`xml_iarchive`, `xml_oarchive`)
+These inherit from `boost::archive::xml_iarchive_impl` and `xml_oarchive_impl`. 
+- **Internals**: They override `load_override` and `save_override` to handle `boost::serialization::hrp<T>` specifically. 
+- **XML Mapping**: When saving an `hrp`, it uses `save_start(name)` and `save_end(name)` to wrap the value in a named XML tag.
+
+### Text Archives (`text_iarchive`, `text_oarchive`)
+Standard text-based archives used for compact serialization. They use `StringReader` to consume decorative text markers during loading.
+
+### Human Readable Text (`hrt_iarchive`, `hrt_oarchive`)
+These are "naked" text archives that suppress most of Boost's internal metadata (object IDs, class IDs, versions).
+- **Goal**: Produce text output that is easy for humans to read and edit.
+- **Internals**: All overrides for Boost internal types (like `object_id_type`, `version_type`, etc.) are implemented as no-ops.
+
+### Log Archive (`log_archive`)
+An XML-based output archive specifically for debug logging.
+- **Internals**: It forces every object into a Name-Value Pair (NVP) even if not provided by the user, and strips all technical metadata to keep the logs clean.
+
+---
+
+## HRP (Human Readable Pair) Integration
+
+`hrp` is a core `uLib` wrapper (defined in `Serializable.h`) that extends Boost's `nvp`:
+
+```cpp
+// Example of HRP usage
+ar & HRP2("Energy", m_energy, "MeV").range(0, 100);
+```
+
+### Internal Handling in Archives
+Archives in `Archives.h` provide specific `save_override`/`load_override` for `hrp<T>`:
+- **XML**: Maps the `name()` to an XML tag.
+- **HRT**: Formats as `name: value [units]\n`.
+- **Log**: Converts it to a standard Boost `nvp` for consistent XML logging.
+
+---
+
+## Registration and Polymorphism
+
+### Registration Macro
+The `ULIB_SERIALIZATION_REGISTER_ARCHIVE(Archive)` macro is crucial for polymorphic serialization. It instantiates the necessary template machinery to link the custom `Archive` type with any `Serializable` class exported via `BOOST_CLASS_EXPORT`.
+
+### Explicit Instantiation
+To reduce compilation times and provide a single point of failure for link-time issues, `uLib` uses explicit instantiations in `src/Core/Archives.cpp`. This file includes the `.ipp` implementation files from Boost and instantiates the `archive_serializer_map` and implementation classes for all `uLib` archive types.
+
+---
+
+## Utility: StringReader
+The `StringReader` utility is used internally by text-based archives to parse and skip literals. For example:
+- When loading a string literal from a text archive, `StringReader` consumes whitespace and ensures the stream matches the expected string, failing if there is a mismatch.
+- This is vital for maintaining the structure of human-readable formats.

docs/geant_integration.md

@@ -0,0 +1,11 @@
+# Geant integration
+
+Geant4 integration in uLib is done through the `HEP/Geant` module.
+The module represets a set of wrapper for geant objects that are also deriving from uLib::Object so they can be used in the uLib::Object tree and visualized with the uLib::Vtk module and driven py properties.
+
+# Geant Solid integration
+
+Geant solid in uLib is represented by the `uLib::Geant::Solid` class and mainly BoxSolid and TessellatedSolid. The solids in Geant does not have the possibility to set properties on the fly so we need to create a new solid every time we want to change the properties of a solid. This is done by creating a new `uLib::Geant::Solid` object and setting the properties of the new solid. The new solid is then added to the `uLib::Geant::Solid` object as a child. The old solid is then removed from the `uLib::Geant::Solid` object as a child. The old solid is then deleted. However id some of the properties can be set then the library will drive the change in the solid update.
+
+The idea is to have a mapping of solid properties that can be used in uLib for Qt representation or vtk representation. then when the property is changed the signaling will update the property in uLib and then the solid will be updated. If the Geant property can be applied to the G4 object underneath then the update will apply the change, in case it is not possible to apply the change to the G4 object underneath then the G4 element will be recreated. 
+In any case a updated singal is emitted and the related element that use that solid is updated ( for instance the scene ).

src/Core/Archives.h

@@ -59,6 +59,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 +152,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 +163,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 +214,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 +238,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 +262,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 +296,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,22 +303,6 @@ 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));
-//     }
-
-//};
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -369,17 +344,13 @@ public:
   using base::load_override;
 
   void load_override(const char *str) {
-    //        StringReader sr(basic_text_iprimitive::is);
+    // StringReader sr(basic_text_iprimitive::is);
-    //        sr >> str;
+    // 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> {
@@ -389,12 +360,8 @@ 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> {
@@ -410,11 +377,6 @@ public:
   xml_oarchive(std::ostream &os, unsigned int flags = 0)
       : boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags) {}
 
-  // example of implementing save_override for const char* //
-  //    void save_override(const char *t, int) {
-  //        std::cout << "found char: " << t << "\n";
-  //    }
-
   using basic_xml_oarchive::save_override;
 
   // special treatment for name-value pairs.
@@ -433,10 +395,10 @@ 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() {}
+  virtual ~xml_oarchive() {}
 };
 
 // typedef boost::archive::detail::polymorphic_oarchive_route<
@@ -471,15 +433,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;
@@ -497,13 +455,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;
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -540,7 +494,7 @@ public:
     sr >> str;
   }
 
-  ~hrt_iarchive() {};
+  virtual ~hrt_iarchive() {}
 };
 
 class hrt_oarchive : public boost::archive::text_oarchive_impl<hrt_oarchive> {
@@ -576,7 +530,7 @@ public:
     *this << "\n";
   }
 
-  ~hrt_oarchive() {}
+  virtual ~hrt_oarchive() {}
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -605,17 +559,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);
   }
@@ -640,11 +586,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<
+  virtual ~log_archive() {}
-// boost::archive::xml_oarchive_impl<log_archive>
+};
-//> polymorphic_log_archive;
 
 } // namespace Archive
 
@@ -658,10 +602,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

src/Core/Object.cpp

@@ -115,6 +115,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) {}

src/Core/Property.h

@@ -42,6 +42,7 @@ public:
   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();
@@ -62,6 +63,13 @@ public:
   virtual void serialize(Archive::log_archive & ar, const unsigned int version) = 0;
 };
 
+
+
+
+
+
+
+
 /**
  * @brief Template class for typed properties.
  */
@@ -71,7 +79,7 @@ public:
   // PROXY: Use an existing variable as back-end storage
   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_HasRange(false), m_HasDefault(false), m_ReadOnly(false) {
       if (m_owner) {
           m_owner->RegisterProperty(this);
       }
@@ -80,7 +88,7 @@ public:
   // MANAGED: Create and own internal storage
   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_HasRange(false), m_HasDefault(true), m_Default(defaultValue), m_ReadOnly(false) {
       if (m_owner) {
           m_owner->RegisterProperty(this);
       }
@@ -139,6 +147,9 @@ public:
 
   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; }
 
@@ -209,6 +220,7 @@ private:
   T m_Max;
   bool m_HasDefault;
   T m_Default;
+  bool m_ReadOnly;
 };
 
 /**
@@ -221,7 +233,8 @@ 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.
@@ -239,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)
@@ -304,6 +327,25 @@ public:
             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);
         }
     }
@@ -312,6 +354,16 @@ public:
     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() : "", 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);
         }
     }
@@ -352,12 +404,14 @@ private:
     std::vector<std::string> m_GroupStack;
 };
 
+
+
 /**
  * @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); }
 
 } // namespace Archive
 } // namespace uLib

src/Core/Serializable.h

@@ -71,15 +71,16 @@ 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;
+  T m_min, m_max;
-  T m_max;
+
   bool m_has_default;
   T m_default;
 
@@ -101,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>
@@ -114,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;
@@ -142,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>
@@ -155,13 +155,121 @@ 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);
 }
 
-#define HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
+// Specialization for rvalues (value-based storage)
-#define HRPU(name, units) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name, units)
+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
@@ -181,7 +289,39 @@ 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)
+
+// 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
+
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -300,6 +440,11 @@ namespace uLib {
   template <class ArchiveT>                                                    \
   void _Ob::save_override(ArchiveT &ar, const unsigned int version)
 
+
+
+
+
+  
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

src/Core/testing/CMakeLists.txt

@@ -29,6 +29,7 @@ set( TESTS
         OpenMPTest
         TeamTest
         AffinityTest
+        ReadOnlyPropertyTest
 )
 
 set(LIBRARIES

src/Core/testing/PropertiesTest.cpp

@@ -23,74 +23,137 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
 #include <iostream>
-
+#include <fstream>
-#include <boost/signals2/signal.hpp>
+#include <string>
-
 
 #include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Archives.h"
+#include "Core/Serializable.h"
 #include "testing-prototype.h"
 
-#define emit
+using namespace uLib;
-
-
-
-
-template <typename T, bool copyable = true>
-class property
-{
-    typedef boost::signals2::signal<void(const property<T>& )> signal_t;
 
+/**
+ * @brief A test class to demonstrate property registration via SERIALIZE_OBJECT.
+ */
+class TestObject : public Object {
 public:
-    property() : m_changed(new signal_t) {}
+    uLibTypeMacro(TestObject, Object)
-    property(const T in) : value(in) , m_changed(new signal_t) {}
 
-    inline operator T const & () const { return value; }
+    TestObject() : m_Value(10.5f), m_Status("Initialized"), m_Counter(0) {}
-    inline operator T & () { return value; }
+
-    inline T & operator = (const T &i) { value = i; return value; }
+    float m_Value;
-    template <typename T2> T2 & operator = (const T2 &i) { T2 &guard = value; }    // Assign exact identical types only.
+    std::string m_Status;
-    inline signal_t & valueChanged() { return *m_changed; }
+    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 TestObject2 : public TestObject {
-//class property <T,false> {
+public:
-//    typedef boost::signals2::signal<void( T )> signal_t;
+    uLibTypeMacro(TestObject2, TestObject)
 
-//public:
+    TestObject2() : TestObject(), m_Value2(20.5f) {}
-//    property() : m_changed() {}
-//    property(const T in) : value(in) , m_changed() {}
 
-//    inline operator T const & () const { return value; }
+    float m_Value2;
-//    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()
-{    
 
+    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.);
+}
+
+
+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
 }

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;
+    }
+}

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;
+  BEGIN_TESTING(DreadDiamond Serialization)
   
-  Archive::xml_oarchive(std::cout) << NVP(o);
+  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
 }

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;
 }

src/HEP/Geant/CMakeLists.txt

@@ -27,6 +27,8 @@ set(SOURCES
     Scene.cpp
     Solid.cpp
     EmitterPrimary.cpp
+    Matter.cpp
+    GeantRegistration.cpp
     DetectorConstruction.cpp
     PhysicsList.cpp
     ActionInitialization.cpp

src/HEP/Geant/GeantRegistration.cpp

@@ -0,0 +1,22 @@
+#include "Core/ObjectFactory.h"
+#include "HEP/Geant/Matter.h"
+#include "HEP/Geant/Solid.h"
+#include "HEP/Geant/Scene.h"
+#include "HEP/Geant/EmitterPrimary.hh"
+#include "HEP/Geant/GeantEvent.h"
+
+namespace uLib {
+namespace Geant {
+
+ULIB_REGISTER_OBJECT(Material)
+ULIB_REGISTER_OBJECT(Solid)
+ULIB_REGISTER_OBJECT(TessellatedSolid)
+ULIB_REGISTER_OBJECT(BoxSolid)
+ULIB_REGISTER_OBJECT(Scene)
+ULIB_REGISTER_OBJECT(SkyPlaneEmitterPrimary)
+ULIB_REGISTER_OBJECT(CylinderEmitterPrimary)
+ULIB_REGISTER_OBJECT(QuadMeshEmitterPrimary)
+ULIB_REGISTER_OBJECT(GeantEvent)
+
+} // namespace Geant
+} // namespace uLib

src/HEP/Geant/Matter.cpp

@@ -0,0 +1,21 @@
+
+#include "HEP/Geant/Matter.h"
+#include <Geant4/G4Material.hh>
+#include <Geant4/G4NistManager.hh>
+
+using namespace uLib::Geant;
+
+Material::Material() : m_G4Data(nullptr) {}
+
+Material::Material(const char *name) : m_G4Data(nullptr) {
+    this->SetFromNist(name);
+}
+
+Material::~Material() {
+    if(m_G4Data) delete m_G4Data;
+}
+
+void Material::SetFromNist(const char *name) {
+    G4NistManager* man = G4NistManager::Instance();
+    m_G4Data = man->FindOrBuildMaterial(name);
+}

src/HEP/Geant/Matter.h

@@ -29,9 +29,10 @@
 #define MATTER_H
 
 #include "Core/Object.h"
+#include <Geant4/G4Material.hh>
+#include <Geant4/G4NistManager.hh>
 
 class G4Element;
-class G4Material;
 
 namespace uLib {
 namespace Geant {
@@ -55,18 +56,54 @@ private:
 //// MATERIAL //////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
+// TODO: finish from G4NistMaterialBuilder
 
 class Material : public Object {
 public:
 
+    enum State  {
+        Undefined = 0,
+        Solid,
+        Liquid,
+        Gas
+    };
+
     virtual const char* GetClassName() const override { return "Geant.Material"; }
 
-    uLibRefMacro(G4Data,G4Material *)
+    Material();
+    Material(const char *name);
+    ~Material();
+
+    void SetFromNist(const char *name);
+
+    template <typename Ar>
+    void serialize(Ar &ar) {
+        ar & HRP("name", m_G4Data->GetName());
+        ar & HRP("density", m_G4Data->GetDensity());
+        ar & serialization::make_hrp_enum("state", m_G4Data->GetState(), {"Undefined", "Solid", "Liquid", "Gas"});
+    }
+    
+    G4Material *GetG4Material() { return m_G4Data; }
+
 private:
     G4Material *m_G4Data;
+
 };
 
+// class MaterialCompound : public Material {
+// public:
 
+//     MaterialCompound(const char *name) {}
+        
+//     void AddMaterial(Material *m, double fractionmass) { m_Materials.push_back(std::make_pair(m, fractionmass)); }
+//     void AddElement(Element *e, double fractionmass) { m_Elements.push_back(std::make_pair(e, fractionmass)); }
+//     void SetDensity(double density) { m_Density = density; }
+    
+// private:
+//     std::vector<std::pair<Material *, double>> m_Materials;
+//     std::vector<std::pair<Element *, double>> m_Elements;
+//     double m_Density;
+// };
     
 }
 }

src/HEP/Geant/Solid.cpp

@@ -146,6 +146,9 @@ void Solid::SetParent(Solid *parent) {
 
 
 
+TessellatedSolid::TessellatedSolid() 
+    : BaseClass("unnamed_tessellated"), m_Solid(new G4TessellatedSolid("unnamed_tessellated")) {}
+
 TessellatedSolid::TessellatedSolid(const char *name)
     : BaseClass(name), m_Solid(new G4TessellatedSolid(name)) {
     }
@@ -173,9 +176,15 @@ void TessellatedSolid::Update() {
 
 
 
+BoxSolid::BoxSolid(const char *name) : 
+    BaseClass(name), 
+    m_ContainerBox(new ContainerBox()), 
+    m_Solid(new G4Box(name, 1, 1, 1))
+  {}
+
 BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
-  m_Solid = new G4Box(name, 1,1,1);
+  m_Solid = new G4Box(name, 1, 1, 1);
-  m_Object = box;
+  m_ContainerBox = box;
   Object::connect(box, &ContainerBox::Updated, this, &BoxSolid::Update);
   if (m_Logical) {
     m_Logical->SetSolid(m_Solid);
@@ -184,27 +193,30 @@ BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
 }
 
 void BoxSolid::Update() {
-  if (m_Object) {
+  if (m_ContainerBox) {
-    Vector3f size = m_Object->GetSize();
+    Vector3f size = m_ContainerBox->GetSize();
     m_Solid->SetXHalfLength(size(0) * 0.5);
     m_Solid->SetYHalfLength(size(1) * 0.5);
     m_Solid->SetZHalfLength(size(2) * 0.5);
     
     // Geant4 placement is relative to center. uLib Box is anchored at corner.
     // 1. Get position and rotation (clean, without scale)
-    Vector3f pos = m_Object->GetPosition();
+    Vector3f pos = m_ContainerBox->GetPosition();
-    Matrix3f rot = m_Object->GetRotation();
+    Matrix3f rot = m_ContainerBox->GetRotation();
 
     // 2. Center = Corner + Rotation * (Half-Size)
     // We must rotate the offset vector because uLib box can be rotated.
     Vector3f center = pos + rot * (size * 0.5);
 
-      uLib::AffineTransform t;
+    uLib::AffineTransform t;
     t.SetPosition(center);
     t.SetRotation(rot);
     
     this->SetTransform(t.GetMatrix());
   }
+
+
+
 }
 
 

src/HEP/Geant/Solid.h

@@ -52,6 +52,7 @@ public:
 
   void SetNistMaterial(const char *name);
   void SetMaterial(G4Material *material);
+  
   void SetSizeUnit(const char *unit);
   // Implementiamo SetParent qui, per tutti.
   virtual void SetParent(Solid *parent); 
@@ -69,6 +70,14 @@ public:
     return m_Logical ? m_Logical->GetName().c_str() : m_Name.c_str(); 
   }
 
+  template < typename Ar >
+  void serialize(Ar &ar, const unsigned int version) {
+    ar & m_Name;
+  }
+    
+    
+
+
 protected:
 
   std::string m_Name;
@@ -89,6 +98,7 @@ public:
 
   virtual const char* GetClassName() const override { return "Geant.TessellatedSolid"; }
 
+  TessellatedSolid();
   TessellatedSolid(const char *name);
   void SetMesh(TriangleMesh &mesh);
   uLibGetMacro(Solid, G4TessellatedSolid *) 
@@ -116,16 +126,23 @@ public:
 
   virtual const char* GetClassName() const override { return "Geant.BoxSolid"; }
 
+  BoxSolid(const char *name = "");
   BoxSolid(const char *name, ContainerBox *box);
   virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }
   
-  ContainerBox* GetObject() const { return m_Object; }
+  ContainerBox* GetObject() const { return m_ContainerBox; }
+
+  template < typename Ar >
+  void serialize(Ar &ar, const unsigned int version) {
+    ar & boost::serialization::base_object<BaseClass>(*this);
+    ar & m_ContainerBox;
+  }
 
 public slots:
   void Update();
 
 private:
-  ContainerBox *m_Object;
+  ContainerBox *m_ContainerBox;
   G4Box *m_Solid;
 };
 

src/Math/ContainerBox.h

@@ -103,7 +103,7 @@ public:
   void serialize(ArchiveT & ar, const unsigned int version) {
     ar & HRP(Size);
     ar & HRP(Origin);
-    ar & boost::serialization::make_nvp("TRS", boost::serialization::base_object<TRS>(*this));
+    ar & NVP("TRS", boost::serialization::base_object<TRS>(*this));
   }
 
   /**

src/Vtk/uLibVtkInterface.cxx

@@ -603,6 +603,8 @@ void Puppet::ConnectInteractor(vtkRenderWindowInteractor *interactor)
 }
 
 
+
+
 // ------------------------------------------------------ //
 // SERIALIZE DISPLAY PROPERTIES