transform properties

Reviewed-on: #1
added CUDA for images and raytracing, added python bindings via pybind11, removed LTK, added documentation

.agents/rules/micromamba.md

@@ -0,0 +1,7 @@
+---
+trigger: always_on
+---
+
+build in build directory using always micromamba "mutom" env.
+build with make flag -j$(nproc).
+

.clangd

@@ -0,0 +1,52 @@
+CompileFlags:
+  CompilationDatabase: build
+  Add: 
+    - -I/home/rigoni/devel/cmt/ulib/src
+    - -isystem/home/share/micromamba/envs/mutom/include
+    - -isystem/home/share/micromamba/envs/mutom/include/eigen3
+    - -isystem/home/share/micromamba/envs/mutom/targets/x86_64-linux/include
+    - -isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++
+    - -isystem/isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu
+    - -isystem/home/share/micromamba/envs/mutom/x86_64-conda-linux-gnu/sysroot/usr/include
+    - "--gcc-toolchain=/home/share/micromamba/envs/mutom"
+    - -D_ULIB_DETAIL_SIGNAL_EMIT
+    - -DUSE_CUDA
+    - -std=c++17
+    - "-D__host__="
+    - "-D__device__="
+    - "-D__global__="
+    - "-D__constant__="
+    - "-D__shared__="
+    - "-D__align__(x)="
+    - "-D__forceinline__=inline"
+    - "-D__launch_bounds__(x)="
+
+Diagnostics:
+  UnusedIncludes: None
+  MissingIncludes: None
+
+---
+If:
+  PathExclude: [/home/rigoni/devel/cmt/ulib/src/.*]
+Diagnostics:
+  Suppress: ["*"]
+
+---
+If:
+  PathMatch: [.*\.cu, .*/src/Math/testing/VoxRaytracerTest.cpp, .*/src/Math/VoxRaytracer.cpp, .*/src/Math/VoxImage.cpp]
+CompileFlags:
+  Add: 
+    - "-x"
+    - "cuda"
+    - "--cuda-path=/home/share/micromamba/envs/mutom"
+    - "--cuda-gpu-arch=sm_61"
+    - "--gcc-toolchain=/home/share/micromamba/envs/mutom"
+    - "-L/home/share/micromamba/envs/mutom/lib"
+    - "-lcudart"
+    - "-lcuda"
+    - "-U__host__"
+    - "-U__device__"
+    - "-U__global__"
+    - "-U__constant__"
+    - "-U__shared__"
+    - "-U__forceinline__"

.gitattributes

@@ -0,0 +1,2 @@
+*.vtk filter=lfs diff=lfs merge=lfs -text
+*.vti filter=lfs diff=lfs merge=lfs -text

.gitea/workflows/publish-docs.yaml

@@ -0,0 +1,42 @@
+name: MkDocs Subpath Deploy
+
+on:
+  workflow_dispatch: # trigger manuale
+  push:
+    branches:
+      - main  # Trigger on main branch
+
+jobs:
+  build-and-deploy:
+    runs-on: mildpub # Runner that can access to SSH_YFINPUB_HOST
+    
+    steps:
+      - name: Checkout del codice
+        uses: actions/checkout@v4
+
+      - name: Configura Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Installa dipendenze
+        run: |
+          python -m pip install --upgrade pip
+          pip install mkdocs-material 
+          pip install -r docs/docker/requirements.txt
+
+      - name: Build del sito
+        run: mkdocs build
+
+      - name: Deploy via SSH (SCP)
+        uses: https://github.com/appleboy/scp-action@master
+        with:
+          host: ${{ vars.SSH_YFINPUB_HOST }}
+          username: ${{ vars.SSH_YFINPUB_USER }}
+          key: ${{ secrets.MILD_PUB }}
+          port: 22
+          source: "site/*"
+          # Il percorso sul server deve corrispondere alla tua sottopagina
+          target: "/var/www/docs/cmt/uLib/"
+          strip_components: 1 # Rimuove la cartella "site/" e mette solo il contenuto
+          rm: true            # Pulisce la cartella prima di copiare (opzionale, stile Vercel)

.gitignore

@@ -1,3 +1,15 @@
 CMakeFiles/
 build/
+.cache/
+build_warnings*.log
+final_build.log
+cmake_configure.log
+compile_commands.json
 
+dist/
+build_python/
+src/Python/uLib/*.so*
+src/Python/uLib/*.pyd
+src/Python/uLib/*.pyc
+src/Python/uLib/__pycache__
+src/Python/uLib/.nfs*

.vscode/settings.json

@@ -0,0 +1,32 @@
+{
+    "clangd.fallbackFlags": [
+        "-I/home/rigoni/devel/cmt/ulib/src",
+        "-isystem/home/share/micromamba/envs/mutom/include",
+        "-isystem/home/share/micromamba/envs/mutom/include/eigen3",
+        "-isystem/home/share/micromamba/envs/mutom/targets/x86_64-linux/include",
+        "-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++",
+        "-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu",
+        "-isystem/home/share/micromamba/envs/mutom/x86_64-conda-linux-gnu/sysroot/usr/include",
+        "--gcc-toolchain=/home/share/micromamba/envs/mutom",
+        "-D__host__=",
+        "-D__device__=",
+        "-D__global__=",
+        "-D__constant__=",
+        "-D__shared__=",
+        "-DUSE_CUDA",
+        "-D__CUDACC__"
+    ],
+    "clangd.semanticHighlighting.enable": true,
+    "clangd.arguments": [
+        "--compile-commands-dir=build",
+        "--query-driver=/home/share/micromamba/envs/mutom/bin/g++,/home/share/micromamba/envs/mutom/bin/gcc,/home/share/micromamba/envs/mutom/bin/nvcc",
+        "--suppress-system-warnings",
+        "--all-scopes-completion",
+        "--completion-style=detailed",
+        "--header-insertion=never",
+        "-j=4",
+        "--pch-storage=memory",
+        "--background-index",
+        "--log=verbose"
+    ]
+}

CLAUDE.md

@@ -0,0 +1,90 @@
+
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+
+```bash
+# Activate the conda environment (required before any build/run)
+export MAMBA_EXE="/home/share/micromamba/bin/micromamba"
+export MAMBA_ROOT_PREFIX="/home/share/micromamba"
+eval "$(/home/share/micromamba/bin/micromamba shell hook --shell bash)"
+micromamba activate mutom
+
+# Configure (from repo root, using Conan preset)
+cmake --preset conan-release
+
+# Build everything
+cmake --build build -j$(nproc)
+
+# Build a specific target
+cmake --build build --target gcompose -j$(nproc)
+
+# Run tests
+cmake --build build --target test
+# or
+ctest --test-dir build
+
+# Run a single test binary (example)
+./build/src/Core/testing/CoreTest
+
+# Run the gcompose GUI app
+./build/app/gcompose/gcompose
+```
+
+First-time setup (if `build/` does not exist):
+```bash
+conan profile detect
+conan install . --output-folder=build --build=missing
+cmake --preset conan-release
+```
+
+## Architecture
+
+**uLib** is a C++ framework for Cosmic Muon Tomography (CMT), structured as layered shared libraries:
+
+```
+mutomCore  →  mutomMath  →  mutomDetectors  →  mutomGeant
+                                              ↘
+                                           mutomVtk  →  gcompose (Qt6 GUI app)
+                                           mutomRoot
+```
+
+### Core Object Model (`src/Core/`)
+- All framework objects inherit from `uLib::Object`
+- **Property system**: `Property<T>` wraps member pointers with change notification via `PropertyChanged` signal
+- **Signal/slot**: `uLib::Object::connect(sender, &Sender::Signal, callback)` — resembles Qt but works for non-QObject classes
+- **Serialization**: Boost archives (`xml_oarchive`, `text_oarchive`, `hrt_oarchive`); `hrp<T>` marks fields as "human-readable properties"
+- `ObjectsContext` is a container owning a list of `Object*` pointers; signals `ObjectAdded`/`ObjectRemoved`
+
+### VTK Layer (`src/Vtk/`)
+- `Puppet` (inherits `uLib::Object`): wraps a VTK `vtkProp` for rendering. Has `GetContent()` returning the underlying domain object. Display-only properties are registered via `ULIB_ACTIVATE_DISPLAY_PROPERTIES` macro.
+- `Viewport`: base class managing the VTK renderer, picking, selection logic. Maintains `m_Puppets` vector and `m_ObjectToPuppet` map.
+- `QViewport` (inherits `QWidget` + `Viewport`): Qt-embedded VTK widget. Emits Qt signal `puppetSelected(Puppet*)` on click-selection via `OnSelectionChanged`.
+- `vtkObjectsContext`: wraps `ObjectsContext`, creating/destroying `Puppet`s as objects come/go. Emits `PuppetAdded`/`PuppetRemoved`.
+- Display properties: `serialize_display()` + `display_properties_archive` registers selected `hrp<T>` fields as `PropertyBase*` in the puppet's `m_DisplayProperties`. `PropertyEditor::setObject(obj, displayOnly=true)` shows only those.
+
+### gcompose GUI App (`app/gcompose/src/`)
+- `MainPanel`: top-level widget. Owns `ContextPanel` (left) and `ViewportPane` (right). Wires together viewport↔context selection via signals.
+- `ContextPanel`: tree view of `ObjectsContext`. Emits `objectSelected(Object*)`. Contains an embedded `PropertiesPanel`.
+- `PropertiesPanel`: shows `uLib::Object` properties via `PropertyEditor`.
+- `ViewportPane`: embeds `QViewport` + a slide-out "Display Properties" panel (`PropertyEditor` in display-only mode).
+- `PropertyEditor`: populates widgets from `Object::GetProperties()` (all) or `Puppet::GetDisplayProperties()` (display-only mode).
+
+### Selection Sync Flow
+```
+Viewport click  →  Viewport::SelectPuppet()  →  QViewport::OnSelectionChanged()
+                →  emit puppetSelected(p)
+                →  MainPanel: contextPanel->selectObject(p->GetContent())  [updates tree + PropertiesPanel]
+                →  MainPanel: firstPane->setObject(p)  [updates Display Properties panel]
+
+ContextPanel tree click  →  emit objectSelected(obj)
+                →  MainPanel: viewport->SelectPuppet(puppet)  [visual selection in VTK]
+                →  MainPanel: firstPane->setObject(puppet)  [updates Display Properties panel]
+```
+
+### Key Patterns
+- **Two signal systems coexist**: Qt signals (`Q_OBJECT`, `connect(...)`) for GUI; `uLib::Object::connect(...)` for domain signals.
+- **Display properties** flow: `Puppet::serialize_display()` → `display_properties_archive` → `RegisterDisplayProperty()` → `PropertyEditor(displayOnly=true)`. Must call `ULIB_ACTIVATE_DISPLAY_PROPERTIES` in the puppet constructor.
+- **Puppet ↔ Object map**: `Viewport::m_ObjectToPuppet` allows lookup by domain object; `vtkObjectsContext::GetPuppet(obj)` does the same.

CMake/uLibCommon.cmake

@@ -15,16 +15,16 @@ set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin CACHE PATH "build path for
 mark_as_advanced(EXECUTABLE_OUTPUT_PATH)
 
 ## Install directories ##
-set(PACKAGE_INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables")
-set(PACKAGE_INSTALL_LIB_DIR lib/${PACKAGE_NAME} CACHE PATH "Installation directory for libraries")
-set(PACKAGE_INSTALL_INC_DIR include/${PACKAGE_NAME} CACHE PATH "Installation directory for headers")
-set(PACKAGE_INSTALL_DATA_DIR share/${PACKAGE_NAME} CACHE PATH "Installation directory for data files")
+set(INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables")
+set(INSTALL_LIB_DIR lib/${PACKAGE_NAME} CACHE PATH "Installation directory for libraries")
+set(INSTALL_INC_DIR include/${PACKAGE_NAME} CACHE PATH "Installation directory for headers")
+set(INSTALL_DATA_DIR share/${PACKAGE_NAME} CACHE PATH "Installation directory for data files")
 if(WIN32 AND NOT CYGWIN)
  set(DEF_INSTALL_CMAKE_DIR CMake)
 else()
  set(DEF_INSTALL_CMAKE_DIR lib/cmake/${PACKAGE_NAME})
 endif()
-set(PACKAGE_INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")
+set(INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")
 
 # Make relative paths absolute (needed later on)
 foreach(p LIB BIN INC DATA CMAKE)
@@ -58,7 +58,7 @@ endif()
 set(CMAKE_CXX_WARNING_OPTION "" CACHE STRING "Warning level -WAll to verbose all warnings")
 set(CMAKE_VERBOSE_MAKEFILE FALSE CACHE STRING "Verbose compile output switch")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x ${CMAKE_CXX_WARNING_OPTION}")
+# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x ${CMAKE_CXX_WARNING_OPTION}")
 
 
 

CMake/uLibTargetMacros.cmake

@@ -41,15 +41,15 @@ macro(uLib_add_shared_library name)
 
   install(TARGETS ${mname}
          EXPORT "${PROJECT_NAME}Targets"
-         RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-         LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib
-  #         PUBLIC_HEADER DESTINATION ${PACKAGE_INSTALL_INC_DIR} COMPONENT dev
+         RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib
+  #         PUBLIC_HEADER DESTINATION ${INSTALL_INC_DIR} COMPONENT dev
   )
  endif(SOURCES)
 
  if(HEADERS)
   foreach(header ${HEADERS})
-   install(FILES ${header} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/${name})
+   install(FILES ${header} DESTINATION ${INSTALL_INC_DIR}/${name})
   endforeach(header)
   endif(HEADERS)
 
@@ -70,7 +70,7 @@ macro(uLib_add_target name)
 
     install(TARGETS ${name}
             EXPORT "${PROJECT_NAME}Targets"
-            RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
+            RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
            )
 ENDMACRO(uLib_add_target)
 
@@ -82,8 +82,9 @@ ENDMACRO(uLib_add_target)
 # TESTS and LIBRARIES must be defined
 macro(uLib_add_tests name)
     foreach(tn ${TESTS})
-        add_executable(${tn} EXCLUDE_FROM_ALL ${tn}.cpp)
+        add_executable(${tn} ${tn}.cpp)
         add_test(NAME ${tn} COMMAND ${tn})
+        set_tests_properties(${tn} PROPERTIES ENVIRONMENT "CTEST_PROJECT_NAME=uLib;QT_QPA_PLATFORM=offscreen")
 
         target_link_libraries(${tn} ${LIBRARIES})
 
@@ -91,7 +92,9 @@ macro(uLib_add_tests name)
 
     # custom target to compile all tests
     add_custom_target(all-${name}-tests)
-    add_dependencies(all-${name}-tests ${TESTS})
+    if(TESTS)
+        add_dependencies(all-${name}-tests ${TESTS})
+    endif()
 endmacro(uLib_add_tests name)
 
 

CMakeConfig.in.h

@@ -34,7 +34,9 @@
 #cmakedefine HAVE_FLOOR
 
 /* Having Geant4 installed */
+#ifndef HAVE_GEANT4
 #cmakedefine HAVE_GEANT4
+#endif
 
 /* Define to 1 if you have the <inttypes.h> header file. */
 #cmakedefine HAVE_INTTYPES_H

CMakeLists.txt

@@ -3,15 +3,42 @@
 ##### CMAKE LISTS ##############################################################
 ################################################################################
 
-cmake_minimum_required (VERSION 2.6)
+if(EXISTS "${CMAKE_BINARY_DIR}/conan_toolchain.cmake")
+    include("${CMAKE_BINARY_DIR}/conan_toolchain.cmake")
+endif()
+
+cmake_minimum_required (VERSION 3.26)
+
+set(QT_NO_VERSION_CHECK TRUE)
+
+if(POLICY CMP0167)
+    cmake_policy(SET CMP0167 NEW)
+endif()
+
 
 ## -------------------------------------------------------------------------- ##
 
 project(uLib)
 
+# CUDA Toolkit seems to be missing locally. Toggle ON if nvcc is made available.
+option(USE_CUDA "Enable CUDA support" OFF)
+if(USE_CUDA)
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -allow-unsupported-compiler")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcudafe \"--diag_suppress=20012\"")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcudafe \"--diag_suppress=20014\"")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcudafe \"--diag_suppress=20015\"")
+    find_package(CUDAToolkit REQUIRED)
+    enable_language(CUDA)
+    set(CMAKE_CUDA_ARCHITECTURES 61)
+    include_directories(${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
+    add_compile_definitions(USE_CUDA)
+endif()
+
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 4)
+set(PROJECT_VERSION_MINOR 6)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
@@ -33,19 +60,31 @@ message(STATUS "Module path = ${CMAKE_MODULE_PATH}")
 
 ## GLOBALS ------------------------------------------------------------------ ##
 
-set(PACKAGE_INSTALL_BIN_DIR ${CMAKE_INSTALL_PREFIX}/bin 
-    CACHE PATH "Installation directory for executables")
-set(PACKAGE_INSTALL_LIB_DIR ${CMAKE_INSTALL_PREFIX}/lib/
-    CACHE PATH "Installation directory for libraries")
-set(PACKAGE_INSTALL_INC_DIR ${CMAKE_INSTALL_PREFIX}/include/${PACKAGE_NAME}
-    CACHE PATH "Installation directory for headers")
-set(PACKAGE_INSTALL_DATA_DIR ${CMAKE_INSTALL_PREFIX}/share/${PACKAGE_NAME}
-    CACHE PATH "Installation directory for data files")
-set(PACKAGE_INSTALL_CMAKE_DIR ${CMAKE_INSTALL_PREFIX}/lib/cmake/${PACKAGE_NAME}
-    CACHE PATH "Installation directory for CMake files")
+# -- move to GnuInstallDirs
+# ref: https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+include(GNUInstallDirs)
+set(INSTALL_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of header files (.../include)" )
+set(INSTALL_ETC_DIR ${CMAKE_INSTALL_SYSCONFDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of configuration files (.../etc)" )
+set(INSTALL_BIN_DIR ${CMAKE_INSTALL_BINDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of executable files (.../bin)" )
+set(INSTALL_LIB_DIR ${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "Location of library files (.../lib)" )
+set(INSTALL_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PACKAGE_NAME}
+    CACHE PATH "Location of cmake files (.../lib/cmake)" )   
+set(INSTALL_DATA_DIR ${CMAKE_INSTALL_DATADIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of data files (.../share)" )
+
+
+
 
 set(SRC_DIR ${PROJECT_SOURCE_DIR}/src)
 
+# this is used to be exported in build target 
+# ( to compile against build directory instead of install )
+set(ULIB_SOURCE_DIR ${PROJECT_SOURCE_DIR})
+
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
     message(STATUS "Setting build type to 'Release' as none was specified.")
     set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
@@ -60,27 +99,91 @@ set(CMAKE_CXX_WARNING_OPTION ""
 set(CMAKE_VERBOSE_MAKEFILE FALSE
     CACHE STRING "Verbose compile output switch")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x ${CMAKE_CXX_WARNING_OPTION}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_WARNING_OPTION}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
+
+# CTEST framework
+set(CTEST_PROJECT_NAME "uLib")
+include(CTest)
+enable_testing()
 
-#enable_testing()
 
 ## FIND PACKAGES ------------------------------------------------------------ ##
 
 set(Boost_USE_STATIC_LIBS OFF)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
-find_package(Boost 1.45.0 COMPONENTS program_options REQUIRED)
+message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}")
+
+find_package(HDF5 REQUIRED)
+
+find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_framework REQUIRED)
 include_directories(${Boost_INCLUDE_DIRS})
 
 find_package(Eigen3 CONFIG REQUIRED)
-include(${EIGEN3_USE_FILE})
+get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+include_directories(${EIGEN3_INCLUDE_DIRS})
 
 find_package(ROOT CONFIG REQUIRED)
 include(${ROOT_USE_FILE})
 
-find_package(VTK CONFIG REQUIRED)
-include(${VTK_USE_FILE})
+find_package(VTK REQUIRED)
+find_package(pybind11 REQUIRED)
+
+option(CENTOS_SUPPORT "VTK definitions for CentOS" OFF)
+if(CENTOS_SUPPORT)
+    find_package(VTK CONFIG REQUIRED)
+    # include(${VTK_USE_FILE})
+else()
+    find_package(VTK REQUIRED
+                     COMPONENTS CommonColor
+                                CommonCore
+                                FiltersCore
+                                FiltersModeling
+                                FiltersSources
+                                IOLegacy
+                                IOXML
+                                IOXMLParser
+                                ImagingCore
+                                InteractionStyle
+                                InteractionWidgets
+                                RenderingAnnotation
+                                RenderingContextOpenGL2
+                                RenderingCore
+                                RenderingFreeType
+                                RenderingGL2PSOpenGL2
+                                RenderingOpenGL2
+                                RenderingVolumeOpenGL2
+                                IOGeometry
+                                GUISupportQt)
+endif()
+
+find_package(Qt6 COMPONENTS Widgets)
+if(Qt6_FOUND)
+    add_compile_definitions(HAVE_QT)
+endif()
+
+find_package(Geant4)
+if(Geant4_FOUND)
+    message(STATUS "Geant4 libs: ${Geant4_LIBRARIES}")
+    add_compile_definitions(HAVE_GEANT4)
+    set(HAVE_GEANT4 1)
+
+    # Sanitize Geant4 targets to remove Qt5 dependencies that conflict with VTK/Qt6
+    if(TARGET Geant4::G4interfaces)
+        set_target_properties(Geant4::G4interfaces PROPERTIES 
+            INTERFACE_LINK_LIBRARIES "Geant4::G4global;Geant4::G4graphics_reps;Geant4::G4intercoms"
+        )
+    endif()
+    if(TARGET Geant4::G4OpenGL)
+        set_target_properties(Geant4::G4OpenGL PROPERTIES 
+            INTERFACE_LINK_LIBRARIES "Geant4::G4vis_management;Geant4::G4graphics_reps;Geant4::G4geometry;Geant4::G4materials;Geant4::G4intercoms;Geant4::G4global;OpenGL::GL;OpenGL::GLU"
+        )
+    endif()
+else()
+    message(STATUS "Geant4 NOT found - optional features will be disabled")
+    set(HAVE_GEANT4 0)
+endif()
 
 set(CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_INCLUDES math.h)
 set(CMAKE_REQUIRED_LIBRARIES CMAKE_REQUIRED_LIBRARIES m)
@@ -119,7 +222,7 @@ configure_file("${PROJECT_SOURCE_DIR}/CMakeConfig.in.h"
                "${PROJECT_BINARY_DIR}/config.h")
 
 install(FILES "${PROJECT_BINARY_DIR}/config.h"
-        DESTINATION ${PACKAGE_INSTALL_INC_DIR})
+        DESTINATION ${INSTALL_INC_DIR})
 
 ## ADD LIBRARIES SUBDIRECTORIES --------------------------------------------- ##
 
@@ -137,8 +240,8 @@ add_subdirectory(${SRC_DIR}/Core)
 include_directories(${SRC_DIR}/Math)
 add_subdirectory(${SRC_DIR}/Math)
 
-include_directories(${SRC_DIR}/Detectors)
-add_subdirectory(${SRC_DIR}/Detectors)
+include_directories(${SRC_DIR}/HEP)
+add_subdirectory(${SRC_DIR}/HEP)
 
 include_directories(${SRC_DIR}/Root)
 add_subdirectory(${SRC_DIR}/Root)
@@ -146,7 +249,9 @@ add_subdirectory(${SRC_DIR}/Root)
 include_directories(${SRC_DIR}/Vtk)
 add_subdirectory(${SRC_DIR}/Vtk)
 
-#add_subdirectory("${SRC_DIR}/utils/make_recipe")
+add_subdirectory(${SRC_DIR}/Python)
+
+add_subdirectory(app)
 
 ## Documentation and packages
 
@@ -164,8 +269,8 @@ add_subdirectory(${SRC_DIR}/Vtk)
 
 
 # Create the FooBarConfig.cmake and FooBarConfigVersion files
-file(RELATIVE_PATH REL_INCLUDE_DIR "${PACKAGE_INSTALL_CMAKE_DIR}"
-   "${PACKAGE_INSTALL_INC_DIR}")
+# file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}"
+#    "${INSTALL_INC_DIR}")
 
 # ... for the build tree
 #set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}")
@@ -174,21 +279,53 @@ file(RELATIVE_PATH REL_INCLUDE_DIR "${PACKAGE_INSTALL_CMAKE_DIR}"
 
 # ... for the install tree
 set(CONF_INCLUDE_DIRS "\${ULIB_CMAKE_DIR}/${REL_INCLUDE_DIR}")
-configure_file(uLibConfig.cmake.in
-               "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
-               @ONLY)
+# [ removed for the configure_config_file ]
+# configure_file(uLibConfig.cmake.in
+#                "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+#                @ONLY)
 
 # ... for both
 configure_file(uLibConfigVersion.cmake.in
-               "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake" @ONLY)
+                "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake" @ONLY)
 
-install(FILES "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+
+# from CMake 3.x configure file shall be created using a dedicated function
+# see: https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html
+#
+include(CMakePackageConfigHelpers)
+configure_package_config_file(uLibConfig.cmake.in
+                              "${PROJECT_BINARY_DIR}/uLibConfig.cmake"
+                              INSTALL_DESTINATION ${INSTALL_CMAKE_DIR}
+                              PATH_VARS 
+                                INSTALL_LIB_DIR 
+                                INSTALL_INC_DIR 
+                                INSTALL_BIN_DIR 
+                                INSTALL_CMAKE_DIR 
+                                INSTALL_ETC_DIR 
+                                INSTALL_DATA_DIR
+                                ULIB_SOURCE_DIR
+                                ULIB_SHARED_LIBRARIES
+                              # NO_SET_AND_CHECK_MACRO
+                              # NO_CHECK_REQUIRED_COMPONENTS_MACRO
+                              )
+
+install(FILES "${PROJECT_BINARY_DIR}/uLibConfig.cmake"
               "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake"
-        DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}"
+        DESTINATION "${INSTALL_CMAKE_DIR}"
         COMPONENT dev)
 
+
+# this is a special target file for the build tree
+# it is used also to identify if we are using a build direcory
+# to link a project against uLib. see: uLibConfig.cmake ( IF )
+export (TARGETS ${ULIB_SHARED_LIBRARIES}
+        FILE "${PROJECT_BINARY_DIR}/uLibTargets-build.cmake"
+        # NAMESPACE "uLib::"
+)        
+
 # Install the export set for use with the install-tree
-install(EXPORT "${PROJECT_NAME}Targets"
-        DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}"
+install(EXPORT "uLibTargets"
+        FILE "uLibTargets.cmake"
+        DESTINATION "${INSTALL_CMAKE_DIR}"
         COMPONENT dev)
 

CMakePresets.json

@@ -0,0 +1,16 @@
+{
+    "version": 8,
+    "configurePresets": [
+        {
+            "name": "andrea",
+            "displayName": "Custom configure preset",
+            "description": "Sets Ninja generator, build and install directory",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/out/build/${presetName}",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
+            }
+        }
+    ]
+}

CMakeUserPresets.json

@@ -0,0 +1,9 @@
+{
+    "version": 4,
+    "vendor": {
+        "conan": {}
+    },
+    "include": [
+        "build/CMakePresets.json"
+    ]
+}

README.md

@@ -7,3 +7,64 @@ base toolkit library
 CMT Cosmic Muon Tomography reconstruction, analysis and imaging software
 Developed by University of Padova and INFN Sezione di Padova  Italy
 
+## Build Instructions
+
+This project relies on `conan` (v2) for dependency management (Eigen3, Boost) and `cmake` for configuration. VTK is provided through the micromamba/conda-forge environment.
+
+### Prerequisites
+
+This project requires a `conda` or `micromamba` environment containing the necessary global tools like **ROOT**, **VTK**, and **Conan** (v2). We provide a `condaenv.yml` file to quickly build this environment.
+
+#### Installing Micromamba (Optional)
+
+If you do not have `conda` installed, `micromamba` is a fast and lightweight alternative. You can install it on Linux via:
+
+```bash
+"${SHELL}" <(curl -L micro.mamba.pm/install.sh)
+```
+
+#### Creating the Environment
+
+You can create and activate the environment using either `micromamba` or `conda`.
+
+**Using Micromamba:**
+```bash
+micromamba env create -f condaenv.yml
+micromamba activate mutom
+```
+
+**Using Conda:**
+```bash
+conda env create -f condaenv.yml
+conda activate mutom
+```
+
+### Configure and Build
+
+1. **Configure Conan profile (if you haven't yet on your machine):**
+```bash
+conan profile detect
+```
+
+2. **Install Conan dependencies:**
+```bash
+conan install . --output-folder=build --build=missing
+```
+
+3. **Configure the project with CMake:**
+```bash
+cmake --preset conan-release
+```
+*(Alternatively: `cd build && cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release`)*
+
+4. **Build the project:**
+```bash
+cmake --build build -j10
+```
+
+### Make python package
+
+```bash
+micromamba run -n mutom env USE_CUDA=ON poetry install
+```
+

Testing/Temporary/CTestCostData.txt

@@ -0,0 +1 @@
+---

Testing/Temporary/LastTest.log

@@ -0,0 +1,3 @@
+Start testing: Mar 25 18:59 UTC
+----------------------------------------------------------
+End testing: Mar 25 18:59 UTC

app/CMakeLists.txt

@@ -0,0 +1,3 @@
+if(HAVE_GEANT4)
+    add_subdirectory(gcompose)
+endif()

app/gcompose/CMakeLists.txt

@@ -0,0 +1,53 @@
+
+add_executable(gcompose 
+    src/main.cpp
+    src/MainWindow.h
+    src/MainWindow.cpp
+    src/ViewportPane.h
+    src/ViewportPane.cpp
+    src/MainPanel.h
+    src/MainPanel.cpp
+    src/ContextPanel.h
+    src/ContextPanel.cpp
+    src/ContextModel.h
+    src/ContextModel.cpp
+    src/StyleManager.h
+    src/StyleManager.cpp
+    src/PropertyWidgets.h
+    src/PropertyWidgets.cpp
+    src/PropertiesPanel.h
+    src/PropertiesPanel.cpp
+)
+
+set_target_properties(gcompose PROPERTIES
+    AUTOMOC ON
+    AUTOUIC ON
+    AUTORCC ON
+)
+
+target_include_directories(gcompose PRIVATE 
+    ${SRC_DIR}
+    ${PROJECT_BINARY_DIR}
+    ${Geant4_INCLUDE_DIRS}
+    ${VTK_INCLUDE_DIRS}
+)
+
+# Filter Geant4 libraries to remove Qt-dependent ones
+set(Geant4_LIBS_FILTERED ${Geant4_LIBRARIES})
+if(Geant4_LIBS_FILTERED)
+    list(REMOVE_ITEM Geant4_LIBS_FILTERED Geant4::G4interfaces Geant4::G4OpenGL Geant4::G4visQt3D)
+endif()
+
+target_link_libraries(gcompose
+    mutomCore
+    mutomMath
+    mutomGeant
+    mutomVtk
+    mutomRoot
+    ${Geant4_LIBS_FILTERED}
+    ${VTK_LIBRARIES}
+    Qt6::Widgets
+    VTK::GUISupportQt
+)
+
+install(TARGETS gcompose RUNTIME DESTINATION bin)

app/gcompose/src/ContextModel.cpp

@@ -0,0 +1,176 @@
+#include "ContextModel.h"
+#include <QString>
+#include <typeinfo>
+#include <cxxabi.h>
+#include <functional>
+#include "Core/Object.h"
+
+ContextModel::ContextModel(QObject* parent) 
+    : QAbstractItemModel(parent), m_rootContext(nullptr) {}
+
+ContextModel::~ContextModel() {}
+
+void ContextModel::setContext(uLib::ObjectsContext* context) {
+    beginResetModel();
+    m_rootContext = context;
+    if (m_rootContext) {
+        auto refresh = [this]() {
+            this->beginResetModel();
+            this->endResetModel();
+        };
+
+        uLib::Object::connect(m_rootContext, &uLib::Object::Updated, refresh);
+        uLib::Object::connect(m_rootContext, &uLib::ObjectsContext::ObjectAdded, [this, refresh](uLib::Object* obj) {
+            uLib::Object::connect(obj, &uLib::Object::Updated, refresh);
+            refresh();
+        });
+        uLib::Object::connect(m_rootContext, &uLib::ObjectsContext::ObjectRemoved, [this, refresh](uLib::Object* obj) {
+            // Disconnect would be good here but not strictly required if refresh handles it
+            refresh();
+        });
+
+        // Connect existing objects
+        for (auto* obj : m_rootContext->GetObjects()) {
+            uLib::Object::connect(obj, &uLib::Object::Updated, refresh);
+        }
+    }
+    endResetModel();
+}
+
+QModelIndex ContextModel::index(int row, int column, const QModelIndex& parent) const {
+    if (!hasIndex(row, column, parent) || !m_rootContext) {
+        return QModelIndex();
+    }
+
+    if (!parent.isValid()) {
+        if (row < m_rootContext->GetCount()) {
+            return createIndex(row, column, m_rootContext->GetObject(row));
+        }
+    } else {
+        uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
+        uLib::ObjectsContext* parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj);
+        if (parentCtx && row < parentCtx->GetCount()) {
+            return createIndex(row, column, parentCtx->GetObject(row));
+        }
+    }
+    return QModelIndex();
+}
+
+QModelIndex ContextModel::parent(const QModelIndex& child) const {
+    if (!child.isValid() || !m_rootContext) {
+        return QModelIndex();
+    }
+
+    uLib::Object* childObj = static_cast<uLib::Object*>(child.internalPointer());
+    
+    // Finding the parent of childObj is O(N) since there is no parent pointer.
+    // We just do a recursive search starting from root context.
+    std::function<uLib::ObjectsContext*(uLib::ObjectsContext*, uLib::Object*)> findParent = 
+        [&findParent](uLib::ObjectsContext* ctx, uLib::Object* target) -> uLib::ObjectsContext* {
+        for (const auto& obj : ctx->GetObjects()) {
+            if (obj == target) return ctx;
+            if (auto subCtx = dynamic_cast<uLib::ObjectsContext*>(obj)) {
+                if (auto p = findParent(subCtx, target)) return p;
+            }
+        }
+        return nullptr;
+    };
+
+    uLib::ObjectsContext* parentCtx = findParent(m_rootContext, childObj);
+    if (!parentCtx || parentCtx == m_rootContext) {
+        return QModelIndex(); // Root items have invalid parent index
+    }
+
+    // Now need to find the row of parentCtx in its own parent Context.
+    uLib::ObjectsContext* grandParentCtx = findParent(m_rootContext, parentCtx);
+    if (!grandParentCtx) grandParentCtx = m_rootContext;
+
+    int row = -1;
+    for (size_t i = 0; i < grandParentCtx->GetCount(); ++i) {
+        if (grandParentCtx->GetObject(i) == parentCtx) {
+            row = (int)i;
+            break;
+        }
+    }
+
+    if (row != -1) {
+        return createIndex(row, 0, parentCtx);
+    }
+    return QModelIndex();
+}
+
+int ContextModel::rowCount(const QModelIndex& parent) const {
+    if (!m_rootContext) return 0;
+
+    if (!parent.isValid()) {
+        return m_rootContext->GetCount();
+    }
+
+    uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
+    if (auto parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj)) {
+        return parentCtx->GetCount();
+    }
+    return 0; // leaf node
+}
+
+int ContextModel::columnCount(const QModelIndex& parent) const {
+    return 1;
+}
+
+static QString getDemangledName(const std::type_info& info) {
+    int status = -4;
+    char* demangled = abi::__cxa_demangle(info.name(), nullptr, nullptr, &status);
+    QString res = (status == 0 && demangled) ? QString::fromUtf8(demangled) : QString::fromUtf8(info.name());
+    if (demangled) free(demangled);
+    
+    // Remove namespaces
+    int lastColon = res.lastIndexOf("::");
+    if (lastColon != -1) {
+        res = res.mid(lastColon + 2);
+    }
+    
+    // Remove "class " prefix if any
+    if (res.startsWith("class ")) res = res.mid(6);
+    return res;
+}
+
+QVariant ContextModel::data(const QModelIndex& index, int role) const {
+    if (!index.isValid()) return QVariant();
+
+    uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+    
+    if (role == Qt::DisplayRole) {
+        QString typeName = getDemangledName(typeid(*obj));
+        std::string instName = obj->GetInstanceName();
+        if (instName.empty()) return typeName;
+        return QString("%1 (%2)").arg(QString::fromStdString(instName)).arg(typeName);
+    }
+    
+    if (role == Qt::EditRole) {
+        return QString::fromStdString(obj->GetInstanceName());
+    }
+    
+    return QVariant();
+}
+
+QVariant ContextModel::headerData(int section, Qt::Orientation orientation, int role) const {
+    if (orientation == Qt::Horizontal && role == Qt::DisplayRole && section == 0) {
+        return "Object Context";
+    }
+    return QVariant();
+}
+
+Qt::ItemFlags ContextModel::flags(const QModelIndex& index) const {
+    if (!index.isValid()) return Qt::NoItemFlags;
+    return Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
+}
+
+bool ContextModel::setData(const QModelIndex& index, const QVariant& value, int role) {
+    if (index.isValid() && role == Qt::EditRole) {
+        uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+        obj->SetInstanceName(value.toString().toStdString());
+        emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
+        return true;
+    }
+    return false;
+}

app/gcompose/src/ContextModel.h

@@ -0,0 +1,28 @@
+#ifndef CONTEXT_MODEL_H
+#define CONTEXT_MODEL_H
+
+#include <QAbstractItemModel>
+#include "Core/ObjectsContext.h"
+
+class ContextModel : public QAbstractItemModel {
+    Q_OBJECT
+public:
+    explicit ContextModel(QObject* parent = nullptr);
+    virtual ~ContextModel();
+
+    void setContext(uLib::ObjectsContext* context);
+
+    QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
+    QModelIndex parent(const QModelIndex& child) const override;
+    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
+    int columnCount(const QModelIndex& parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+    Qt::ItemFlags flags(const QModelIndex& index) const override;
+    bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
+
+private:
+    uLib::ObjectsContext* m_rootContext;
+};
+
+#endif // CONTEXT_MODEL_H

app/gcompose/src/ContextPanel.cpp

@@ -0,0 +1,118 @@
+#include "ContextPanel.h"
+#include "ContextModel.h"
+#include "PropertyWidgets.h"
+#include "PropertiesPanel.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QTreeView>
+#include <QSplitter>
+#include <QList>
+#include <QShortcut>
+#include <QItemSelectionModel>
+
+ContextPanel::ContextPanel(QWidget* parent) 
+    : QWidget(parent)
+    , m_context(nullptr) {
+    this->setObjectName("ContextPanel");
+    this->setAttribute(Qt::WA_StyledBackground);
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar setup
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 5, 0);
+
+    m_titleLabel = new QLabel("Context Panel", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+
+    m_layout->addWidget(m_titleBar);
+
+    m_treeView = new QTreeView(this);
+    m_treeView->setObjectName("ContextTree");
+    m_treeView->setHeaderHidden(false);
+    
+    m_model = new ContextModel(this);
+    m_treeView->setModel(m_model);
+
+    m_splitter = new QSplitter(Qt::Vertical, this);
+    m_splitter->addWidget(m_treeView);
+    
+    m_propertiesPanel = new PropertiesPanel(m_splitter);
+    m_splitter->addWidget(m_propertiesPanel);
+
+    QList<int> sizes;
+    sizes << 400 << 600;
+    m_splitter->setSizes(sizes);
+
+    m_layout->addWidget(m_splitter);
+
+    connect(m_treeView->selectionModel(), &QItemSelectionModel::selectionChanged,
+            this, &ContextPanel::onSelectionChanged);
+
+    auto* deleteShortcut = new QShortcut(QKeySequence::Delete, this);
+    connect(deleteShortcut, &QShortcut::activated, [this]() {
+        auto selectedIndexes = m_treeView->selectionModel()->selectedIndexes();
+        if (selectedIndexes.isEmpty() || !m_context) return;
+        
+        std::vector<uLib::Object*> toRemove;
+        for (const auto& idx : selectedIndexes) {
+            if (idx.column() == 0) {
+                toRemove.push_back(static_cast<uLib::Object*>(idx.internalPointer()));
+            }
+        }
+        
+        for (auto* obj : toRemove) {
+            m_context->RemoveObject(obj);
+        }
+    });
+}
+
+ContextPanel::~ContextPanel() {}
+
+void ContextPanel::setContext(uLib::ObjectsContext* context) {
+    m_context = context;
+    m_model->setContext(context);
+    m_treeView->expandAll();
+}
+
+void ContextPanel::onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected) {
+    uLib::Object* target = nullptr;
+    if (!selected.indexes().isEmpty()) {
+        target = static_cast<uLib::Object*>(selected.indexes().first().internalPointer());
+    }
+
+    emit objectSelected(target);
+    m_propertiesPanel->setObject(target);
+}
+
+void ContextPanel::selectObject(uLib::Object* obj) {
+    if (!obj) {
+        clearSelection();
+        return;
+    }
+    
+    for (int i = 0; i < m_model->rowCount(); ++i) {
+        QModelIndex idx = m_model->index(i, 0);
+        if (idx.internalPointer() == obj) {
+            QSignalBlocker blocker(m_treeView->selectionModel());
+            m_treeView->selectionModel()->select(idx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
+            m_treeView->scrollTo(idx);
+            m_propertiesPanel->setObject(obj); // Explicitly update properties too
+            return;
+        }
+    }
+}
+
+void ContextPanel::clearSelection() {
+    QSignalBlocker blocker(m_treeView->selectionModel());
+    m_treeView->selectionModel()->clearSelection();
+    m_propertiesPanel->setObject(nullptr);
+}

app/gcompose/src/ContextPanel.h

@@ -0,0 +1,45 @@
+#ifndef CONTEXTPANEL_H
+#define CONTEXTPANEL_H
+
+#include <QWidget>
+#include <QItemSelection>
+#include "Core/Object.h"
+
+class QVBoxLayout;
+class QHBoxLayout;
+class QLabel;
+class QTreeView;
+class QSplitter;
+class ContextModel;
+namespace uLib { class ObjectsContext; }
+
+class ContextPanel : public QWidget {
+    Q_OBJECT
+public:
+    ContextPanel(QWidget* parent = nullptr);
+    ~ContextPanel();
+
+    void setContext(uLib::ObjectsContext* context);
+    void selectObject(uLib::Object* obj);
+    void clearSelection();
+
+signals:
+    void objectSelected(uLib::Object* obj);
+
+private slots:
+    void onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);
+
+private:
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    
+    QTreeView* m_treeView;
+    ContextModel* m_model;
+    QSplitter* m_splitter;
+
+    class PropertiesPanel* m_propertiesPanel;
+    uLib::ObjectsContext* m_context;
+};
+
+#endif // CONTEXTPANEL_H

app/gcompose/src/MainPanel.cpp

@@ -0,0 +1,247 @@
+#include "MainPanel.h"
+#include "ViewportPane.h"
+#include "ContextPanel.h"
+#include "PropertiesPanel.h"
+#include "Core/ObjectFactory.h"
+#include "Core/ObjectsContext.h"
+#include "Vtk/vtkObjectsContext.h"
+#include "Vtk/vtkQViewport.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QSplitter>
+#include <QLabel>
+#include <QPushButton>
+#include <QMenu>
+#include <QAction>
+#include <QApplication>
+#include <QFileDialog>
+#include <QFileInfo>
+#include "StyleManager.h"
+#include "Math/VoxImage.h"
+
+MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_mainVtkContext(nullptr) {
+    this->setObjectName("MainPanel");
+    this->setAttribute(Qt::WA_StyledBackground);
+    auto* mainLayout = new QVBoxLayout(this);
+    mainLayout->setContentsMargins(0, 0, 0, 0);
+    mainLayout->setSpacing(0);
+
+    // 1. Top Menu Panel
+    auto* menuPanel = new QWidget(this);
+    menuPanel->setObjectName("MenuPanel");
+    menuPanel->setFixedHeight(36);
+    
+    auto* menuLayout = new QHBoxLayout(menuPanel);
+    menuLayout->setContentsMargins(10, 0, 10, 0);
+    menuLayout->setSpacing(15);
+
+    auto* logo = new QLabel("G-COMPOSE", menuPanel);
+    logo->setObjectName("LogoLabel");
+
+    // File Menu Button
+    auto* btnFile = new QPushButton("File", menuPanel);
+    btnFile->setObjectName("MenuButton");
+    auto* fileMenu = new QMenu(btnFile);
+    fileMenu->addAction("Open", this, &MainPanel::onOpen);
+    fileMenu->addAction("Save", this, &MainPanel::onSave);
+    fileMenu->addAction("Save As", this, &MainPanel::onSaveAs);
+    fileMenu->addAction("Exit", this, &MainPanel::onExit);
+    btnFile->setMenu(fileMenu);
+
+    // Theme Menu Button
+    auto* btnTheme = new QPushButton("Theme", menuPanel);
+    btnTheme->setObjectName("MenuButton");
+    auto* themeMenu = new QMenu(btnTheme);
+    themeMenu->addAction("Dark", this, &MainPanel::onDarkTheme);
+    themeMenu->addAction("Bright", this, &MainPanel::onBrightTheme);
+    btnTheme->setMenu(themeMenu);
+
+    // New Menu Button
+    auto* btnNew = new QPushButton("Add", menuPanel);
+    btnNew->setObjectName("MenuButton");
+    auto* newMenu = new QMenu(btnNew);
+    
+    auto classes = uLib::ObjectFactory::Instance().GetRegisteredClasses();
+    for (const auto& className : classes) {
+        auto* action = newMenu->addAction(QString::fromStdString(className));
+        connect(action, &QAction::triggered, [this, className]() {
+            this->onCreateObject(className);
+        });
+    }
+    btnNew->setMenu(newMenu);
+
+    menuLayout->addWidget(logo);
+    menuLayout->addWidget(btnFile);
+    menuLayout->addWidget(btnNew);
+    menuLayout->addWidget(btnTheme);
+    menuLayout->addStretch();
+
+    mainLayout->addWidget(menuPanel);
+
+    // 2. Central Splitter Area
+    m_rootSplitter = new QSplitter(Qt::Horizontal, this);
+    m_contextPanel = new ContextPanel(m_rootSplitter);
+    m_rootSplitter->addWidget(m_contextPanel);
+    m_rootSplitter->setStretchFactor(0, 0);
+
+    m_firstPane = new ViewportPane(m_rootSplitter);
+    m_rootSplitter->addWidget(m_firstPane);
+    m_rootSplitter->setStretchFactor(1, 1);
+    
+    connect(m_contextPanel, &ContextPanel::objectSelected, [this](uLib::Object* obj) {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            uLib::Vtk::Puppet* puppet = nullptr;
+            if (m_mainVtkContext) {
+                puppet = m_mainVtkContext->GetPuppet(obj);
+            }
+            viewport->SelectPuppet(puppet);
+            // Update the display properties in the viewport pane itself - use the puppet proxy if possible
+            m_firstPane->setObject(puppet ? (uLib::Object*)puppet : obj);
+        } else {
+            m_firstPane->setObject(obj);
+        }
+    });
+
+    // Set initial sizes: Context(250), Viewport(600), Properties(250)
+    QList<int> sizes;
+    sizes << 250 << 600 << 250;
+    m_rootSplitter->setSizes(sizes);
+
+    mainLayout->addWidget(m_rootSplitter, 1);
+}
+
+void MainPanel::setContext(uLib::ObjectsContext* context) {
+    m_context = context;
+    m_contextPanel->setContext(context);
+
+    if (m_mainVtkContext) {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            viewport->RemovePuppet(*m_mainVtkContext);
+        }
+        delete m_mainVtkContext;
+        m_mainVtkContext = nullptr;
+    }
+
+    if (context) {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            m_mainVtkContext = new uLib::Vtk::vtkObjectsContext(context);
+            // viewport->AddPuppet(*m_mainVtkContext); // redundant
+
+            auto syncSelection = [this](uLib::Vtk::Puppet* p) {
+                if (!p) {
+                    m_contextPanel->clearSelection();
+                    m_firstPane->setObject(nullptr);
+                } else {
+                    m_contextPanel->selectObject(p->GetContent());
+                    m_firstPane->setObject(p);
+                }
+            };
+            connect(viewport, &uLib::Vtk::QViewport::puppetSelected, syncSelection);
+
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetAdded, [this](uLib::Vtk::Puppet* p) {
+                if (p) {
+                    auto panes = this->findChildren<ViewportPane*>();
+                    for (auto* pane : panes) {
+                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
+                            vp->AddPuppet(*p);
+                            vp->ZoomAuto();
+                            vp->Render();
+                        }
+                    }
+                }
+            });
+
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetRemoved, [this](uLib::Vtk::Puppet* p) {
+                if (p) {
+                    auto panes = this->findChildren<ViewportPane*>();
+                    for (auto* pane : panes) {
+                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
+                            vp->RemovePuppet(*p);
+                            vp->Render();
+                        }
+                    }
+                }
+            });
+
+            // Add any puppets that were created during m_mainVtkContext's construction to all panes
+            auto panes = this->findChildren<ViewportPane*>();
+            for (auto* obj : context->GetObjects()) {
+                if (auto* p = m_mainVtkContext->GetPuppet(obj)) {
+                    for (auto* pane : panes) {
+                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
+                            vp->AddPuppet(*p);
+                        }
+                    }
+                }
+            }
+
+            uLib::Object::connect(context, &uLib::Object::Updated, [viewport]() {
+                viewport->Render();
+            });
+            viewport->ZoomAuto();
+            viewport->Render();
+        }
+    }
+}
+
+void MainPanel::onCreateObject(const std::string& className) {
+    if (!m_context) return;
+    auto* obj = uLib::ObjectFactory::Instance().Create(className);
+    if (obj) {
+        m_context->AddObject(obj);
+    }
+}
+
+void MainPanel::onOpen() {
+    QString fileName = QFileDialog::getOpenFileName(this, "Open File", "", 
+        "VTK/VTI Images (*.vtk *.vti);;All Files (*.*)");
+    
+    if (fileName.isEmpty()) return;
+
+    QFileInfo info(fileName);
+    QString ext = info.suffix().toLower();
+
+    if (ext == "vti" || ext == "vtk") {
+        auto* obj = uLib::ObjectFactory::Instance().Create("VoxImage");
+        auto* vox = dynamic_cast<uLib::Abstract::VoxImage*>(obj);
+        if (vox) {
+            bool success = false;
+            if (ext == "vti") {
+                success = vox->ImportFromVti(fileName.toStdString().c_str());
+            } else {
+                success = vox->ImportFromVtk(fileName.toStdString().c_str());
+            }
+
+            if (success) {
+                obj->SetInstanceName(info.fileName().toStdString());
+                m_context->AddObject(obj);
+            } else {
+                delete obj;
+            }
+        } else {
+            delete obj;
+        }
+    }
+}
+
+void MainPanel::onSave() {
+    // Placeholder for save logic
+}
+
+void MainPanel::onSaveAs() {
+    // Placeholder for save as logic
+}
+
+void MainPanel::onExit() {
+    qApp->quit();
+}
+
+void MainPanel::onDarkTheme() {
+    StyleManager::applyStyle(qApp, "dark");
+}
+
+void MainPanel::onBrightTheme() {
+    StyleManager::applyStyle(qApp, "bright");
+}
+
+MainPanel::~MainPanel() {}

app/gcompose/src/MainPanel.h

@@ -0,0 +1,46 @@
+#ifndef MAINPANEL_H
+#define MAINPANEL_H
+
+#include <QWidget>
+
+class QSplitter;
+class ViewportPane;
+class ContextPanel;
+class PropertiesPanel;
+
+namespace uLib {
+    class ObjectsContext;
+    namespace Vtk {
+        class vtkObjectsContext;
+    }
+}
+
+class MainPanel : public QWidget {
+    Q_OBJECT
+public:
+    explicit MainPanel(QWidget* parent = nullptr);
+    virtual ~MainPanel();
+
+    void setContext(uLib::ObjectsContext* context);
+    ViewportPane* getFirstPane() const { return m_firstPane; }
+
+private slots:
+    void onOpen();
+    void onSave();
+    void onSaveAs();
+    void onExit();
+
+    void onDarkTheme();
+    void onBrightTheme();
+    
+    void onCreateObject(const std::string& className);
+
+private:
+    QSplitter* m_rootSplitter;
+    ViewportPane* m_firstPane;
+    ContextPanel* m_contextPanel;
+    uLib::ObjectsContext* m_context;
+    uLib::Vtk::vtkObjectsContext* m_mainVtkContext;
+};
+
+#endif // MAINPANEL_H

app/gcompose/src/MainWindow.cpp

@@ -0,0 +1,21 @@
+#include "MainWindow.h"
+#include <QSplitter>
+#include "MainPanel.h"
+#include "Core/ObjectsContext.h"
+
+using namespace uLib;
+
+MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
+    m_panel = new MainPanel(this);
+    setCentralWidget(m_panel);
+
+    setWindowTitle("gcompose - Qt VTK Interface");
+    resize(1200, 800);
+}
+
+MainWindow::~MainWindow() {
+}
+
+void MainWindow::setContext(uLib::ObjectsContext* context) {
+    m_panel->setContext(context);
+}

app/gcompose/src/MainWindow.h

@@ -0,0 +1,29 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QVTKOpenGLNativeWidget.h>
+
+class MainPanel;
+class ViewportPane;
+
+namespace uLib {
+namespace Vtk {
+}
+class ObjectsContext;
+}
+
+class MainWindow : public QMainWindow {
+    Q_OBJECT
+public:
+    MainWindow(QWidget* parent = nullptr);
+    virtual ~MainWindow();
+
+    void setContext(uLib::ObjectsContext* context);
+    MainPanel* getPanel() { return m_panel; }
+
+private:
+    MainPanel* m_panel;
+};
+
+#endif

app/gcompose/src/PropertiesPanel.cpp

@@ -0,0 +1,46 @@
+#include "PropertiesPanel.h"
+#include "PropertyWidgets.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include "Core/Object.h"
+
+PropertiesPanel::PropertiesPanel(QWidget* parent) : QWidget(parent) {
+    this->setObjectName("PropertiesPanel");
+    this->setAttribute(Qt::WA_StyledBackground);
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 5, 0);
+
+    m_titleLabel = new QLabel("Properties", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+
+    m_layout->addWidget(m_titleBar);
+
+    // Editor
+    m_editor = new uLib::Qt::PropertyEditor(this);
+    m_layout->addWidget(m_editor, 1);
+}
+
+void PropertiesPanel::setObject(uLib::Object* obj) {
+    if (obj) {
+        m_titleLabel->setText(QString("Properties: %1 (%2)")
+            .arg(QString::fromStdString(obj->GetInstanceName()))
+            .arg(obj->GetClassName()));
+    } else {
+        m_titleLabel->setText("Properties: (No selection)");
+    }
+    m_editor->setObject(obj);
+}
+
+PropertiesPanel::~PropertiesPanel() {}

app/gcompose/src/PropertiesPanel.h

@@ -0,0 +1,35 @@
+#ifndef PROPERTIES_PANEL_H
+#define PROPERTIES_PANEL_H
+
+#include <QWidget>
+
+namespace uLib {
+    class Object;
+    namespace Qt { class PropertyEditor; }
+}
+
+class QVBoxLayout;
+class QLabel;
+
+/**
+ * @class PropertiesPanel
+ * @brief A panel dedicated to inspecting and editing properties of a selected uLib::Object.
+ */
+class PropertiesPanel : public QWidget {
+    Q_OBJECT
+public:
+    explicit PropertiesPanel(QWidget* parent = nullptr);
+    virtual ~PropertiesPanel();
+
+    /** @brief Sets the object to be inspected. */
+    void setObject(uLib::Object* obj);
+
+private:
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    
+    uLib::Qt::PropertyEditor* m_editor;
+};
+
+#endif // PROPERTIES_PANEL_H

app/gcompose/src/PropertyWidgets.cpp

@@ -0,0 +1,401 @@
+#include "PropertyWidgets.h"
+#include <QSignalBlocker>
+#include <QRegularExpression>
+#include <QRegularExpressionMatch>
+#include <QComboBox>
+#include <QCheckBox>
+#include "Vtk/uLibVtkInterface.h"
+#include "Math/Units.h"
+#include "Math/Dense.h"
+#include "Settings.h"
+
+namespace uLib {
+namespace Qt {
+
+PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent) 
+    : QWidget(parent), m_BaseProperty(prop) {
+    m_Layout = new QHBoxLayout(this);
+    m_Layout->setContentsMargins(4, 2, 4, 2);
+    
+    std::string unit = prop->GetUnits();
+    QString labelText = QString::fromStdString(prop->GetName());
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        if (!pref.empty()) {
+            labelText += " [" + QString::fromStdString(pref) + "]";
+        } else {
+            labelText += " [" + QString::fromStdString(unit) + "]";
+        }
+    }
+    
+    m_Label = new QLabel(labelText, this);
+    m_Label->setMinimumWidth(120);
+    m_Layout->addWidget(m_Label);
+}
+PropertyWidgetBase::~PropertyWidgetBase() {
+    m_Connection.disconnect();
+}
+
+// Helper for unit parsing
+double parseWithUnits(const QString& text, double* factorOut, QString* suffixOut) {
+    static QRegularExpression re("^\\s*([-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?)\\s*(_?[a-zA-Z]+)?\\s*$");
+    QRegularExpressionMatch match = re.match(text);
+    if (!match.hasMatch()) return 0.0;
+
+    double num = match.captured(1).toDouble();
+    QString unit = match.captured(3);
+    double factor = 1.0;
+
+    if (!unit.isEmpty()) {
+        QString u = unit.startsWith('_') ? unit.mid(1) : unit;
+        if (u == "m") factor = CLHEP::meter;
+        else if (u == "cm") factor = CLHEP::centimeter;
+        else if (u == "mm") factor = CLHEP::millimeter;
+        else if (u == "um") factor = CLHEP::micrometer;
+        else if (u == "nm") factor = CLHEP::nanometer;
+        else if (u == "km") factor = CLHEP::kilometer;
+        else if (u == "deg") factor = CLHEP::degree;
+        else if (u == "rad") factor = CLHEP::radian;
+        else if (u == "ns") factor = CLHEP::nanosecond;
+        else if (u == "s") factor = CLHEP::second;
+        else if (u == "ms") factor = CLHEP::millisecond;
+        else if (u == "MeV") factor = CLHEP::megaelectronvolt;
+        else if (u == "eV") factor = CLHEP::electronvolt;
+        else if (u == "keV") factor = CLHEP::kiloelectronvolt;
+        else if (u == "GeV") factor = CLHEP::gigaelectronvolt;
+        else if (u == "TeV") factor = CLHEP::teraelectronvolt;
+        if (suffixOut) *suffixOut = u;
+    } else if (suffixOut) {
+        // Reuse previous suffix if none provided, or empty
+    }
+
+    if (factorOut) *factorOut = factor;
+    return num * factor;
+}
+
+// UnitLineEdit implementation
+UnitLineEdit::UnitLineEdit(QWidget* parent) : QLineEdit(parent), m_Value(0), m_Factor(1.0), m_Suffix(""), m_IsInteger(false) {
+    connect(this, &QLineEdit::editingFinished, this, &UnitLineEdit::onEditingFinished);
+}
+
+void UnitLineEdit::setUnits(const QString& suffix, double factor) {
+    m_Suffix = suffix;
+    m_Factor = factor;
+    updateText();
+}
+
+void UnitLineEdit::setValue(double val) {
+    if (m_Value != val) {
+        m_Value = val;
+        // Suffix heuristic ONLY if it was mm and no explicit unit was given?
+        // Actually, if m_Suffix is empty or we have a specific one, we should respect it.
+        // The original code had a heuristic, but it's better to let property decide.
+        // Let's keep it ONLY if m_Suffix was mm (legacy behavior)
+        if (!m_IsInteger && m_Suffix == "mm" && std::abs(val) >= 1000.0) { m_Suffix = "m"; m_Factor = CLHEP::meter; }
+        updateText();
+    }
+}
+
+void UnitLineEdit::onEditingFinished() {
+    double factor = m_Factor;
+    QString suffix = m_Suffix;
+    double parsedVal = parseWithUnits(text(), &factor, &suffix);
+    if (!suffix.isEmpty()) {
+        m_Suffix = suffix;
+        m_Factor = factor;
+    }
+    if (m_IsInteger) {
+        parsedVal = std::round(parsedVal);
+    }
+    
+    if (m_Value != parsedVal) {
+        m_Value = parsedVal;
+        emit valueManualChanged(m_Value);
+    }
+    updateText();
+}
+
+void UnitLineEdit::updateText() {
+    QSignalBlocker blocker(this);
+    QString s;
+    if (m_IsInteger) {
+        s = QString::number((int)m_Value);
+        if (s.isEmpty()) s = "0";
+    } else {
+        double displayVal = m_Value / m_Factor;
+        s = QString::number(displayVal, 'g', 6);
+        if (!s.contains('.') && !s.contains('e')) {
+            s += ".0";
+        }
+    }
+    setText(s);
+}
+
+void UnitLineEdit::setIntegerOnly(bool integerOnly) {
+    m_IsInteger = integerOnly;
+    updateText();
+}
+
+DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Edit = new UnitLineEdit(this);
+    std::string unit = prop->GetUnits();
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
+    }
+    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_Edit->setValue(m_Prop->Get());
+    });
+}
+
+FloatPropertyWidget::FloatPropertyWidget(Property<float>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Edit = new UnitLineEdit(this);
+    std::string unit = prop->GetUnits();
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
+    }
+    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_Edit->setValue((double)m_Prop->Get());
+    });
+}
+
+IntPropertyWidget::IntPropertyWidget(Property<int>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Edit = new UnitLineEdit(this);
+    m_Edit->setIntegerOnly(true);
+    std::string unit = prop->GetUnits();
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
+    }
+    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_Edit->setValue((double)m_Prop->Get());
+    });
+}
+
+BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_CheckBox = new QCheckBox(this);
+    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](){
+        if (m_CheckBox->isChecked() != m_Prop->Get()) {
+            QSignalBlocker blocker(m_CheckBox);
+            m_CheckBox->setChecked(m_Prop->Get());
+        }
+    });
+}
+BoolPropertyWidget::~BoolPropertyWidget() {}
+
+StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_LineEdit = new QLineEdit(this);
+    m_LineEdit->setText(QString::fromStdString(prop->Get()));
+    m_Layout->addWidget(m_LineEdit, 1);
+    connect(m_LineEdit, &QLineEdit::editingFinished, [this](){
+        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](){
+        if (m_LineEdit->text().toStdString() != m_Prop->Get()) {
+            QSignalBlocker blocker(m_LineEdit);
+            m_LineEdit->setText(QString::fromStdString(m_Prop->Get()));
+        }
+    });
+}
+StringPropertyWidget::~StringPropertyWidget() {}
+
+class GroupHeaderWidget : public QWidget {
+public:
+    GroupHeaderWidget(const QString& name, QWidget* parent = nullptr) : QWidget(parent) {
+        auto* layout = new QVBoxLayout(this);
+        layout->setContentsMargins(0, 8, 0, 4);
+        auto* line = new QFrame(this);
+        line->setFrameShape(QFrame::HLine);
+        line->setFrameShadow(QFrame::Sunken);
+        line->setStyleSheet("color: #555;");
+        layout->addWidget(line);
+        auto* label = new QLabel(name, this);
+        QFont font = label->font();
+        font.setBold(true);
+        font.setPointSize(font.pointSize() + 1);
+        label->setFont(font);
+        label->setStyleSheet("color: #aaa; text-transform: uppercase;");
+        layout->addWidget(label);
+    }
+};
+
+class EnumPropertyWidget : public PropertyWidgetBase {
+    PropertyBase* m_Prop;
+    QComboBox* m_Combo;
+public:
+    EnumPropertyWidget(PropertyBase* prop, QWidget* parent)
+        : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+        m_Combo = new QComboBox(this);
+        const auto& labels = prop->GetEnumLabels();
+        for (const auto& label : labels) {
+            m_Combo->addItem(QString::fromStdString(label));
+        }
+
+        // Get initial value
+        if (auto* p = dynamic_cast<Property<int>*>(prop)) {
+            m_Combo->setCurrentIndex(p->Get());
+            connect(m_Combo, &QComboBox::currentIndexChanged, [p](int index){
+                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](){
+                if (m_Combo->currentIndex() != p->Get()) {
+                    QSignalBlocker blocker(m_Combo);
+                    m_Combo->setCurrentIndex(p->Get());
+                }
+            });
+        }
+
+        m_Layout->addWidget(m_Combo, 1);
+    }
+};
+
+PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(nullptr) {
+    m_MainLayout = new QVBoxLayout(this);
+    m_MainLayout->setContentsMargins(0, 0, 0, 0);
+    m_ScrollArea = new QScrollArea(this);
+    m_ScrollArea->setWidgetResizable(true);
+    m_MainLayout->addWidget(m_ScrollArea);
+    m_Container = new QWidget();
+    m_ContainerLayout = new QVBoxLayout(m_Container);
+    m_ContainerLayout->setAlignment(::Qt::AlignTop);
+    m_ScrollArea->setWidget(m_Container);
+    
+    registerFactory<double>([](PropertyBase* p, QWidget* parent){
+        return new DoublePropertyWidget(static_cast<Property<double>*>(p), parent);
+    });
+    registerFactory<float>([](PropertyBase* p, QWidget* parent){
+        return new FloatPropertyWidget(static_cast<Property<float>*>(p), parent);
+    });
+    registerFactory<int>([](PropertyBase* p, QWidget* parent){
+        return new IntPropertyWidget(static_cast<Property<int>*>(p), parent);
+    });
+    registerFactory<bool>([](PropertyBase* p, QWidget* parent){
+        return new BoolPropertyWidget(static_cast<Property<bool>*>(p), parent);
+    });
+    registerFactory<std::string>([](PropertyBase* p, QWidget* parent){
+        return new StringPropertyWidget(static_cast<Property<std::string>*>(p), parent);
+    });
+    
+    // Register EnumProperty specifically (needs to check type since it holds Property<int> but is EnumProperty)
+    m_Factories[std::type_index(typeid(EnumProperty))] = [](PropertyBase* p, QWidget* parent) {
+        return new EnumPropertyWidget(p, parent);
+    };
+
+    // Vector Registration
+    registerFactory<Vector2i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2i, 2>(static_cast<Property<Vector2i>*>(p), parent); });
+    registerFactory<Vector2f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2f, 2>(static_cast<Property<Vector2f>*>(p), parent); });
+    registerFactory<Vector2d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2d, 2>(static_cast<Property<Vector2d>*>(p), parent); });
+    registerFactory<Vector3i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3i, 3>(static_cast<Property<Vector3i>*>(p), parent); });
+    registerFactory<Vector3f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3f, 3>(static_cast<Property<Vector3f>*>(p), parent); });
+    registerFactory<Vector3d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3d, 3>(static_cast<Property<Vector3d>*>(p), parent); });
+    registerFactory<Vector4i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4i, 4>(static_cast<Property<Vector4i>*>(p), parent); });
+    registerFactory<Vector4f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4f, 4>(static_cast<Property<Vector4f>*>(p), parent); });
+    registerFactory<Vector4d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4d, 4>(static_cast<Property<Vector4d>*>(p), parent); });
+}
+
+PropertyEditor::~PropertyEditor() {}
+
+void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
+    m_Object = obj;
+    clear();
+    if (!obj) return;
+    
+    // Choose which properties to show
+    const std::vector<::uLib::PropertyBase*>* props = &obj->GetProperties();
+    
+    if (displayOnly) {
+        if (auto* puppet = dynamic_cast<::uLib::Vtk::Puppet*>(obj)) {
+            props = &puppet->GetDisplayProperties();
+        } else {
+            // If it's not a puppet but displayOnly is requested, showing nothing or fallback?
+            // Fallback: core properties.
+        }
+    }
+
+    // Group properties by their group string
+    std::map<std::string, std::vector<::uLib::PropertyBase*>> groupedProps;
+    std::vector<std::string> groupOrder;
+    
+    for (auto* prop : *props) {
+        std::string group = prop->GetGroup();
+        if (groupedProps.find(group) == groupedProps.end()) {
+            groupOrder.push_back(group);
+        }
+        groupedProps[group].push_back(prop);
+    }
+
+    for (const auto& groupName : groupOrder) {
+        if (!groupName.empty()) {
+            m_ContainerLayout->addWidget(new GroupHeaderWidget(QString::fromStdString(groupName), m_Container));
+        }
+
+        for (auto* prop : groupedProps[groupName]) {
+            QWidget* widget = nullptr;
+            
+            // Priority 1: Check if it provides enum labels
+            if (!prop->GetEnumLabels().empty()) {
+                widget = new EnumPropertyWidget(prop, m_Container);
+            } else {
+                // Priority 2: Standard factory lookup
+                auto it = m_Factories.find(prop->GetTypeIndex());
+                if (it != m_Factories.end()) {
+                    widget = it->second(prop, m_Container);
+                } else {
+                    // Debug info for unknown types
+                    std::cout << "PropertyEditor: No factory for " << prop->GetQualifiedName() 
+                              << " (Type: " << prop->GetTypeName() << ")" << std::endl;
+
+                    widget = new PropertyWidgetBase(prop, m_Container);
+                    widget->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
+                }
+            }
+
+            if (widget) {
+                if (!groupName.empty()) {
+                    // Indent grouped properties
+                    widget->setContentsMargins(16, 0, 0, 0);
+                }
+                m_ContainerLayout->addWidget(widget);
+            }
+        }
+    }
+    m_ContainerLayout->addStretch(1);
+}
+
+void PropertyEditor::clear() {
+    QLayoutItem* item;
+    while ((item = m_ContainerLayout->takeAt(0)) != nullptr) {
+        delete item->widget();
+        delete item;
+    }
+}
+
+} // namespace Qt
+} // namespace uLib

app/gcompose/src/PropertyWidgets.h

@@ -0,0 +1,188 @@
+#ifndef PROPERTY_WIDGETS_H
+#define PROPERTY_WIDGETS_H
+
+#include <QWidget>
+#include <QLabel>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QLineEdit>
+#include <QCheckBox>
+#include <QScrollArea>
+#include <map>
+#include <typeindex>
+#include <functional>
+
+#include "Core/Property.h"
+#include "Core/Object.h"
+#include "Core/Signal.h"
+#include "Math/Dense.h"
+#include "Settings.h"
+
+namespace uLib {
+namespace Qt {
+
+double parseWithUnits(const QString& text, double* factorOut = nullptr, QString* suffixOut = nullptr);
+
+class PropertyWidgetBase : public QWidget {
+    Q_OBJECT
+public:
+    PropertyWidgetBase(PropertyBase* prop, QWidget* parent = nullptr);
+    virtual ~PropertyWidgetBase();
+    PropertyBase* getProperty() const { return m_BaseProperty; }
+
+protected:
+    PropertyBase* m_BaseProperty;
+    QHBoxLayout* m_Layout;
+    QLabel* m_Label;
+    // Stores the uLib signal connection so it can be disconnected on destruction,
+    // preventing use-after-free when PropertyEditor::clear() deletes widgets.
+    Connection m_Connection;
+};
+
+class UnitLineEdit : public QLineEdit {
+    Q_OBJECT
+public:
+    UnitLineEdit(QWidget* parent = nullptr);
+    void setValue(double val);
+    void setUnits(const QString& suffix, double factor = 1.0);
+    double getValue() const { return m_Value; }
+    void setIntegerOnly(bool b);
+
+signals:
+    void valueManualChanged(double val);
+
+private slots:
+    void onEditingFinished();
+
+private:
+    void updateText();
+    double m_Value;
+    double m_Factor;
+    QString m_Suffix;
+    bool m_IsInteger;
+};
+
+class DoublePropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    DoublePropertyWidget(Property<double>* prop, QWidget* parent = nullptr);
+private:
+    Property<double>* m_Prop;
+    UnitLineEdit* m_Edit;
+};
+
+class FloatPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    FloatPropertyWidget(Property<float>* prop, QWidget* parent = nullptr);
+private:
+    Property<float>* m_Prop;
+    UnitLineEdit* m_Edit;
+};
+
+class IntPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    IntPropertyWidget(Property<int>* prop, QWidget* parent = nullptr);
+private:
+    Property<int>* m_Prop;
+    UnitLineEdit* m_Edit;
+};
+
+template <typename VecT, int Size>
+class VectorPropertyWidget : public PropertyWidgetBase {
+public:
+    VectorPropertyWidget(Property<VecT>* prop, QWidget* parent = nullptr)
+        : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+        
+        std::string unit = prop->GetUnits();
+        double factor = 1.0;
+        QString prefSuffix;
+        if (!unit.empty()) {
+            auto dim = Settings::Instance().IdentifyDimension(unit);
+            std::string pref = Settings::Instance().GetPreferredUnit(dim);
+            factor = Settings::Instance().GetUnitFactor(pref);
+            prefSuffix = QString::fromStdString(pref);
+        }
+
+        for (int i = 0; i < Size; ++i) {
+            m_Edits[i] = new UnitLineEdit(this);
+            if (std::is_integral<typename VecT::Scalar>::value) {
+                m_Edits[i]->setIntegerOnly(true);
+            }
+            if (!prefSuffix.isEmpty()) {
+               m_Edits[i]->setUnits(prefSuffix, factor);
+            }
+            m_Layout->addWidget(m_Edits[i], 1);
+            
+            connect(m_Edits[i], &UnitLineEdit::valueManualChanged, [this, i](double val){
+                VecT v = m_Prop->Get();
+                v(i) = (typename VecT::Scalar)val;
+                if (m_Prop->Get() != v) m_Prop->Set(v);
+            });
+        }
+        updateEdits();
+        m_Connection = uLib::Object::connect(m_Prop, &Property<VecT>::PropertyChanged, [this](){
+            updateEdits();
+        });
+    }
+    ~VectorPropertyWidget() { m_Connection.disconnect(); }
+
+private:
+    void updateEdits() {
+        VecT v = m_Prop->Get();
+        for (int i = 0; i < Size; ++i) {
+            if (!m_Edits[i]->hasFocus()) {
+                m_Edits[i]->setValue((double)v(i));
+            }
+        }
+    }
+    Property<VecT>* m_Prop;
+    UnitLineEdit* m_Edits[Size];
+};
+
+class BoolPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    BoolPropertyWidget(Property<bool>* prop, QWidget* parent = nullptr);
+    virtual ~BoolPropertyWidget();
+private:
+    Property<bool>* m_Prop;
+    QCheckBox* m_CheckBox;
+};
+
+class StringPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    StringPropertyWidget(Property<std::string>* prop, QWidget* parent = nullptr);
+    virtual ~StringPropertyWidget();
+private:
+    Property<std::string>* m_Prop;
+    QLineEdit* m_LineEdit;
+};
+
+class PropertyEditor : public QWidget {
+    Q_OBJECT
+public:
+    PropertyEditor(QWidget* parent = nullptr);
+    virtual ~PropertyEditor();
+    void setObject(uLib::Object* obj, bool displayOnly = false);
+    template<typename T>
+    void registerFactory(std::function<QWidget*(PropertyBase*, QWidget*)> factory) {
+        m_Factories[std::type_index(typeid(T))] = factory;
+    }
+
+private:
+    void clear();
+    uLib::Object* m_Object;
+    QVBoxLayout* m_MainLayout;
+    QScrollArea* m_ScrollArea;
+    QWidget* m_Container;
+    QVBoxLayout* m_ContainerLayout;
+    std::map<std::type_index, std::function<QWidget*(PropertyBase*, QWidget*)>> m_Factories;
+};
+
+} // namespace Qt
+} // namespace uLib
+
+#endif // PROPERTY_WIDGETS_H

app/gcompose/src/QViewportPane.cpp

@@ -0,0 +1,231 @@
+#include "QViewportPane.h"
+#include <Vtk/vtkQViewport.h>
+#include <Root/QCanvas.h>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QToolButton>
+#include <QMenu>
+#include <QAction>
+#include <QSplitter>
+#include <vtkCamera.h>
+#include "PropertyWidgets.h"
+#include <QSignalBlocker>
+
+QViewportPane::QViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullptr) {
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar setup
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 0, 0);
+
+    m_titleLabel = new QLabel("Viewport", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    
+    m_toggleBtn = new QPushButton("Display", m_titleBar);
+    m_toggleBtn->setCheckable(true);
+    m_toggleBtn->setFixedSize(60, 18);
+    m_toggleBtn->setObjectName("DisplayToggleBtn");
+
+    auto* closeBtn = new QToolButton(m_titleBar);
+    closeBtn->setObjectName("PaneCloseButton");
+    closeBtn->setText("X");
+    closeBtn->setFixedSize(18, 18);
+
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+    titleLayout->addWidget(m_toggleBtn);
+    titleLayout->addSpacing(5);
+    titleLayout->addWidget(closeBtn);
+
+    m_layout->addWidget(m_titleBar);
+
+    // Main horizontal container for viewport and display panel
+    QWidget* mainArea = new QWidget(this);
+    QHBoxLayout* hLayout = new QHBoxLayout(mainArea);
+    hLayout->setContentsMargins(0, 0, 0, 0);
+    hLayout->setSpacing(0);
+    m_layout->addWidget(mainArea);
+
+    // Viewport will be added here via setViewport
+    m_viewport = new uLib::Vtk::QViewport(mainArea);
+    hLayout->addWidget(m_viewport);
+
+    // Display Panel (Overlay/Slide-out)
+    m_displayPanel = new QFrame(mainArea);
+    m_displayPanel->setObjectName("DisplayPropertiesPanel");
+    m_displayPanel->setFixedWidth(250);
+    m_displayPanel->hide();
+    
+    QVBoxLayout* panelLayout = new QVBoxLayout(m_displayPanel);
+    panelLayout->setContentsMargins(5, 5, 5, 5);
+    
+    QLabel* panelHeader = new QLabel("Display Properties", m_displayPanel);
+    panelHeader->setStyleSheet("font-weight: bold; padding: 5px;");
+    panelLayout->addWidget(panelHeader);
+
+    m_displayEditor = new uLib::Qt::PropertyEditor(m_displayPanel);
+    panelLayout->addWidget(m_displayEditor);
+    
+    hLayout->addWidget(m_displayPanel);
+
+    connect(m_toggleBtn, &QPushButton::toggled, this, &QViewportPane::toggleDisplayPanel);
+    connect(m_titleBar, &QWidget::customContextMenuRequested, this, &QViewportPane::showContextMenu);
+    connect(closeBtn, &QToolButton::clicked, this, &QViewportPane::onCloseRequested);
+
+    m_titleBar->setContextMenuPolicy(Qt::CustomContextMenu);
+}
+
+void QViewportPane::toggleDisplayPanel() {
+    m_displayPanel->setVisible(m_toggleBtn->isChecked());
+}
+
+void QViewportPane::setObject(uLib::Object* obj) {
+    m_displayEditor->setObject(obj, true);
+    // Auto-show panel if it's a puppet and we want to highlight this feature?
+    // User asked for "hiding panel", so maybe we don't auto-show.
+}
+
+void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
+    if (m_viewport) {
+        m_viewport->parentWidget()->layout()->removeWidget(m_viewport);
+        delete m_viewport;
+    }
+    m_viewport = viewport;
+    m_titleLabel->setText(title);
+
+    m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    auto* mainAreaLayout = static_cast<QHBoxLayout*>(m_displayPanel->parentWidget()->layout());
+    mainAreaLayout->insertWidget(0, m_viewport);
+}
+
+
+QViewportPane::~QViewportPane() {}
+
+void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
+    if (m_viewport) {
+        m_layout->removeWidget(m_viewport);
+        delete m_viewport;
+    }
+    m_viewport = viewport;
+    m_titleLabel->setText(title);
+
+    m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    m_layout->addWidget(m_viewport);
+}
+
+void QViewportPane::addVtkViewport() {
+    auto* viewport = new uLib::Vtk::QViewport(this);
+    setViewport(viewport, "VTK Viewport");
+}
+
+void QViewportPane::addRootCanvas() {
+    auto* canvas = new uLib::Root::QCanvas(this);
+    setViewport(canvas, "ROOT Canvas");
+}
+
+void QViewportPane::onCloseRequested() {
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(parentWidget());
+    if (parentSplitter && parentSplitter->count() > 1) {
+        deleteLater();
+    } else {
+        // Can't close the last viewport in the splitter safely. Re-initialize to default VTK canvas.
+        addVtkViewport();
+    }
+}
+
+void QViewportPane::showContextMenu(const QPoint& pos) {
+    QMenu menu(this);
+    QAction* hSplit = menu.addAction("H split");
+    QAction* vSplit = menu.addAction("V split");
+    menu.addSeparator();
+    
+    bool isVtk = (qobject_cast<uLib::Vtk::QViewport*>(m_viewport) != nullptr);
+
+    QAction* changeType = menu.addAction(isVtk ? "Change to ROOT Canvas" : "Change to VTK Viewport");
+
+    QAction* selected = menu.exec(m_titleBar->mapToGlobal(pos));
+    
+    if (selected == hSplit) {
+        AttemptSplit(Qt::Horizontal);
+    } else if (selected == vSplit) {
+        AttemptSplit(Qt::Vertical);
+    } else if (selected == changeType) {
+        if (isVtk) {
+            addRootCanvas();
+        } else {
+            addVtkViewport();
+        }
+    }
+}
+
+void QViewportPane::AttemptSplit(Qt::Orientation orientation) {
+    QWidget* p = parentWidget();
+    if (!p) return;
+
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(p);
+    if (!parentSplitter) return;
+
+    QViewportPane* newPane = new QViewportPane();
+
+    // 1. Synchronize viewport content and camera (VTK Viewport only for now)
+    auto* currentVtk = qobject_cast<uLib::Vtk::QViewport*>(m_viewport);
+    if (currentVtk) {
+        auto* newVtk = qobject_cast<uLib::Vtk::QViewport*>(newPane->currentViewport());
+        if (newVtk) {
+            // Copy puppets
+            for (auto* puppet : currentVtk->getPuppets()) {
+                newVtk->AddPuppet(*puppet);
+            }
+            // Copy camera
+            if (currentVtk->GetRenderer() && newVtk->GetRenderer()) {
+                vtkCamera* currentCam = currentVtk->GetRenderer()->GetActiveCamera();
+                vtkCamera* newCam = newVtk->GetRenderer()->GetActiveCamera();
+                if (currentCam && newCam) {
+                    newCam->DeepCopy(currentCam);
+                }
+            }
+            // Sync grid visible and axis
+            newVtk->SetGridVisible(currentVtk->GetGridVisible());
+            newVtk->SetGridAxis(currentVtk->GetGridAxis());
+        }
+    }
+
+    // 2. Adjust for ROOT Canvas if that was the active view
+    bool isRoot = (qobject_cast<uLib::Root::QCanvas*>(m_viewport) != nullptr);
+    if (isRoot) {
+        newPane->addRootCanvas();
+    }
+
+    if (parentSplitter->orientation() == orientation) {
+        int index = parentSplitter->indexOf(this);
+        QList<int> sizes = parentSplitter->sizes();
+        int currentSize = sizes.value(index, 0);
+        int half = currentSize / 2;
+        sizes[index] = half;
+        sizes.insert(index + 1, currentSize - half);
+        
+        parentSplitter->insertWidget(index + 1, newPane);
+        parentSplitter->setSizes(sizes);
+    } else {
+        int index = parentSplitter->indexOf(this);
+        QList<int> parentSizes = parentSplitter->sizes();
+        
+        QSplitter* newSplitter = new QSplitter(orientation);
+        newSplitter->addWidget(this);
+        newSplitter->addWidget(newPane);
+        
+        QList<int> subSizes;
+        subSizes << 500 << 500;
+        newSplitter->setSizes(subSizes);
+        
+        parentSplitter->insertWidget(index, newSplitter);
+        parentSplitter->setSizes(parentSizes);
+    }
+}

app/gcompose/src/QViewportPane.h

@@ -0,0 +1,50 @@
+#ifndef QVIEWPORTPANE_H
+#define QVIEWPORTPANE_H
+
+#include <QWidget>
+#include <QFrame>
+#include <QPushButton>
+
+namespace uLib {
+    class Object;
+    namespace Qt { class PropertyEditor; }
+}
+
+class QVBoxLayout;
+class QLabel;
+
+class QViewportPane : public QWidget {
+    Q_OBJECT
+public:
+    explicit QViewportPane(QWidget* parent = nullptr);
+    virtual ~QViewportPane();
+
+    void addVtkViewport();
+    void addRootCanvas();
+
+    QWidget* currentViewport() const { return m_viewport; }
+    
+    /** @brief Update the display properties for the given object. */
+    void setObject(uLib::Object* obj);
+
+private slots:
+    void onCloseRequested();
+    void showContextMenu(const QPoint& pos);
+    void toggleDisplayPanel();
+
+private:
+    void AttemptSplit(Qt::Orientation orientation);
+    void setViewport(QWidget* viewport, const QString& title);
+
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    QWidget* m_viewport;
+
+    // Display Properties Overlay
+    QFrame* m_displayPanel;
+    uLib::Qt::PropertyEditor* m_displayEditor;
+    QPushButton* m_toggleBtn;
+};
+
+#endif // QVIEWPORTPANE_H

app/gcompose/src/Settings.h

@@ -0,0 +1,75 @@
+#ifndef GCOMPOSE_SETTINGS_H
+#define GCOMPOSE_SETTINGS_H
+
+#include <string>
+#include <map>
+#include "Math/Units.h"
+
+namespace uLib {
+namespace Qt {
+
+class Settings {
+public:
+    static Settings& Instance() {
+        static Settings instance;
+        return instance;
+    }
+
+    enum Dimension {
+        Length,
+        Angle,
+        Energy,
+        Time,
+        Dimensionless
+    };
+
+    void SetPreferredUnit(Dimension dim, const std::string& unit) {
+        m_PreferredUnits[dim] = unit;
+    }
+
+    std::string GetPreferredUnit(Dimension dim) const {
+        auto it = m_PreferredUnits.find(dim);
+        if (it != m_PreferredUnits.end()) return it->second;
+        
+        switch(dim) {
+            case Length: return "mm";
+            case Angle: return "deg";
+            case Energy: return "MeV";
+            case Time: return "ns";
+            default: return "";
+        }
+    }
+
+    double GetUnitFactor(const std::string& unit) const {
+        if (unit == "m") return CLHEP::meter;
+        if (unit == "cm") return CLHEP::centimeter;
+        if (unit == "mm") return CLHEP::millimeter;
+        if (unit == "um") return CLHEP::micrometer;
+        if (unit == "deg") return CLHEP::degree;
+        if (unit == "rad") return CLHEP::radian;
+        if (unit == "ns") return CLHEP::nanosecond;
+        if (unit == "s") return CLHEP::second;
+        if (unit == "ms") return CLHEP::millisecond;
+        if (unit == "MeV") return CLHEP::megaelectronvolt;
+        if (unit == "GeV") return CLHEP::gigaelectronvolt;
+        if (unit == "eV") return CLHEP::electronvolt;
+        return 1.0;
+    }
+
+    Dimension IdentifyDimension(const std::string& unit) const {
+        if (unit == "m" || unit == "cm" || unit == "mm" || unit == "um" || unit == "nm") return Length;
+        if (unit == "deg" || unit == "rad") return Angle;
+        if (unit == "MeV" || unit == "GeV" || unit == "eV" || unit == "keV" || unit == "TeV") return Energy;
+        if (unit == "ns" || unit == "s" || unit == "ms" || unit == "us") return Time;
+        return Dimensionless;
+    }
+
+private:
+    Settings() {}
+    std::map<Dimension, std::string> m_PreferredUnits;
+};
+
+} // namespace Qt
+} // namespace uLib
+
+#endif

app/gcompose/src/StyleManager.cpp

@@ -0,0 +1,98 @@
+#include "StyleManager.h"
+#include <QApplication>
+
+static const QString DARK_THEME = R"(
+QWidget#MenuPanel { background-color: #2b2b2b; border-bottom: 1px solid #111; }
+QLabel#LogoLabel { font-weight: bold; color: #0078d7; font-size: 14px; letter-spacing: 1px; }
+QPushButton#MenuButton { background: transparent; color: #ccc; border: none; padding: 5px 10px; }
+QPushButton#MenuButton:hover { background: #3c3c3c; color: white; border-radius: 4px; }
+QWidget#PaneTitleBar { background-color: #333; color: white; border-bottom: 2px solid #222; }
+QLabel#TitleLabel { font-weight: bold; margin-left: 2px; }
+QToolButton#PaneCloseButton { border: none; font-weight: bold; background: transparent; color: #ccc; }
+QToolButton#PaneCloseButton:hover { color: white; background: #c42b1c; }
+
+/* Global & Panel Backgrounds */
+QMainWindow, QWidget#MainPanel { background-color: #1e1e1e; }
+QWidget#DisplayPropertiesPanel, QWidget#PropertiesPanel, QWidget#ContextPanel { background-color: #252526; border-left: 1px solid #3e3e42; }
+QPushButton#DisplayToggleBtn { background-color: #333337; border: 1px solid #3e3e42; border-radius: 2px; color: #f1f1f1; font-size: 11px; }
+QPushButton#DisplayToggleBtn:checked { background-color: #0078d7; color: white; border-color: #005a9e; font-weight: bold; }
+QPushButton#DisplayToggleBtn:hover { border-color: #0078d7; }
+
+QScrollArea { border: none; background: transparent; }
+QScrollArea > QWidget > QWidget { background: transparent; }
+
+/* Property Widgets Styling */
+QLabel { color: #cccccc; }
+QDoubleSpinBox, QSpinBox, QLineEdit { background: #3c3c3c; color: #f1f1f1; border: 1px solid #3e3e42; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
+QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus { border-color: #0078d7; }
+QCheckBox { color: #cccccc; spacing: 5px; }
+QCheckBox::indicator { width: 14px; height: 14px; border: 1px solid #3e3e42; background: #333337; border-radius: 2px; }
+QCheckBox::indicator:checked { background: #0078d7; border-color: #005a9e; }
+QCheckBox::indicator:hover { border-color: #0078d7; }
+
+QMenu { background-color: #2b2b2b; color: white; border: 1px solid #111; }
+QMenu::item:selected { background-color: #3c3c3c; }
+QTreeView#ContextTree { background-color: #1e1e1e; color: #ccc; border: none; }
+QTreeView#ContextTree::item:hover { background-color: #2a2d2e; }
+QTreeView#ContextTree::item:selected { background-color: #094771; color: white; }
+QHeaderView::section { background-color: #252526; color: #ccc; border: 1px solid #323233; padding: 4px; }
+
+/* ScrollBars */
+QScrollBar:vertical { background: #1e1e1e; width: 12px; margin: 0px; }
+QScrollBar::handle:vertical { background: #3e3e42; min-height: 20px; border-radius: 6px; margin: 2px; }
+QScrollBar::handle:vertical:hover { background: #505050; }
+QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
+)";
+
+static const QString BRIGHT_THEME = R"(
+QWidget#MenuPanel { background-color: #f3f3f3; border-bottom: 1px solid #ccc; }
+QLabel#LogoLabel { font-weight: bold; color: #005a9e; font-size: 14px; letter-spacing: 1px; }
+QPushButton#MenuButton { background: transparent; color: #333; border: none; padding: 5px 10px; }
+QPushButton#MenuButton:hover { background: #e5e5e5; color: black; border-radius: 4px; }
+QWidget#PaneTitleBar { background-color: #eeeeee; color: black; border-bottom: 2px solid #ddd; }
+QLabel#TitleLabel { font-weight: bold; margin-left: 2px; }
+QToolButton#PaneCloseButton { border: none; font-weight: bold; background: transparent; color: #666; }
+QToolButton#PaneCloseButton:hover { color: white; background: #e81123; }
+
+/* Global & Panel Backgrounds */
+QMainWindow, QWidget#MainPanel { background-color: #f3f3f3; }
+QWidget#DisplayPropertiesPanel, QWidget#PropertiesPanel, QWidget#ContextPanel { background-color: #ffffff; border-left: 1px solid #cccccc; }
+QPushButton#DisplayToggleBtn { background-color: #ffffff; border: 1px solid #cccccc; border-radius: 2px; color: #333; font-size: 11px; }
+QPushButton#DisplayToggleBtn:checked { background-color: #0078d7; color: white; border-color: #005a9e; font-weight: bold; }
+QPushButton#DisplayToggleBtn:hover { border-color: #0078d7; }
+
+QScrollArea { border: none; background: transparent; }
+QScrollArea > QWidget > QWidget { background: transparent; }
+
+/* Property Widgets Styling */
+QLabel { color: #333333; }
+QDoubleSpinBox, QSpinBox, QLineEdit { background: #ffffff; color: #333333; border: 1px solid #cccccc; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
+QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus { border-color: #0078d7; }
+QCheckBox { color: #333333; spacing: 5px; }
+QCheckBox::indicator { width: 14px; height: 14px; border: 1px solid #cccccc; background: #ffffff; border-radius: 2px; }
+QCheckBox::indicator:checked { background: #0078d7; border-color: #005a9e; }
+QCheckBox::indicator:hover { border-color: #0078d7; }
+
+QMenu { background-color: #f3f3f3; color: black; border: 1px solid #ccc; }
+QMenu::item:selected { background-color: #d0d0d0; }
+QTreeView#ContextTree { background-color: #ffffff; color: #333; border: none; }
+QTreeView#ContextTree::item:hover { background-color: #f2f2f2; }
+QTreeView#ContextTree::item:selected { background-color: #0078d7; color: white; }
+QHeaderView::section { background-color: #f3f3f3; color: #333; border: 1px solid #ccc; padding: 4px; }
+
+/* ScrollBars */
+QScrollBar:vertical { background: #ffffff; width: 12px; margin: 0px; }
+QScrollBar::handle:vertical { background: #cccccc; min-height: 20px; border-radius: 6px; margin: 2px; }
+QScrollBar::handle:vertical:hover { background: #aaaaaa; }
+QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
+)";
+
+void StyleManager::applyStyle(QApplication* app, const QString& themeName) {
+    if (!app) return;
+    
+    if (themeName == "bright") {
+        app->setStyleSheet(BRIGHT_THEME);
+    } else {
+        app->setStyleSheet(DARK_THEME); // default
+    }
+}

app/gcompose/src/StyleManager.h

@@ -0,0 +1,13 @@
+#ifndef STYLEMANAGER_H
+#define STYLEMANAGER_H
+
+#include <QString>
+
+class QApplication;
+
+class StyleManager {
+public:
+    static void applyStyle(QApplication* app, const QString& themeName);
+};
+
+#endif // STYLEMANAGER_H

app/gcompose/src/ViewportPane.cpp

@@ -0,0 +1,187 @@
+#include "ViewportPane.h"
+#include <Vtk/vtkQViewport.h>
+#include <Root/QCanvas.h>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QToolButton>
+#include <QMenu>
+#include <QAction>
+#include <QSplitter>
+#include <vtkCamera.h>
+#include "PropertyWidgets.h"
+#include <QSignalBlocker>
+
+ViewportPane::ViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullptr) {
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar setup
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 0, 0);
+
+    m_titleLabel = new QLabel("Viewport", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    
+    m_toggleBtn = new QPushButton("Display", m_titleBar);
+    m_toggleBtn->setCheckable(true);
+    m_toggleBtn->setFixedSize(60, 18);
+    m_toggleBtn->setObjectName("DisplayToggleBtn");
+
+    auto* closeBtn = new QToolButton(m_titleBar);
+    closeBtn->setObjectName("PaneCloseButton");
+    closeBtn->setText("X");
+    closeBtn->setFixedSize(18, 18);
+
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+    titleLayout->addWidget(m_toggleBtn);
+    titleLayout->addSpacing(5);
+    titleLayout->addWidget(closeBtn);
+
+    m_layout->addWidget(m_titleBar);
+
+    // Main area with splitter for viewport and display panel
+    m_areaSplitter = new QSplitter(Qt::Horizontal, this);
+    m_areaSplitter->setObjectName("ViewportAreaSplitter");
+    m_layout->addWidget(m_areaSplitter, 1);
+
+    // Viewport will be added here via setViewport
+    m_viewport = new uLib::Vtk::QViewport(m_areaSplitter);
+    m_areaSplitter->addWidget(m_viewport);
+
+    // Display Panel (Overlay/Slide-out)
+    m_displayPanel = new QFrame(m_areaSplitter);
+    m_displayPanel->setObjectName("DisplayPropertiesPanel");
+    m_displayPanel->setMinimumWidth(150);
+    m_displayPanel->hide();
+    
+    m_areaSplitter->addWidget(m_displayPanel);
+    m_areaSplitter->setStretchFactor(0, 1);
+    m_areaSplitter->setStretchFactor(1, 0);
+    
+    QVBoxLayout* panelLayout = new QVBoxLayout(m_displayPanel);
+    panelLayout->setContentsMargins(5, 5, 5, 5);
+    
+    QLabel* panelHeader = new QLabel("Display Properties", m_displayPanel);
+    panelHeader->setStyleSheet("font-weight: bold; padding: 5px;");
+    panelLayout->addWidget(panelHeader);
+
+    m_displayEditor = new uLib::Qt::PropertyEditor(m_displayPanel);
+    panelLayout->addWidget(m_displayEditor);
+
+    connect(m_toggleBtn, &QPushButton::toggled, this, &ViewportPane::toggleDisplayPanel);
+    connect(m_titleBar, &QWidget::customContextMenuRequested, this, &ViewportPane::showContextMenu);
+    connect(closeBtn, &QToolButton::clicked, this, &ViewportPane::onCloseRequested);
+
+    m_titleBar->setContextMenuPolicy(Qt::CustomContextMenu);
+}
+
+ViewportPane::~ViewportPane() {}
+
+void ViewportPane::toggleDisplayPanel() {
+    bool visible = m_toggleBtn->isChecked();
+    m_displayPanel->setVisible(visible);
+    if (visible && m_areaSplitter->sizes().value(1, 0) == 0) {
+        QList<int> sizes = m_areaSplitter->sizes();
+        int total = sizes[0] + sizes[1];
+        sizes[1] = 250;
+        sizes[0] = total - 250;
+        m_areaSplitter->setSizes(sizes);
+    }
+}
+
+void ViewportPane::setObject(uLib::Object* obj) {
+    m_displayEditor->setObject(obj, true);
+    
+    // Check if the object is a Puppet (meaning it has display properties)
+    bool isPuppet = (dynamic_cast<::uLib::Vtk::Puppet*>(obj) != nullptr);
+    
+    // Only show the "Display" toggle button if it's a puppet
+    m_toggleBtn->setVisible(isPuppet);
+    
+    // If it's a puppet, we might want to keep the panel state if it was already open,
+    // or if it's NOT a puppet, definitely hide the toggle and panel.
+    if (!isPuppet) {
+        m_toggleBtn->setChecked(false);
+        m_displayPanel->hide();
+    }
+}
+
+void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
+    if (m_viewport) {
+        delete m_viewport;
+    }
+    m_viewport = viewport;
+    m_titleLabel->setText(title);
+
+    m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    m_areaSplitter->insertWidget(0, m_viewport);
+    m_areaSplitter->setStretchFactor(0, 1);
+}
+
+void ViewportPane::addVtkViewport() {
+    auto* viewport = new uLib::Vtk::QViewport(this);
+    setViewport(viewport, "VTK Viewport");
+}
+
+void ViewportPane::addRootCanvas() {
+    auto* canvas = new uLib::Root::QCanvas(this);
+    setViewport(canvas, "ROOT Canvas");
+}
+
+void ViewportPane::onCloseRequested() {
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(parentWidget());
+    if (parentSplitter && parentSplitter->count() > 1) {
+        deleteLater();
+    } else {
+        addVtkViewport();
+    }
+}
+
+void ViewportPane::showContextMenu(const QPoint& pos) {
+    QMenu menu(this);
+    QAction* hSplit = menu.addAction("H split");
+    QAction* vSplit = menu.addAction("V split");
+    menu.addSeparator();
+    bool isVtk = (qobject_cast<uLib::Vtk::QViewport*>(m_viewport) != nullptr);
+    QAction* changeType = menu.addAction(isVtk ? "Change to ROOT Canvas" : "Change to VTK Viewport");
+    QAction* selected = menu.exec(m_titleBar->mapToGlobal(pos));
+    if (selected == hSplit) AttemptSplit(Qt::Horizontal);
+    else if (selected == vSplit) AttemptSplit(Qt::Vertical);
+    else if (selected == changeType) isVtk ? addRootCanvas() : addVtkViewport();
+}
+
+void ViewportPane::AttemptSplit(Qt::Orientation orientation) {
+    QWidget* p = parentWidget();
+    if (!p) return;
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(p);
+    if (!parentSplitter) return;
+    ViewportPane* newPane = new ViewportPane();
+    if (parentSplitter->orientation() == orientation) {
+        int index = parentSplitter->indexOf(this);
+        QList<int> sizes = parentSplitter->sizes();
+        int currentSize = sizes.value(index, 0);
+        int half = currentSize / 2;
+        sizes[index] = half;
+        sizes.insert(index + 1, currentSize - half);
+        parentSplitter->insertWidget(index + 1, newPane);
+        parentSplitter->setSizes(sizes);
+    } else {
+        int index = parentSplitter->indexOf(this);
+        QList<int> parentSizes = parentSplitter->sizes();
+        QSplitter* newSplitter = new QSplitter(orientation);
+        newSplitter->addWidget(this);
+        newSplitter->addWidget(newPane);
+        QList<int> subSizes;
+        subSizes << 500 << 500;
+        newSplitter->setSizes(subSizes);
+        parentSplitter->insertWidget(index, newSplitter);
+        parentSplitter->setSizes(parentSizes);
+    }
+}

app/gcompose/src/ViewportPane.h

@@ -0,0 +1,52 @@
+#ifndef VIEWPORTPANE_H
+#define VIEWPORTPANE_H
+
+#include <QWidget>
+#include <QFrame>
+#include <QPushButton>
+
+namespace uLib {
+    class Object;
+    namespace Qt { class PropertyEditor; }
+}
+
+class QSplitter;
+class QVBoxLayout;
+class QLabel;
+
+class ViewportPane : public QWidget {
+    Q_OBJECT
+public:
+    explicit ViewportPane(QWidget* parent = nullptr);
+    virtual ~ViewportPane();
+
+    void addVtkViewport();
+    void addRootCanvas();
+
+    QWidget* currentViewport() const { return m_viewport; }
+    
+    /** @brief Update the display properties for the given object. */
+    void setObject(uLib::Object* obj);
+
+private slots:
+    void onCloseRequested();
+    void showContextMenu(const QPoint& pos);
+    void toggleDisplayPanel();
+
+private:
+    void AttemptSplit(Qt::Orientation orientation);
+    void setViewport(QWidget* viewport, const QString& title);
+
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    QSplitter* m_areaSplitter;
+    QWidget* m_viewport;
+
+    // Display Properties Overlay
+    QFrame* m_displayPanel;
+    uLib::Qt::PropertyEditor* m_displayEditor;
+    QPushButton* m_toggleBtn;
+};
+
+#endif // VIEWPORTPANE_H

app/gcompose/src/main.cpp

@@ -0,0 +1,55 @@
+#include <QApplication>
+#include "MainWindow.h"
+#include "MainPanel.h"
+#include "ViewportPane.h"
+#include "StyleManager.h"
+
+#include "Math/ContainerBox.h"
+#include <HEP/Geant/Scene.h>
+#include "HEP/Detectors/DetectorChamber.h"
+#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
+
+#include <Vtk/Math/vtkContainerBox.h>
+#include <Vtk/vtkQViewport.h>
+
+#include "Core/ObjectsContext.h"
+
+#include <vtkSmartPointer.h>
+#include <vtkCubeSource.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkActor.h>
+#include <vtkRenderer.h>
+
+
+#include "Math/Units.h"
+#include <iostream>
+
+using namespace uLib;
+using namespace uLib::literals;
+
+int main(int argc, char** argv) {
+    QApplication app(argc, argv);
+    StyleManager::applyStyle(&app, "dark");
+    std::cout << "Starting gcompose Qt application..." << std::endl;
+
+    // ContainerBox world_box(Vector3f(1, 1, 1));
+    // world_box.Scale(Vector3f(2_mm, 2_mm, 2_mm));
+    // world_box.SetPosition(Vector3f(-1_mm, -1_mm, -1_mm));    
+
+    // Geant::Scene scene;
+    // scene.ConstructWorldBox(world_box.GetSize(), "G4_AIR");
+    // scene.Initialize();
+
+    uLib::ObjectsContext globalContext;
+    // globalContext.AddObject(&world_box);
+    // globalContext.AddObject(&scene);
+
+    // 2. Initialize MainWindow (contains embedded VTK QViewport)
+    MainWindow window;
+    window.setContext(&globalContext);
+    
+    std::cout << "Geant4 and VTK scenes are ready." << std::endl;
+    
+    window.show();
+    return app.exec();
+}

build.log

@@ -0,0 +1,36 @@
+make: Entering directory '/home/rigoni/devel/cmt/ulib/build'
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxImage.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/TriangleMesh.cpp.o
+[ 30%] Building CXX object src/Core/CMakeFiles/mutomCore.dir/Options.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Dense.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredGrid.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxRaytracer.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredData.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured2DGrid.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured4DGrid.cpp.o
+[ 33%] Linking CXX shared library libmutomCore.so
+[ 33%] Built target mutomCore
+[ 36%] Linking CXX shared library libmutomMath.so
+[ 36%] Built target mutomMath
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkContainerBox.cpp.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkInterface.cxx.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkStructuredGrid.cpp.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkMuonScatter.cxx.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkViewer.cpp.o
+[ 63%] Generating mutomRootDict.cxx, libmutomRootDict_rdict.pcm, libmutomRootDict.rootmap
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxImage.cpp.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxRaytracerRepresentation.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorSkinHit.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorHit.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMCTrack.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorInfo.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/RootMuonScatter.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorPrimaryVertex.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMuDetDIGI.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/SkinDetectorWriter.cpp.o
+[ 93%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/mutomRootDict.cxx.o
+[ 96%] Linking CXX shared library libmutomVtk.so
+[ 96%] Built target mutomVtk
+[100%] Linking CXX shared library libmutomRoot.so
+[100%] Built target mutomRoot
+make: Leaving directory '/home/rigoni/devel/cmt/ulib/build'

build_python.py

@@ -0,0 +1,54 @@
+import os
+import subprocess
+import sys
+import shutil
+
+def build(setup_kwargs):
+    """
+    Build the C++ extension using CMake.
+    This function is called by poetry-core during the build process.
+    The binary is placed directly inside the uLib directory in src/Python.
+    """
+    # Root of the whole project where this build_extension.py is located
+    project_root = os.path.abspath(os.path.dirname(__file__))
+    
+    # Where the extension should go
+    package_dir = os.path.join(project_root, "src/Python/uLib")
+    
+    # Ensure package directory exists
+    os.makedirs(package_dir, exist_ok=True)
+    
+    # Temporary build directory
+    build_temp = os.path.join(project_root, "build_python")
+    os.makedirs(build_temp, exist_ok=True)
+
+    print(f"--- Running CMake build in {build_temp} ---")
+    print(f"Project root: {project_root}")
+    print(f"Target binary dir: {package_dir}")
+
+    # Determine if CUDA should be enabled
+    use_cuda = os.environ.get("USE_CUDA", "OFF").upper()
+    if use_cuda in ["ON", "1", "TRUE", "YES"]:
+        use_cuda = "ON"
+    else:
+        use_cuda = "OFF"
+    
+    # CMake configuration
+    cmake_args = [
+        f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={package_dir}",
+        f"-DPYTHON_EXECUTABLE={sys.executable}",
+        "-DCMAKE_BUILD_TYPE=Release",
+        f"-DUSE_CUDA={use_cuda}", 
+        "-G", "Unix Makefiles",
+    ]
+
+    # Use micromamba to ensure Boost and VTK are found during the build
+    subprocess.check_call(["cmake", project_root] + cmake_args, cwd=build_temp)
+    subprocess.check_call(["cmake", "--build", ".", "--parallel", "--target", "uLib_python"], cwd=build_temp)
+    
+    # Ensure the package is found by poetry during the wheel creation process.
+    # Return setup_kwargs for poetry-core.
+    return setup_kwargs
+
+if __name__ == "__main__":
+    build({})

conanfile.txt

@@ -0,0 +1,13 @@
+[requires]
+eigen/3.4.0
+boost/1.83.0
+# pybind11/3.0.2
+hdf5/1.14.3
+
+[generators]
+CMakeDeps
+CMakeToolchain
+
+[options]
+hdf5/*:threadsafe=True
+hdf5/*:enable_unsupported=True

condaenv.yml

@@ -0,0 +1,10 @@
+name: mutom
+channels:
+  - conda-forge
+dependencies:
+  - compiler-rt
+  - make
+  - cmake
+  - conan
+  - root
+  - vtk

docs/assets/css/extensions/tabbed.css

@@ -0,0 +1,41 @@
+.tabbed-set {
+  display: flex;
+  position: relative;
+  flex-wrap: wrap;
+}
+
+.tabbed-set .highlight {
+  background: #ddd;
+}
+
+.tabbed-set .tabbed-content {
+  display: none;
+  order: 99;
+  width: 100%;
+}
+
+.tabbed-set label {
+  width: auto;
+  margin: 0 0.5em;
+  padding: 0.25em;
+  font-size: 120%;
+  cursor: pointer;
+  color: #ffffff !important;
+}
+
+.tabbed-set input {
+  position: absolute;
+  opacity: 0;
+}
+
+.tabbed-set input:nth-child(n+1) {
+  color: #333333;
+}
+
+.tabbed-set input:nth-child(n+1):checked + label {
+    color: cyan !important;
+}
+
+.tabbed-set input:nth-child(n+1):checked + label + .tabbed-content {
+    display: block;
+}

docs/assets/css/extra.css

@@ -0,0 +1,17 @@
+@import "extensions/tabbed.css";
+
+.md-grid {
+    max-width: 100%;
+}
+
+.md-main__inner {
+    margin-top: 0;
+    padding-top: 0;
+}
+
+.md-sidebar--secondary {
+    right: 1.5rem;
+    top: 4.8rem;
+    transform: none;
+    width: 18rem;
+}

docs/docker/Dockerfile

@@ -0,0 +1,30 @@
+# Stage 1: Build the static site using MkDocs
+FROM python:3.9-slim-buster as builder
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the requirements file
+COPY requirements.txt .
+
+# Install the Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application files
+COPY ../.. .
+
+# Build the MkDocs site
+RUN mkdocs build
+
+
+# Stage 2: Serve the static files with Nginx
+FROM nginx:alpine
+
+# Copy the built site from the builder stage
+COPY --from=builder /app/site /usr/share/nginx/html
+
+# Expose port 80 for the web server
+EXPOSE 80
+
+# Command to run Nginx in the foreground
+CMD ["nginx", "-g", "daemon off;"]

docs/docker/Dockerfile.dev

@@ -0,0 +1,14 @@
+# Dockerfile for development with live-reloading
+FROM python:3.9-slim-buster
+
+WORKDIR /app
+
+# Copy and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the port MkDocs serve will run on
+EXPOSE 8000
+
+# Command to run the development server
+CMD ["mkdocs", "serve", "--dev-addr", "0.0.0.0:8000"]

docs/docker/docker-compose.yml

@@ -0,0 +1,13 @@
+version: '3.8'
+
+services:
+  mkdocs:
+    build:
+      context: .
+      dockerfile: Dockerfile.dev
+    ports:
+      - "8000:8000"
+    volumes:
+      - ../..:/app
+    environment:
+      - GIT_DISCOVERY_ACROSS_FILESYSTEM=1 

docs/docker/requirements.txt

@@ -0,0 +1,17 @@
+# ------------------------------------------------------------------
+# MkDocs runtime dependencies for the docs Docker image
+# ------------------------------------------------------------------
+
+# Core: theme (provides mkdocs itself as a transitive dep)
+mkdocs-material==9.7.1
+
+# pymdownx.* extensions used in mkdocs.yml:
+#   arithmatex, highlight, superfences, tabbed, details, blocks.caption
+# (also a hard dep of mkdocs-material, pinned here for reproducibility)
+pymdown-extensions>=10.0
+
+# Markdown math rendering support (arithmatex generic mode)
+# JS side is loaded via CDN (polyfill.io + MathJax), no extra Python pkg needed
+
+# Optional: PDF export plugin (exporter: block, currently commented out in mkdocs.yml)
+mkdocs-exporter

docs/docker/runtime.txt

@@ -0,0 +1 @@
+3.7

docs/index.md

@@ -0,0 +1,63 @@
+# uLib
+
+[![DOI](https://zenodo.org/badge/36926725.svg)](https://zenodo.org/badge/latestdoi/36926725)
+
+**uLib** is the base toolkit library for the **CMT (Cosmic Muon Tomography)** project, developed at the University of Padova and INFN Sezione di Padova, Italy.
+
+It provides:
+
+- **Core** – object model, timers, configuration, UUID utilities.
+- **Math** – linear algebra (Eigen3), structured grids, voxel images, ray-tracing, image filters.
+- **Python bindings** – full pybind11 interface for scripting and analysis workflows.
+- Optional **CUDA** acceleration for voxel filtering (transparent RAM ↔ VRAM management).
+
+---
+
+## Quick Start
+
+=== "Users (pip / poetry)"
+    ```bash
+    # Activate your conda/micromamba environment first
+    micromamba activate mutom
+
+    poetry install            # CPU build
+    USE_CUDA=ON poetry install # GPU build
+    ```
+
+=== "Developers (CMake)"
+    ```bash
+    conan install . --output-folder=build --build=missing
+    cmake --preset conan-release
+    cmake --build build --target uLib_python -j$(nproc)
+
+    export PYTHONPATH="$(pwd)/build/src/Python:$(pwd)/src/Python"
+    ```
+
+Then in Python:
+
+```python
+import uLib
+
+# Core
+timer = uLib.Core.Timer()
+timer.Start()
+
+# Math
+grid = uLib.Math.StructuredGrid([10, 10, 10])
+grid.SetSpacing([1.0, 1.0, 1.0])
+
+img = uLib.Math.VoxImage([10, 10, 10])
+img.SetValue(0, 3.14)
+print(img.GetValue(0))
+```
+
+---
+
+## Documentation Sections
+
+| Section | Description |
+|---|---|
+| [Python – Installation](python/installation.md) | Environment setup, user install, developer build |
+| [Python – API Usage](python/usage.md) | Full API reference with examples |
+| [Python – Developer Guide](python/developer_guide.md) | Adding bindings, running tests, build details |
+| [C++ Build – Usage & CUDA](usage/usage.md) | CMake build, CUDA configuration |

docs/python/developer_guide.md

@@ -0,0 +1,179 @@
+# Developer Guide – Python Bindings
+
+This guide is aimed at contributors who want to extend or modify the Python bindings for `uLib`.
+
+---
+
+## Repository Layout
+
+```
+ulib/
+├── src/
+│   └── Python/
+│       ├── module.cpp               # pybind11 module entry point
+│       ├── core_bindings.cpp        # uLib::Core bindings
+│       ├── math_bindings.cpp        # uLib::Math bindings
+│       ├── math_filters_bindings.cpp# VoxImageFilter bindings
+│       ├── CMakeLists.txt           # builds uLib_python shared lib
+│       ├── testing/                 # Python unit tests
+│       │   ├── pybind_test.py
+│       │   ├── core_pybind_test.py
+│       │   ├── math_pybind_test.py
+│       │   └── math_filters_test.py
+│       └── uLib/                    # Python package (uLib_python.so lands here)
+│           └── __init__.py
+├── build_python.py                  # poetry build hook (calls CMake)
+├── pyproject.toml                   # poetry metadata
+└── condaenv.yml                     # conda/micromamba environment
+```
+
+---
+
+## Adding a New Binding
+
+All bindings live in the four source files listed above. The module entry point `module.cpp` calls `init_core()`, `init_math()`, and `init_math_filters()` in order.
+
+### 1. Pick (or create) the right binding file
+
+| C++ header location | Binding file |
+|---|---|
+| `src/Core/` | `core_bindings.cpp` |
+| `src/Math/` (geometry, grids, VoxImage) | `math_bindings.cpp` |
+| `src/Math/VoxImageFilter*.hpp` | `math_filters_bindings.cpp` |
+
+### 2. Add the `#include` directive
+
+```cpp
+// math_bindings.cpp
+#include "Math/MyNewClass.h"
+```
+
+### 3. Write the pybind11 binding inside the appropriate `init_*` function
+
+```cpp
+void init_math(py::module_ &m) {
+    // ... existing bindings ...
+
+    py::class_<MyNewClass>(m, "MyNewClass")
+        .def(py::init<>())
+        .def("MyMethod",  &MyNewClass::MyMethod)
+        .def("AnotherMethod", &MyNewClass::AnotherMethod,
+             py::arg("x"), py::arg("y") = 0.0f);
+}
+```
+
+### 4. Rebuild only the Python target
+
+```bash
+cmake --build build --target uLib_python -j$(nproc)
+```
+
+### 5. Write a Python test
+
+Add a new test class to the relevant test file (or create a new one under `src/Python/testing/`):
+
+```python
+# src/Python/testing/math_pybind_test.py
+class TestMyNewClass(unittest.TestCase):
+    def test_basic(self):
+        obj = uLib.Math.MyNewClass()
+        result = obj.MyMethod()
+        self.assertAlmostEqual(result, expected_value)
+```
+
+Register the test in `src/Python/CMakeLists.txt` if you add a new file:
+
+```cmake
+add_test(NAME pybind_my_new
+         COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testing/my_new_test.py)
+set_tests_properties(pybind_my_new PROPERTIES
+    ENVIRONMENT "PYTHONPATH=$<TARGET_FILE_DIR:uLib_python>:${PROJECT_SOURCE_DIR}/src/Python")
+```
+
+---
+
+## Build System Details
+
+### CMakeLists.txt (`src/Python/`)
+
+`pybind11_add_module` compiles the shared library `uLib_python` and links it against the C++ static/shared libraries `uLibCore` and `uLibMath`. The install target copies the `.so` into the standard library directory.
+
+```cmake
+pybind11_add_module(uLib_python
+    module.cpp core_bindings.cpp math_bindings.cpp math_filters_bindings.cpp)
+
+target_link_libraries(uLib_python PRIVATE uLibCore uLibMath)
+```
+
+### poetry / build_python.py
+
+`pyproject.toml` declares `build_python.py` as the custom build hook. When `poetry install` or `poetry build` is invoked it:
+
+1. Calls `cmake <root> -DCMAKE_LIBRARY_OUTPUT_DIRECTORY=<pkg_dir> ...` in `build_python/`.
+2. Builds only the `uLib_python` target.
+3. The resulting `.so` is placed inside `src/Python/uLib/` so it is picked up by Poetry as a package data file.
+
+The `USE_CUDA` environment variable gates CUDA support at build time:
+
+```bash
+USE_CUDA=ON poetry install   # with CUDA
+USE_CUDA=OFF poetry install  # CPU only (default)
+```
+
+---
+
+## Running All Tests
+
+```bash
+# From the repository root, with PYTHONPATH set:
+export PYTHONPATH="$(pwd)/build/src/Python:$(pwd)/src/Python"
+
+python -m pytest src/Python/testing/ -v
+```
+
+Or through CMake's test runner (after building the full project):
+
+```bash
+cd build
+ctest --output-on-failure -R pybind
+```
+
+Expected output (all passing):
+
+```
+    Start 1: pybind_general
+1/4 Test #1: pybind_general .............   Passed
+    Start 2: pybind_core
+2/4 Test #2: pybind_core ................   Passed
+    Start 3: pybind_math
+3/4 Test #3: pybind_math ................   Passed
+    Start 4: pybind_math_filters
+4/4 Test #4: pybind_math_filters ........   Passed
+```
+
+---
+
+## Memory Management Notes
+
+`uLib::Vector<T>` has explicit GPU memory management. When wrapping methods that return references to internal data, use `py::return_value_policy::reference_internal` to avoid dangling references:
+
+```cpp
+.def("Data", &VoxImage<Voxel>::Data,
+     py::return_value_policy::reference_internal)
+```
+
+For objects held by `std::unique_ptr` without Python-side deletion, use `py::nodelete`:
+
+```cpp
+py::class_<Abstract::VoxImageFilter,
+           std::unique_ptr<Abstract::VoxImageFilter, py::nodelete>>(m, "AbstractVoxImageFilter")
+```
+
+---
+
+## Useful References
+
+- [pybind11 documentation](https://pybind11.readthedocs.io)
+- [pybind11 – STL containers](https://pybind11.readthedocs.io/en/stable/advanced/cast/stl.html)
+- [pybind11 – Eigen integration](https://pybind11.readthedocs.io/en/stable/advanced/cast/eigen.html)
+- [CMake – pybind11 integration](https://pybind11.readthedocs.io/en/stable/compiling.html)

docs/python/installation.md

@@ -0,0 +1,146 @@
+# Python Installation
+
+The `uLib` Python package exposes the Core and Math C++ libraries via [pybind11](https://pybind11.readthedocs.io) bindings. There are two ways to install it: as an **end user** (pre-built wheel / pip) or as a **developer** (editable build from source).
+
+---
+
+## Prerequisites
+
+`uLib` depends on native C++ libraries that must be compiled. Ensure the following are available in your environment before installing:
+
+| Dependency | Minimum version | Notes |
+|---|---|---|
+| Python | 3.9 | |
+| CMake | 3.12 | |
+| pybind11 | 2.6.0 | |
+| Conan | 2.x | for Eigen3 / Boost |
+| micromamba / conda | any | recommended – provides ROOT, VTK |
+
+### Creating the `mutom` Conda/Micromamba Environment
+
+A ready-to-use environment definition is provided as `condaenv.yml` at the repository root.
+
+=== "Micromamba"
+    ```bash
+    micromamba env create -f condaenv.yml
+    micromamba activate mutom
+    ```
+
+=== "Conda"
+    ```bash
+    conda env create -f condaenv.yml
+    conda activate mutom
+    ```
+
+The environment installs CMake, Conan, ROOT, VTK, and the compiler toolchain.
+
+> **CUDA (optional)**  
+> If you want GPU-accelerated voxel filtering, you also need NVCC inside the environment:
+> ```bash
+> micromamba install cuda-nvcc -c conda-forge
+> ```
+
+---
+
+## User Installation (wheel / pip)
+
+Once the native dependencies are present in your environment, install the package with Poetry or pip:
+
+```bash
+# Activate your environment first
+micromamba activate mutom
+
+# Build and install (CUDA disabled by default)
+poetry install
+
+# Build and install with CUDA support
+USE_CUDA=ON poetry install
+```
+
+After installation the module is importable from anywhere in the environment:
+
+```python
+import uLib
+print(dir(uLib.Core))
+print(dir(uLib.Math))
+```
+
+---
+
+## Developer Installation (editable / in-tree build)
+
+For development you typically want to skip the packaging layer and work directly against the CMake build tree.
+
+### Step 1 – Install Conan dependencies
+
+```bash
+conan profile detect          # first time only
+conan install . --output-folder=build --build=missing
+```
+
+### Step 2 – Configure and build
+
+```bash
+# Standard release build
+cmake --preset conan-release
+
+# …or manually
+cmake -B build \
+      -DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DUSE_CUDA=OFF          # set to ON when a GPU is available
+
+cmake --build build --target uLib_python -j$(nproc)
+```
+
+The shared library (`uLib_python*.so`) is written to `build/src/Python/`.
+
+### Step 3 – Make the module importable
+
+Point `PYTHONPATH` at the build output **and** the Python source directory (the latter carries the `uLib/__init__.py` that stitches sub-modules together):
+
+```bash
+export PYTHONPATH="$(pwd)/build/src/Python:$(pwd)/src/Python:$PYTHONPATH"
+python -c "import uLib; print(uLib.__version__)"
+```
+
+Or, for a one-shot check:
+
+```bash
+PYTHONPATH="build/src/Python:src/Python" python src/Python/testing/pybind_test.py
+```
+
+### Step 4 – Run the tests
+
+CMake registers the Python tests alongside the C++ ones; use `ctest` from the build directory:
+
+```bash
+cd build
+ctest --output-on-failure -R pybind
+```
+
+Individual test scripts can also be run directly once `PYTHONPATH` is set:
+
+```bash
+python src/Python/testing/core_pybind_test.py
+python src/Python/testing/math_pybind_test.py
+python src/Python/testing/math_filters_test.py
+```
+
+---
+
+## Verifying the Installation
+
+```python
+import uLib
+
+# Core module
+obj    = uLib.Core.Object()
+timer  = uLib.Core.Timer()
+timer.Start()
+elapsed = timer.StopWatch()   # float, seconds
+
+# Math module
+v3 = uLib.Math.Vector3f([1.0, 0.0, 0.0])
+print(v3[0])  # 1.0
+```

docs/python/usage.md

@@ -0,0 +1,373 @@
+# Python API Usage
+
+The `uLib` Python package is split into two sub-modules mirroring the C++ library:
+
+| Sub-module | Contents |
+|---|---|
+| `uLib.Core` | Low-level utilities: `Object`, `Timer`, `Options`, `TypeRegister` |
+| `uLib.Math` | Geometry, grids, voxel images, ray-tracing, image filters |
+
+```python
+import uLib
+# Sub-modules are accessible as attributes
+uLib.Core   # core utilities
+uLib.Math   # mathematical structures
+```
+
+---
+
+## uLib.Core
+
+### Object
+
+Base class for uLib objects; exposed to Python for type-hierarchy purposes.
+
+```python
+obj = uLib.Core.Object()
+copy = obj.DeepCopy()
+```
+
+### Timer
+
+Precision wall-clock timer.
+
+```python
+import time
+timer = uLib.Core.Timer()
+timer.Start()
+time.sleep(0.5)
+elapsed = timer.StopWatch()   # returns elapsed seconds as float
+print(f"Elapsed: {elapsed:.3f} s")
+```
+
+### Options
+
+Wraps Boost.ProgramOptions for INI-style configuration files.
+
+```python
+opt = uLib.Core.Options("My Program")
+opt.parse_config_file("config.ini")   # load settings
+n = opt.count("my_key")               # check if key exists
+opt.save_config_file("out.ini")
+```
+
+---
+
+## uLib.Math – Linear Algebra
+
+The math module exposes Eigen3 vectors and matrices as well-typed Python objects with NumPy interoperability.
+
+### Fixed-size Vectors
+
+```python
+import numpy as np
+import uLib
+
+# Construct from list
+v3 = uLib.Math.Vector3f([1.0, 2.0, 3.0])
+print(v3[0], v3[1], v3[2])   # 1.0 2.0 3.0
+
+# Construct from NumPy array
+arr = np.array([4.0, 5.0, 6.0], dtype=np.float32)
+v3b = uLib.Math.Vector3f(arr)
+
+# Zero-initialise
+v4d = uLib.Math.Vector4d()    # all zeros
+
+# Available types
+# Vector1f / 2f / 3f / 4f  (float32)
+# Vector1d / 2d / 3d / 4d  (float64)
+# Vector1i / 2i / 3i / 4i  (int32)
+```
+
+### Fixed-size Matrices
+
+```python
+# 2-by-2 float matrix
+m2f = uLib.Math.Matrix2f()
+m2f[0, 0] = 1;  m2f[0, 1] = 2
+m2f[1, 0] = 3;  m2f[1, 1] = 4
+
+# From list (row-major)
+m4f = uLib.Math.Matrix4f([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1])
+
+# From NumPy (2-D array)
+mat = np.eye(3, dtype=np.float32)
+m3f = uLib.Math.Matrix3f(mat)
+
+# Dynamic matrices
+mXf = uLib.Math.MatrixXf(4, 4)   # 4×4 float, zeros
+```
+
+### Homogeneous Types
+
+```python
+# HPoint3f – a 3-D point in homogeneous coordinates (w = 1)
+p = uLib.Math.HPoint3f(1.0, 2.0, 3.0)
+
+# HVector3f – a free vector (w = 0)
+v = uLib.Math.HVector3f(0.0, 1.0, 0.0)
+
+# HLine3f – a parametric ray
+line = uLib.Math.HLine3f()
+line.origin    = uLib.Math.HPoint3f(0, 0, 0)
+line.direction = uLib.Math.HVector3f(0, 0, 1)
+```
+
+---
+
+## uLib.Math – Transforms and Geometry
+
+### AffineTransform
+
+A rigid-body / affine transform stored as a 4×4 matrix.
+
+```python
+tf = uLib.Math.AffineTransform()
+
+tf.SetPosition([1.0, 0.0, 0.0])   # translate
+tf.Translate([0.0, 1.0, 0.0])     # cumulative translate
+tf.Scale([2.0, 2.0, 2.0])         # uniform scale
+tf.Rotate(uLib.Math.Vector3f([0, 0, 3.14159]))  # Euler angles (rad)
+
+mat4 = tf.GetWorldMatrix()   # 4×4 matrix
+pos  = tf.GetPosition()      # Vector3f
+```
+
+### Geometry
+
+Inherits `AffineTransform`; converts points between world and local frames.
+
+```python
+geo = uLib.Math.Geometry()
+geo.SetPosition([1.0, 1.0, 1.0])
+
+world_pt = uLib.Math.Vector4f([2.0, 3.0, 2.0, 1.0])
+local_pt = geo.GetLocalPoint(world_pt)
+back     = geo.GetWorldPoint(local_pt)
+# back ≈ [2, 3, 2, 1]
+```
+
+### ContainerBox
+
+An axis-aligned bounding box with an associated transform.
+
+```python
+box = uLib.Math.ContainerBox()
+box.SetOrigin([-1.0, -1.0, -1.0])
+box.SetSize([2.0, 2.0, 2.0])
+print(box.GetSize())    # [2, 2, 2]
+```
+
+---
+
+## uLib.Math – Structured Grids
+
+### StructuredGrid (3-D)
+
+A 3-D voxel grid (origin, spacing, and integer dimensions).
+
+```python
+dims = uLib.Math.Vector3i([10, 10, 10])
+grid = uLib.Math.StructuredGrid(dims)
+grid.SetSpacing([1.0, 1.0, 1.0])
+grid.SetOrigin([0.0, 0.0, 0.0])
+
+print(grid.GetSpacing())          # [1, 1, 1]
+print(grid.IsInsideBounds([5, 5, 5, 1]))  # True
+idx = grid.Find([2.5, 2.5, 2.5]) # returns grid cell index
+```
+
+### Structured2DGrid / Structured4DGrid
+
+```python
+grid2d = uLib.Math.Structured2DGrid()
+grid2d.SetDims([100, 100])
+grid2d.SetPhysicalSpace([0, 0], [1, 1])
+print(grid2d.GetSpacing())
+```
+
+---
+
+## uLib.Math – VoxImage
+
+`VoxImage` is a 3-D voxel volume where each cell stores a `Voxel` ( `.Value` + `.Count`).
+
+```python
+dims = uLib.Math.Vector3i([20, 20, 20])
+img  = uLib.Math.VoxImage(dims)
+img.SetSpacing([0.5, 0.5, 0.5])
+
+# Access by linear index
+img.SetValue(0, 42.0)
+print(img.GetValue(0))    # 42.0
+
+# Access by 3-D index
+img.SetValue(uLib.Math.Vector3i([1, 1, 1]), 7.5)
+print(img.GetValue(uLib.Math.Vector3i([1, 1, 1])))  # 7.5
+
+# Clipping / masking helpers
+cropped = img.clipImage(uLib.Math.Vector3i([2, 2, 2]),
+                        uLib.Math.Vector3i([18, 18, 18]))
+masked  = img.maskImage(0.0, 100.0, 0.0)   # mask outside [0, 100]
+
+# I/O
+img.ExportToVti("output.vti")
+img.ImportFromVti("output.vti")
+```
+
+### Voxel (element type)
+
+```python
+vox = uLib.Math.Voxel()
+vox.Value = 1.5
+vox.Count = 3
+
+data = img.Data()        # returns the underlying Vector_Voxel
+vox0 = data[0]
+print(vox0.Value, vox0.Count)
+```
+
+---
+
+## uLib.Math – VoxRaytracer
+
+Performs ray-tracing through a `StructuredGrid` and returns per-voxel chord lengths.
+
+```python
+import numpy as np
+import uLib
+
+grid = uLib.Math.StructuredGrid([10, 10, 10])
+grid.SetSpacing([1.0, 1.0, 1.0])
+grid.SetOrigin([0.0, 0.0, 0.0])
+
+rt = uLib.Math.VoxRaytracer(grid)
+
+# Trace a ray between two homogeneous points (x, y, z, w=1)
+p1 = np.array([0.5, 0.5, -1.0, 1.0], dtype=np.float32)
+p2 = np.array([0.5, 0.5, 11.0, 1.0], dtype=np.float32)
+result = rt.TraceBetweenPoints(p1, p2)
+
+print("Voxels crossed:", result.Count())
+print("Total length  :", result.TotalLength())
+
+elements = result.Data()
+for i in range(result.Count()):
+    print(f"  vox_id={elements[i].vox_id}  L={elements[i].L:.4f}")
+```
+
+---
+
+## uLib.Math – Image Filters
+
+All filters share the same interface: construct with a kernel size, attach a `VoxImage`, optionally set parameters, then call `.Run()`.
+
+```python
+import uLib
+
+dims = uLib.Math.Vector3i([10, 10, 10])
+img  = uLib.Math.VoxImage(dims)
+for i in range(10**3):
+    img.SetValue(i, float(i))
+
+kernel_dims = uLib.Math.Vector3i([3, 3, 3])
+```
+
+### Linear (Gaussian / Box) Filter
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmLinear(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)   # uniform box kernel, length = product of dims
+filt.Run()
+```
+
+### ABTrim Filter
+
+Applies alpha-beta trimming to remove outliers before averaging.
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmAbtrim(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)
+filt.SetABTrim(2, 2)    # trim 2 low and 2 high values
+filt.Run()
+```
+
+### Bilateral Filter
+
+Edge-preserving smoothing controlled by a spatial sigma (from the kernel shape) and an intensity sigma.
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmBilateral(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)
+filt.SetIntensitySigma(0.3)
+filt.Run()
+```
+
+### Threshold Filter
+
+Zeros voxels below a threshold.
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmThreshold(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)
+filt.SetThreshold(0.5)
+filt.Run()
+```
+
+### Median Filter
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmMedian(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)
+filt.Run()
+```
+
+---
+
+## uLib.Math – Accumulators
+
+Accumulators collect scalar samples and return a summary statistic.
+
+```python
+# Arithmetic mean
+acc = uLib.Math.Accumulator_Mean_f()
+acc(10.0)
+acc(20.0)
+mean = acc()       # 15.0
+
+# Alpha-beta trimmed mean
+acc2 = uLib.Math.Accumulator_ABTrim_f()
+acc2.SetABTrim(0.1, 0.1)   # trim bottom 10 % and top 10 %
+acc2 += 1.0
+acc2 += 9999.0             # outlier
+acc2 += 5.0
+result = acc2()            # trimmed mean ≈ 3.0
+```
+
+---
+
+## Dynamic Vectors (`uLib.Math.Vector_*`)
+
+Typed dynamic arrays backed by `uLib::Vector<T>` with optional CUDA memory management.
+
+```python
+# Integer vector
+vi = uLib.Math.Vector_i()
+vi.append(1); vi.append(2); vi.append(3)
+print(len(vi), vi[0])
+
+# Float vector with CUDA management
+vf = uLib.Math.Vector_f()
+vf.append(1.5)
+vf.MoveToVRAM()   # copy to GPU (no-op when CUDA is absent)
+vf.MoveToRAM()    # copy back to CPU
+
+# Other types: Vector_ui, Vector_l, Vector_ul, Vector_d
+# Compound element types: Vector_Vector3f, Vector_Vector4f, Vector_Voxel …
+```

docs/usage/usage.md

@@ -0,0 +1,60 @@
+# Usage and Installation Guide
+
+## Requirements
+
+### Compiling with CUDA Support
+
+The library supports running VoxImage filtering operations directly on CUDA cores via transparent RAM/VRAM memory transfers.
+
+By default, the `CMakeLists.txt` build system sets `USE_CUDA=ON` and will attempt to locate `nvcc` and the NVIDIA CUDA Toolkit. If the toolkit is missing, `CMake` will fail unless you explicitly configure the project with `-DUSE_CUDA=OFF`.
+
+### 1. Installing CUDA Environment via Micromamba
+
+If you are developing inside an isolated Conda/Micromamba environment (e.g., `mutom`), you can inject the CUDA compilers directly into your environment rather than relying on global system dependencies:
+
+```bash
+# Add the conda-forge channel if not already available
+micromamba config append channels conda-forge
+
+# Install nvcc and the necessary CUDA toolkit components
+micromamba install cuda-nvcc
+```
+
+Verify your installation:
+
+```bash
+nvcc --version
+```
+
+### 2. Building the Project
+
+Configure and compile the project using standard CMake flows:
+
+```bash
+mkdir -p build && cd build
+
+# Configure CMake
+# (Optional) Explicitly toggle CUDA: cmake -DUSE_CUDA=ON ..
+cmake ..
+
+# Compile the project and tests
+make -j $(nproc)
+```
+
+### 3. Validating CUDA Support
+
+You can verify that the CUDA kernels are launching correctly and allocating device memory through `DataAllocator` by running the mathematical unit tests.
+
+```bash
+# From the build directory
+./src/Math/testing/VoxImageFilterTest
+
+# Output should show:
+# "Data correctly stayed in VRAM after CUDA execution!"
+```
+
+## How It Works Under The Hood
+
+The `DataAllocator<T>` container automatically wraps memory allocations to transparently map to CPU RAM, or GPU VRAM. Standard iteration automatically pulls data backwards using implicit `MoveToRAM()` calls. 
+
+Filters using `#ifdef USE_CUDA` explicitly dictate `<buffer>.MoveToVRAM()` allocating directly on device bounds seamlessly. Fallbacks to Host compute iterations handle themselves automatically. Chaining specific filters together safely chains continuous VRAM operations avoiding costly Host copies in between iterations.

mkdocs.yml

@@ -0,0 +1,561 @@
+# site_name: uLib Documentation
+# site_description: CMT Cosmic Muon Tomography – uLib toolkit
+# site_author: Andrea Rigoni Garola
+# repo_url: https://github.com/cmt/ulib
+# docs_dir: docs
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | This is the main file used by MkDocs to build the pages.                                               |
+# | It contains a lot of information and settings for you to read and use.                                 |
+# | Comments may contain "Read More" URLs to more in-depth documentation about the option for you to read. |
+# |                                                                                                        |
+# | You can check out https://www.mkdocs.org/user-guide/configuration/ for a more detailed explanation of  |
+# | all the options MkDocs offers by default.                                                              |
+# |                                                                                                        |
+# +------------------------------------------------- NOTE -------------------------------------------------+
+# |                                                                                                        |
+# | Some of the options listed here are only available through the usage of Material for MkDocs.           |
+# | Those options will usually have a link to the docs of this Theme and also mention "Material" as name.  |
+# | The actual name of the theme is "Material for MkDocs" and "Material" is used for simplicity reasons.   |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | Main Page Settings for MkDocs.                                                                         |
+# | Those settings are site name, site description, Site author and also Site URL (Canonical URL)          |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#site_name                                           |
+# | - https://www.mkdocs.org/user-guide/configuration/#site_description                                    |
+# | - https://www.mkdocs.org/user-guide/configuration/#site_author                                         |
+# | - https://www.mkdocs.org/user-guide/configuration/#site_url                                            |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+site_name: OpenCMT uLib Documentation
+site_url: https://docs.mildstone.org/uLib/ # <--- project subfolder
+use_directory_urls: true
+site_description: 'Documentation for OpenCMT uLib'
+site_author: 'Andrea Rigoni Garola'
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | This setting allows you to define your own Copyright notice.                                           |
+# | The text is treated as HTML code so you can use things like <a> tags or &copy; to display the          |
+# | Copyright icon.                                                                                        |
+# |                                                                                                        |
+# | Where or IF the Copyright is displayed depends on the theme you use.                                   |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#copyright                                           |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+copyright: |
+  &copy; Author
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | The base folder to use.                                                                                |
+# | Any Markdown files you put into this folder will be turned into a static HTML page once you build or   |
+# | publish your page.                                                                                     |
+# |                                                                                                        |
+# | It is also used as the base directory for other settings like the "extra_css" or "extra_javascript"    |
+# | option.                                                                                                |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+docs_dir: docs/
+
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | These options allow to define a Repository to link to.                                                 |
+# | The result will, depending on the theme, be a link somewhere shown on the page that links to the       |
+# | Repository with the specified repo_name.                                                               |
+# |                                                                                                        |
+# | This will also enable a "edit" button on the page itself that allows the direct editing of the page.   |
+# | You can disable this by setting "edit_uri" to an empty String.                                         |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#repo_name                                           |
+# | - https://www.mkdocs.org/user-guide/configuration/#repo_url                                            |
+# | - https://www.mkdocs.org/user-guide/configuration/#edit_uri                                            |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+repo_name: OpenCMT/uLib
+repo_url: https://gitea.mildstone.org/OpenCMT/uLib.git
+#edit_uri: tree/master/docs # Uncomment to define a different URI/URL for the "edit" option
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | The "nav" option is where you define the navigation to show in MkDocs.                                 |
+# |                                                                                                        |
+# | Depending on the theme you use will the resulting Navigation look different.                           |
+# |                                                                                                        |
+# | You can set different types of navigations. Either just the path, the path with a separate title or    |
+# | an external URL.                                                                                       |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#documentation-layout                                |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+
+nav:
+  - Home: index.md
+  - Python:
+    - Installation: python/installation.md
+    - API Usage: python/usage.md
+    - Developer Guide: python/developer_guide.md
+  - C++ Build:
+    - Usage & CUDA: usage/usage.md
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | The "theme" section allows you to define what theme to use.                                            |
+# | It is also used for theme-specific options, but also for advanced stuff such as theme-extensions, if   |
+# | the theme actually supports it.                                                                        |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#theme                                               |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+theme:
+
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "name" option is where you define the theme to use.                                              |
+  # |                                                                                                      |
+  # | Note that not all themes are included by default and will require you to install them first.         |
+  # | The Material theme is one of them. See the "Read More" link for instructions on how to install it.   |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/getting-started/                                       |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  name: 'material'
+
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The Material theme allows "theme-extsnions", meaning that you can override parts of it by either     |
+  # | overriding a particular file, or only parts (blocks) of it.                                          |
+  # |                                                                                                      |
+  # | If you want to override parts of Material, uncomment the "custom_dir" option below and set the       |
+  # | folder (relative to the mkdocs.yml file) where your theme extensions will be located at.             |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://www.mkdocs.org/user-guide/configuration/#custom_dir                                        |
+  # | - https://squidfunk.github.io/mkdocs-material/customization/#extending-the-theme                     |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #custom_dir: 'theme'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "favicon" option allows you to set your own image/icon to use in the browser-tab.                |
+  # |                                                                                                      |
+  # | Pretty much all image types are supported, but it's recommended to use a PNG, SVG or ICO image for   |
+  # | the favicon.                                                                                         |
+  # |                                                                                                      |
+  # | The directory is relative to the "docs_dir".                                                         |
+  # |                                                                                                      |
+  # | Example: Having a favicon.png in docs/assets/images will result in the "favicon" setting showing     |
+  # |          'assets/images/favicon.png'                                                                 |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-logo-and-icons/#favicon             |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #favicon: 'assets/images/favicon.png'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "palette" section is a Material option and allows you to define specific style options such as   |
+  # | Color-Scheme, and primary and secondary Color.                                                       |
+  # |                                                                                                      |
+  # | You can also define multiple palettes that can have different Color Schemses and primary and/or      |
+  # | secondary Colors.                                                                                    |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/                             |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/#color-palette-toggle        |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  palette:
+  
+    # Palette toggle for light mode
+    - media: "(prefers-color-scheme: light)"
+      scheme: default
+      primary: 'indigo'
+      accent: 'indigo'
+      toggle:
+        icon: material/brightness-7
+        name: Switch to dark mode
+
+    # Palette toggle for dark mode
+    - media: "(prefers-color-scheme: dark)"
+      scheme: slate
+      primary: 'indigo'
+      accent: 'indigo'
+      toggle:
+        icon: material/brightness-4
+        name: Switch to light mode
+    
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | With the "font" option can you set a different font to use.                                          |
+  # |                                                                                                      |
+  # | Material supports all Google fonts, but you can also define your own ones if you choose so.          |
+  # |                                                                                                      |
+  # | The "text" option is used for the regular font while "code" is used for code blocks, inline code and |
+  # | similar.                                                                                             |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-fonts/                              |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #font:
+  #  text: 'Roboto'
+  #  code: 'Roboto Mono'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | Material suppors more than 40 different languages which you can set using the "language" option      |
+  # | below.                                                                                               |
+  # |                                                                                                      |
+  # | The default language is "en" (English).                                                              |
+  # |                                                                                                      |
+  # | You can also enable/set a "selector" to allow switching between languages.                           |
+  # | See the "alternate" option in the "extra" section below for more information on this topic.          |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-language/                           |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #language: 'en'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "direction" option is commonly used together with the "language" option.                         |
+  # |                                                                                                      |
+  # | It allows you to change the text direction from the default left-to-right (ltr) to right-to-left     |
+  # | (rtl) which is used in certain languages.                                                            |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-language/#directionality            |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #direction: 'ltr'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "features" option allows you to enable specific features of Material, by adding them to the      |
+  # | list.                                                                                                |
+  # |                                                                                                      |
+  # | Features are in the format <category>.<name>. As an example, the feature to enable tabs is called    |
+  # | navigation.tabs.                                                                                     |
+  # |                                                                                                      |
+  # | The list below contains all known features of Material.                                              |
+  # |                                                                                                      |
+  # | Features marked with a * are currently Insiders-only. (Last update: 11th December 2021)              |
+  # | https://squidfunk.github.io/mkdocs-material/insiders/                                                |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/setting-up-navigation/                           |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  features:
+  # Announce
+  #
+  #- announce.dismiss # Adds a "X" button to dismiss a news banner/mark it as read.*
+  
+  # Header
+  #
+  #- header.autohide # Hide header when user scrolls past a specific point.
+  
+  # Navigation:
+  #
+  #- navigation.expand      # Expand all collapsable sections.
+  #- navigation.instant     # Instant loading pages.
+  #- navigation.indexes     # Attach pages directly to Sections. Incompatible with "toc.integrate"
+  #- navigation.sections    # Render top sections as groups.
+  - navigation.tabs         # Render top sections as tabs at the top.
+  #- navigation.tabs.sticky # Tabs won't disappear when scrolling down. Requires "navigation.tabs".
+  #- navigation.top         # Adds a "Back to top" that is shown when scrolling up.
+  #- navigation.tracking    # Updates the url with highlighted section anchor.
+  
+  # Search
+  #
+  #- search.highlight # Search will highlight the searched word(s) on the page.*
+  #- search.share     # Adds an option to share a search query link.*
+  #- search.suggest   # Search will suggest the likeliest completion for a word.*
+  
+  # Table of Contents
+  #
+  #- toc.integrate          # Include the TOC sections in the left navugation.
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "icon" section allows you to define a icon to use for the logo and/or repository.                |
+  # |                                                                                                      |
+  # | To use already available icons will you need to set the right path for it, depending on which you    |
+  # | want to use.                                                                                         |
+  # |                                                                                                      |
+  # | Available icons:                                                                                     |
+  # | - FontAwesome                                                                                        |
+  # |   - Brands:  fontawesome/brands/...  (https://fontawesome.com/icons?d=gallery&p=2&s=brands&m=free)   |
+  # |   - Regular: fontawesome/regular/... (https://fontawesome.com/icons?d=gallery&p=2&s=regular&m=free)  |
+  # |   - Solid:   fontawesome/solid/...   (https://fontawesome.com/icons?d=gallery&p=2&s=solid&m=free)    |
+  # |                                                                                                      |
+  # | - Material Design Icons: material/... (https://materialdesignicons.com/)                             |
+  # |                                                                                                      |
+  # | - Octicons: octicons/... (https://primer.style/octicons/)                                            |
+  # |                                                                                                      |
+  # | You can also define your own Image for the logo. To do that, remove the "logo" option from "icon"    |
+  # | instead add a "logo" option on the same level as the "icon" one, where you then set the path         |
+  # | (relative to the "docs_dir") to the icon to use. Supported are all images types, including SVG.      |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-logo-and-icons/#logo                |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  icon:
+    logo: 'material/library'
+    repo: 'material/library'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "admonition" option allows you to set a different icon for each admonition type.                 |
+  # |                                                                                                      |
+  # | This is currently a Insiders-only feature. (Last update: 7th October 2021)                           |
+  # | https://squidfunk.github.io/mkdocs-material/insiders/                                                |
+  # |                                                                                                      |
+  # | Supported are all bundled icons:                                                                     |
+  # | - FontAwesome                                                                                        |
+  # |   - Brands:  fontawesome/brands/...  (https://fontawesome.com/icons?d=gallery&p=2&s=brands&m=free)   |
+  # |   - Regular: fontawesome/regular/... (https://fontawesome.com/icons?d=gallery&p=2&s=regular&m=free)  |
+  # |   - Solid:   fontawesome/solid/...   (https://fontawesome.com/icons?d=gallery&p=2&s=solid&m=free)    |
+  # |                                                                                                      |
+  # | - Material Design Icons: material/... (https://materialdesignicons.com/)                             |
+  # |                                                                                                      |
+  # | - Octicons: octicons/... (https://primer.style/octicons/)                                            |
+  # |                                                                                                      |
+  # | You can also create and use your own icons. See the documentation for more information.              |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/reference/admonitions/#changing-the-icons              |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #admonition:
+  #    note: 'octicons/tag-16'
+  #    abstract: 'octicons/checklist-16'
+  #    info: 'octicons/info-16'
+  #    tip: 'octicons/squirrel-16'
+  #    success: 'octicons/check-16'
+  #    question: 'octicons/question-16'
+  #    warning: 'octicons/alert-16'
+  #    failure: 'octicons/x-circle-16'
+  #    danger: 'octicons/zap-16'
+  #    bug: 'octicons/bug-16'
+  #    example: 'octicons/beaker-16'
+  #    quote: 'octicons/quote-16'
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | With the "extra_css" option can you add your own (S)CSS files to enhance the documentation.            |
+# |                                                                                                        |
+# | The path to the file is relative to the "docs_dir".                                                    |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#extra_css                                           |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+extra_css:
+  - assets/css/extra.css
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | Similar to the "extra_css" option does the "extra_javascript" option allow you to set custom JS files  |
+# | to add extra featurues.                                                                                |
+# |                                                                                                        |
+# | The path to the file is relative to the "docs_dir".                                                    |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#extra_javascript                                    |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+extra_javascript:
+  - https://polyfill.io/v3/polyfill.min.js?features=es6
+  - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | The "extra" section contains pretty much anything you want, as long as it is a valid key-value pair.   |
+# |                                                                                                        |
+# | Material uses this section for different custom settings that wouldn't fit in the theme section.       |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#extra                                               |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+extra:
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The social section allows you to set a list of entries which would be displayed in the footer of the |
+  # | page.                                                                                                |
+  # |                                                                                                      |
+  # | Each entry has the exact same options:                                                               |
+  # | - icon: Path to the SVG icon to use. See "icon" section for available icon sets.                     |
+  # | - link: URL to which the icon should link.                                                           |
+  # | - name: Optional Name that would be displayed as title on hover.                                     |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/setting-up-the-footer/#social-links              |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  social:
+    - icon: 'fontawesome/brands/github'
+      link: 'https://github.com/Andre601/mkdocs-template'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | Allows you to hide the "Made with Material for MkDocs" text in the footer of the pages by setting    |
+  # | this to "true".                                                                                      |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/setting-up-the-footer/#generator-notice          |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #generator: true
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "manifest" option allows you to define a .manifest file to use.                                  |
+  # |                                                                                                      |
+  # | A .manifest file makes the doc act like a web-application and tells it how to behave when installed. |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/reference/meta-tags/#adding-a-web-app-manifest         |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #manifest: manifest.webmanifest
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "alternate" option can be used to create a selector to switch languages.                         |
+  # |                                                                                                      |
+  # | Using this requires you to create a specific, more complicated MkDocs setup.                         |
+  # |                                                                                                      |
+  # | A Setup Guide for multi-language docs can be found here:                                             |
+  # | https://github.com/squidfunk/mkdocs-material/discussions/2346                                        |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-language/#site-language-selector    |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #alternate:
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | MkDocs allows the usage of Markdown extensions which can do various things.                            |
+# |                                                                                                        |
+# | Material includes the pymdownx extension which provides a lot of useful features to use.               |
+# |                                                                                                        |
+# | Note that some extensions may use specific settings that you need to set.                              |
+# | Please check out the official documentation of PyMdownx for more information:                          |
+# | https://facelessuser.github.io/pymdown-extensions/                                                     |
+# |                                                                                                        |
+# | Material already provides required CSS and JS values for the PyMdownX Extensions, which means you do   |
+# | not need to set them up yourself.                                                                      |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#markdown_extensions                                 |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+markdown_extensions:
+  - markdown.extensions.admonition:
+  - markdown.extensions.codehilite:
+      guess_lang: false
+  - markdown.extensions.toc:
+      permalink: true
+  - pymdownx.arithmatex:
+      generic: true
+  - attr_list
+  - md_in_html
+  - pymdownx.blocks.caption
+  - admonition
+  - pymdownx.highlight:
+      anchor_linenums: true
+  - pymdownx.superfences
+  - pymdownx.tabbed:
+      alternate_style: true
+  - pymdownx.details
+  - attr_list
+  - tables
+
+  #- pymdownx.b64:
+  #- pymdownx.betterem:
+  #- pymdownx.caret:
+  #- pymdownx.critic:
+  #- pymdownx.details:
+  #- pymdownx.emoji:
+  #- pymdownx.escapeall:
+  #- pymdownx.extra:
+  #- pymdownx.extrarawhtml:
+  #- pymdownx.highlight:
+  #- pymdownx.inlinehilite:
+  #- pymdownx.keys:
+  #- pymdownx.magiclink:
+  #- pymdownx.mark:
+  #- pymdownx.pathconverter:
+  #- pymdownx.progressbar:
+  #- pymdownx.smartsymbols:
+  #- pymdownx.snippets:
+  #- pymdownx.striphtml:
+  #- pymdownx.superfences:
+  #- pymdownx.tabbed:
+  #- pymdownx.tasklist:
+  #- pymdownx.tilde:
+  # - exporter:
+  #     formats:
+  #       pdf:
+  #         enabled: !ENV [MKDOCS_EXPORTER_PDF, true]
+  #         concurrency: 8
+  #         stylesheets:
+  #           - resources/stylesheets/pdf.scss
+  #         covers:
+  #           front: resources/templates/covers/front.html.j2
+  #           back: resources/templates/covers/back.html.j2
+  #         aggregator:
+  #           enabled: true
+  #           output: .well-known/site.pdf
+  #           covers: all
+
+# theme:
+#   name: material
+#   palette:
+#     - scheme: default
+#       primary: indigo
+#       accent: blue
+#       toggle:
+#         icon: material/brightness-7
+#         name: Switch to dark mode
+#     - scheme: slate
+#       primary: indigo
+#       accent: blue
+#       toggle:
+#         icon: material/brightness-4
+#         name: Switch to light mode
+#   features:
+#     - navigation.tabs
+#     - navigation.sections
+#     - navigation.top
+#     - content.code.copy
+#     - content.tabs.link
+
+# plugins:
+#   - search
+
+# markdown_extensions:
+
+

poetry.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Poetry 2.3.1 and should not be changed by hand.
+package = []
+
+[metadata]
+lock-version = "2.1"
+python-versions = ">=3.9"
+content-hash = "db9b4c08b159b17b239e26c67ead7c37b82d9f9eb06550245ae3134c095f98f7"

pyproject.toml

@@ -0,0 +1,15 @@
+[tool.poetry]
+name = "uLib"
+version = "0.6.0"
+description = "CMT Cosmic Muon Tomography project uLib python bindings"
+authors = ["Andrea Rigoni Garola <andrea.rigoni@pd.infn.it>"]
+readme = "README.md"
+packages = [{ include = "uLib", from = "src/Python" }]
+build = "build_python.py"
+
+[tool.poetry.dependencies]
+python = ">=3.9"
+
+[build-system]
+requires = ["poetry-core>=2.0.0", "pybind11>=2.6.0", "cmake>=3.12"]
+build-backend = "poetry.core.masonry.api"

src/Core/CMakeLists.txt

@@ -1,10 +1,49 @@
 
-set(HEADERS Options.h
-            StaticInterface.h)
+set(HEADERS 
+    Archives.h 
+    Array.h 
+    Collection.h 
+    DataAllocator.h 
+    Debug.h 
+    Export.h 
+    Function.h 
+    Macros.h 
+    Mpl.h 
+    Object.h 
+    ObjectFactory.h
+    ObjectsContext.h
+    Options.h 
+    Serializable.h 
+    Signal.h 
+    Singleton.h 
+    SmartPointer.h 
+    StaticInterface.h 
+    StringReader.h 
+    Threads.h
+    Monitor.h
+    Types.h 
+    Uuid.h 
+    Vector.h
+)
 
-set(SOURCES Options.cpp)
+set(SOURCES 
+    Archives.cpp 
+    Debug.cpp 
+    Object.cpp 
+    ObjectFactory.cpp
+    ObjectsContext.cpp
+    Options.cpp 
+    Serializable.cpp 
+    Signal.cpp 
+    Uuid.cpp
+    Threads.cpp
+)
 
-set(LIBRARIES ${Boost_PROGRAM_OPTIONS_LIBRARY})
+set(LIBRARIES 
+    Boost::program_options 
+    Boost::serialization
+    OpenMP::OpenMP_CXX
+)
 
 set(libname ${PACKAGE_LIBPREFIX}Core)
 set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
@@ -14,14 +53,20 @@ add_library(${libname} SHARED ${SOURCES})
 set_target_properties(${libname} PROPERTIES
                       VERSION ${PROJECT_VERSION}
                       SOVERSION ${PROJECT_SOVERSION})
+if(USE_CUDA)
+  set(LIBRARIES ${LIBRARIES} CUDA::cudart)
+endif()
+
 target_link_libraries(${libname} ${LIBRARIES})
 
 install(TARGETS ${libname}
-        EXPORT "${PROJECT_NAME}Targets"
-        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
-
-install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Core)
-
+        EXPORT "uLibTargets"
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
 
+install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Core)
 
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Core/DataAllocator.h

@@ -0,0 +1,287 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_MATH_DATAALLOCATOR_H
+#define U_MATH_DATAALLOCATOR_H
+
+#include <algorithm>
+#include <cstring>
+#include <iostream>
+#include <stdexcept>
+#include <vector>
+
+#ifdef USE_CUDA
+#include <cuda_runtime.h>
+#include <thrust/device_vector.h>
+#endif
+
+namespace uLib {
+
+enum class MemoryDevice { RAM, VRAM };
+
+template <typename T> class DataAllocator {
+public:
+  DataAllocator(size_t size = 0, bool owns_objects = true)
+      : m_Size(size), m_RamData(nullptr), m_VramData(nullptr),
+        m_Device(MemoryDevice::RAM), m_OwnsObjects(owns_objects) {
+    if (m_Size > 0) {
+      if (m_OwnsObjects)
+        m_RamData = new T[m_Size]();
+      else
+        m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
+    }
+    // std::cout << "DataAllocator Constructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
+  }
+
+  DataAllocator(const DataAllocator<T> &other)
+      : m_Size(other.m_Size), m_RamData(nullptr), m_VramData(nullptr),
+        m_Device(other.m_Device), m_OwnsObjects(other.m_OwnsObjects) {
+    if (m_Size > 0) {
+      if (other.m_RamData) {
+        if (m_OwnsObjects)
+          m_RamData = new T[m_Size];
+        else
+          m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
+        
+        if (m_OwnsObjects) {
+            std::copy(other.m_RamData, other.m_RamData + m_Size, m_RamData);
+        } else {
+            std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
+        }
+      }
+#ifdef USE_CUDA
+      if (other.m_VramData) {
+        cudaMalloc((void **)&m_VramData, m_Size * sizeof(T));
+        cudaMemcpy(m_VramData, other.m_VramData, m_Size * sizeof(T),
+                   cudaMemcpyDeviceToDevice);
+      }
+#endif
+    }
+    // std::cout << "DataAllocator CopyConstructor: from=" << other.m_RamData << " to=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
+  }
+
+  ~DataAllocator() {
+    // std::cout << "DataAllocator Destructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
+    if (m_RamData) {
+      if (m_OwnsObjects)
+        delete[] m_RamData;
+      else
+        ::operator delete(m_RamData);
+      m_RamData = nullptr;
+    }
+#ifdef USE_CUDA
+    if (m_VramData) {
+      cudaFree(m_VramData);
+    }
+#endif
+  }
+
+  DataAllocator &operator=(const DataAllocator &other) {
+    if (this != &other) {
+      if (m_Size == other.m_Size && m_OwnsObjects != other.m_OwnsObjects) {
+          // Ownership changed but size is same: we must force reallocation
+          // to avoid using the wrong delete operator later.
+          size_t oldSize = m_Size;
+          m_Size = 0; 
+          resize(oldSize); // This will free the old buffer with the OLD ownership
+      }
+      m_OwnsObjects = other.m_OwnsObjects;
+      resize(other.m_Size);
+      m_Device = other.m_Device;
+      if (other.m_RamData) {
+        if (!m_RamData) {
+          if (m_OwnsObjects)
+            m_RamData = new T[m_Size];
+          else
+            m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
+        }
+        if (m_OwnsObjects) {
+            std::copy(other.m_RamData, other.m_RamData + m_Size, m_RamData);
+        } else {
+            std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
+        }
+      }
+#ifdef USE_CUDA
+      if (other.m_VramData) {
+        if (!m_VramData)
+          cudaMalloc((void **)&m_VramData, m_Size * sizeof(T));
+        cudaMemcpy(m_VramData, other.m_VramData, m_Size * sizeof(T),
+                   cudaMemcpyDeviceToDevice);
+      }
+#endif
+    }
+    // std::cout << "DataAllocator AssigmentOp: otherPtr=" << other.m_RamData << " thisPtr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
+    return *this;
+  }
+
+  void MoveToRAM() {
+    if (m_Device == MemoryDevice::RAM)
+      return;
+    if (!m_RamData && m_Size > 0) {
+      if (m_OwnsObjects)
+        m_RamData = new T[m_Size]();
+      else
+        m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
+    }
+#ifdef USE_CUDA
+    if (m_VramData && m_Size > 0) {
+      cudaMemcpy(m_RamData, m_VramData, m_Size * sizeof(T),
+                 cudaMemcpyDeviceToHost);
+    }
+#endif
+    m_Device = MemoryDevice::RAM;
+  }
+
+  void MoveToVRAM() {
+    if (m_Device == MemoryDevice::VRAM)
+      return;
+#ifdef USE_CUDA
+    if (!m_VramData && m_Size > 0) {
+      cudaMalloc((void **)&m_VramData, m_Size * sizeof(T));
+    }
+    if (m_RamData && m_Size > 0) {
+      cudaMemcpy(m_VramData, m_RamData, m_Size * sizeof(T),
+                 cudaMemcpyHostToDevice);
+    }
+#endif
+    m_Device = MemoryDevice::VRAM;
+  }
+
+  void resize(size_t size) {
+    if (m_Size == size)
+      return;
+
+    // std::cout << "DataAllocator Resize: from=" << m_Size << " to=" << size << " ptr=" << m_RamData << " own=" << m_OwnsObjects << std::endl;
+
+    T *newRam = nullptr;
+    T *newVram = nullptr;
+
+    if (size > 0) {
+      if (m_OwnsObjects)
+        newRam = new T[size]();
+      else
+        newRam = static_cast<T *>(::operator new(size * sizeof(T)));
+
+      if (m_RamData) {
+        if (m_OwnsObjects) {
+            std::copy(m_RamData, m_RamData + std::min(m_Size, size), newRam);
+        } else {
+            std::memcpy(newRam, m_RamData, std::min(m_Size, size) * sizeof(T));
+        }
+      }
+
+#ifdef USE_CUDA
+      cudaMalloc((void **)&newVram, size * sizeof(T));
+      if (m_VramData) {
+        cudaMemcpy(newVram, m_VramData, std::min(m_Size, size) * sizeof(T),
+                   cudaMemcpyDeviceToDevice);
+      }
+#endif
+    }
+
+    if (m_RamData) {
+      if (m_OwnsObjects)
+        delete[] m_RamData;
+      else
+        ::operator delete(m_RamData);
+    }
+#ifdef USE_CUDA
+    if (m_VramData)
+      cudaFree(m_VramData);
+#endif
+
+    m_Size = size;
+    m_RamData = newRam;
+    m_VramData = newVram;
+  }
+
+  size_t size() const { return m_Size; }
+
+  T &at(size_t index) {
+    MoveToRAM();
+    if (index >= m_Size)
+      throw std::out_of_range("Index out of range");
+    return m_RamData[index];
+  }
+
+  const T &at(size_t index) const {
+    const_cast<DataAllocator *>(this)->MoveToRAM();
+    if (index >= m_Size)
+      throw std::out_of_range("Index out of range");
+    return m_RamData[index];
+  }
+
+  T &operator[](size_t index) {
+    MoveToRAM();
+    return m_RamData[index];
+  }
+
+  const T &operator[](size_t index) const {
+    const_cast<DataAllocator *>(this)->MoveToRAM();
+    return m_RamData[index];
+  }
+
+  T *data() { return (m_Device == MemoryDevice::RAM) ? m_RamData : m_VramData; }
+  const T *data() const {
+    return (m_Device == MemoryDevice::RAM) ? m_RamData : m_VramData;
+  }
+
+  T *GetRAMData() { return m_RamData; }
+  const T *GetRAMData() const { return m_RamData; }
+
+  T *GetVRAMData() { return m_VramData; }
+  const T *GetVRAMData() const { return m_VramData; }
+
+  MemoryDevice GetDevice() const { return m_Device; }
+
+  // Iterator support for RAM operations
+  T *begin() {
+    MoveToRAM();
+    return m_RamData;
+  }
+  T *end() {
+    MoveToRAM();
+    return m_RamData + m_Size;
+  }
+  const T *begin() const {
+    const_cast<DataAllocator *>(this)->MoveToRAM();
+    return m_RamData;
+  }
+  const T *end() const {
+    const_cast<DataAllocator *>(this)->MoveToRAM();
+    return m_RamData + m_Size;
+  }
+
+private:
+  size_t m_Size;
+  T *m_RamData;
+  T *m_VramData;
+  MemoryDevice m_Device;
+  bool m_OwnsObjects;
+};
+
+} // namespace uLib
+
+#endif // U_MATH_DATAALLOCATOR_H

src/Core/Debug.h

@@ -36,7 +36,7 @@
 #include "SmartPointer.h"
 
 #include <boost/any.hpp>
-#include <TObject.h>
+
 
 namespace uLib {
 
@@ -119,8 +119,8 @@ public:
     void AddAdapter(AdapterInterface &ad) { m_a.push_back(Adapter(ad)); }
 
     void Update() {
-        foreach(Adapter &ad, m_a) {
-            foreach(DItem &item, m_v) {
+        for(Adapter &ad : m_a) {
+            for(DItem &item : m_v) {
                 item.m_adapter->operator()(ad, item.m_value);
             }
         }

src/Core/Export.h

@@ -23,95 +23,85 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_EXPORT_H
 #define U_CORE_EXPORT_H
 
-#include <utility>
 #include <cstddef> // NULL
 #include <iostream>
+#include <utility>
 
 #include <boost/config.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/preprocessor/stringize.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/type_traits/is_polymorphic.hpp>
 
-#include <boost/mpl/assert.hpp>
 #include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
+#include <boost/mpl/assert.hpp>
 #include <boost/mpl/bool.hpp>
+#include <boost/mpl/not.hpp>
 
-#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
-#include <boost/serialization/static_warning.hpp>
 #include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
 #include <boost/serialization/force_include.hpp>
 #include <boost/serialization/singleton.hpp>
+#include <boost/serialization/static_warning.hpp>
 
 #include <boost/archive/detail/register_archive.hpp>
 
-
 #include "Core/Archives.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
-
 namespace uLib {
 namespace Archive {
 namespace detail {
 namespace extra_detail {
 
-template<class T>
-struct guid_initializer
-{
-    void export_guid(mpl::false_) const {
-        // generates the statically-initialized objects whose constructors
-        // register the information allowing serialization of T objects
-        // through pointers to their base classes.
-        boost::archive::detail::
-                instantiate_ptr_serialization((T*)0, 0,
-                                              uLib::Archive::detail::adl_tag());
-    }
-    void export_guid(mpl::true_) const {
-    }
-    guid_initializer const & export_guid() const {
-        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
-        // note: exporting an abstract base class will have no effect
-        // and cannot be used to instantitiate serialization code
-        // (one might be using this in a DLL to instantiate code)
-        //BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
-        export_guid(boost::serialization::is_abstract< T >());
-        return *this;
-    }
+template <class T> struct guid_initializer {
+  void export_guid(boost::mpl::false_) const {
+    // generates the statically-initialized objects whose constructors
+    // register the information allowing serialization of T objects
+    // through pointers to their base classes.
+    boost::archive::detail::instantiate_ptr_serialization(
+        (T *)0, 0, uLib::Archive::detail::adl_tag());
+  }
+  void export_guid(boost::mpl::true_) const {}
+  guid_initializer const &export_guid() const {
+    BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
+    // note: exporting an abstract base class will have no effect
+    // and cannot be used to instantitiate serialization code
+    // (one might be using this in a DLL to instantiate code)
+    // BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
+    export_guid(boost::serialization::is_abstract<T>());
+    return *this;
+  }
 };
 
-template<typename T>
-struct init_guid;
+template <typename T> struct init_guid;
 
-} // anonymous
+} // namespace extra_detail
 } // namespace detail
 } // namespace Archive
 } // namespace uLib
 
-
-
-#define  ULIB_CLASS_EXPORT_IMPLEMENT(T)                      \
-    namespace uLib  {                                        \
-    namespace Archive {                                      \
-    namespace detail {                                       \
-    namespace extra_detail {                                 \
-    template<>                                               \
-    struct init_guid< T > {                                  \
-        static guid_initializer< T > const & g;              \
-    };                                                       \
-    guid_initializer< T > const & init_guid< T >::g =        \
-        ::boost::serialization::singleton<                   \
-            guid_initializer< T >                            \
-        >::get_mutable_instance().export_guid();             \
-    }}}}                                                     \
-/**/
+#define ULIB_CLASS_EXPORT_IMPLEMENT(T)                                         \
+  namespace uLib {                                                             \
+  namespace Archive {                                                          \
+  namespace detail {                                                           \
+  namespace extra_detail {                                                     \
+  template <> struct init_guid<T> {                                            \
+    static guid_initializer<T> const &g;                                       \
+  };                                                                           \
+  guid_initializer<T> const &init_guid<T>::g =                                 \
+      ::boost::serialization::singleton<                                       \
+          guid_initializer<T>>::get_mutable_instance()                         \
+          .export_guid();                                                      \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
+  /**/
 
 #endif // EXPORT_H

src/Core/Makefile.am

@@ -14,7 +14,6 @@ library_include_HEADERS = 	\
                                 Macros.h \
                                 Mpl.h \
                                 Object.h \
-                                ObjectProps.h \
                                 Options.h \
                                 Serializable.h \
                                 Signal.h \

src/Core/Monitor.h

@@ -0,0 +1,215 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_CORE_MONITOR_H
+#define U_CORE_MONITOR_H
+
+#include <mutex>
+#include <condition_variable>
+#include <chrono>
+#include <utility>
+
+namespace uLib {
+
+/**
+ * @brief Mutex class wraps std::timed_mutex and is used for thread synchronization.
+ */
+class Mutex {
+public:
+  Mutex() = default;
+  ~Mutex() = default;
+
+  /** @brief Locks the mutex, blocking if necessary. */
+  void Lock() { m_Mutex.lock(); }
+
+  /** @brief Unlocks the mutex. */
+  void Unlock() { m_Mutex.unlock(); }
+
+  /** @brief Tries to lock the mutex without blocking. */
+  bool TryLock() { return m_Mutex.try_lock(); }
+
+  /** @brief Tries to lock the mutex within a timeout in milliseconds. */
+  bool TryLockFor(int timeout_ms) {
+      if (timeout_ms < 0) { Lock(); return true; }
+      return m_Mutex.try_lock_for(std::chrono::milliseconds(timeout_ms));
+  }
+
+  /** @brief RAII helper for scoped locking. */
+  class ScopedLock {
+  public:
+    ScopedLock(Mutex &mutex) : m_Mutex(mutex) { m_Mutex.Lock(); }
+    ~ScopedLock() { m_Mutex.Unlock(); }
+  private:
+    Mutex &m_Mutex;
+    // Non-copyable
+    ScopedLock(const ScopedLock&) = delete;
+    ScopedLock& operator=(const ScopedLock&) = delete;
+  };
+
+  /** @brief Returns the underlying std::timed_mutex. */
+  std::timed_mutex& GetNative() { return m_Mutex; }
+
+private:
+  std::timed_mutex m_Mutex;
+  // Non-copyable
+  Mutex(const Mutex &) = delete;
+  Mutex &operator=(const Mutex &) = delete;
+};
+
+namespace detail {
+
+/** @brief Internal implementation for the ULIB_MUTEX_LOCK macros. */
+class ScopedTimedLock {
+public:
+    ScopedTimedLock(Mutex& mutex, int timeout_ms) 
+        : m_RawMutex(nullptr), m_MutexWrapper(&mutex), m_Locked(false) {
+        m_Locked = m_MutexWrapper->TryLockFor(timeout_ms);
+    }
+    
+    ScopedTimedLock(std::timed_mutex& mutex, int timeout_ms) 
+        : m_RawMutex(&mutex), m_MutexWrapper(nullptr), m_Locked(false) {
+        if (timeout_ms < 0) { m_RawMutex->lock(); m_Locked = true; }
+        else m_Locked = m_RawMutex->try_lock_for(std::chrono::milliseconds(timeout_ms));
+    }
+
+    ~ScopedTimedLock() {
+        if (m_Locked) {
+            if (m_RawMutex) m_RawMutex->unlock();
+            else if (m_MutexWrapper) m_MutexWrapper->Unlock();
+        }
+    }
+    
+    operator bool() const { return m_Locked; }
+    void unlock() { if (m_Locked) { 
+        if (m_RawMutex) m_RawMutex->unlock();
+        else if (m_MutexWrapper) m_MutexWrapper->Unlock();
+        m_Locked = false; 
+    } }
+
+private:
+    std::timed_mutex* m_RawMutex = nullptr;
+    Mutex* m_MutexWrapper = nullptr;
+    bool m_Locked;
+    
+    // Non-copyable/movable to be safe in the 'for' loop
+    ScopedTimedLock(const ScopedTimedLock&) = delete;
+    ScopedTimedLock& operator=(const ScopedTimedLock&) = delete;
+    ScopedTimedLock(ScopedTimedLock&&) = default; 
+};
+
+inline ScopedTimedLock makeScopedMutexLock(Mutex& mutex, int timeout_ms) {
+    return ScopedTimedLock(mutex, timeout_ms);
+}
+
+inline ScopedTimedLock makeScopedMutexLock(std::timed_mutex& mutex, int timeout_ms) {
+    return ScopedTimedLock(mutex, timeout_ms);
+}
+
+} // namespace detail
+
+/**
+ * @brief Macro for block-scoped locking of a static mutex.
+ * @param timeout Timeout in ms (-1 for infinite).
+ */
+#define ULIB_STATIC_LOCK(timeout) \
+    static std::timed_mutex __ulib_static_mutex; \
+    for (auto __ulib_lock = uLib::detail::makeScopedMutexLock(__ulib_static_mutex, timeout); \
+         __ulib_lock; \
+         __ulib_lock.unlock())
+
+/**
+ * @brief Macro for block-scoped locking of a provided mutex.
+ * @param mutex The uLib::Mutex or std::timed_mutex to lock.
+ * @param timeout Timeout in ms (-1 for infinite).
+ */
+#define ULIB_MUTEX_LOCK(mutex, timeout) \
+    for (auto __ulib_lock = uLib::detail::makeScopedMutexLock(mutex, timeout); \
+         __ulib_lock; \
+         __ulib_lock.unlock())
+
+/**
+ * @brief RecursiveMutex class wraps std::recursive_timed_mutex.
+ */
+class RecursiveMutex {
+public:
+  RecursiveMutex() = default;
+  ~RecursiveMutex() = default;
+
+  /** @brief Locks the mutex, blocking if necessary. */
+  void Lock() { m_Mutex.lock(); }
+
+  /** @brief Unlocks the mutex. */
+  void Unlock() { m_Mutex.unlock(); }
+
+  /** @brief Tries to lock the mutex without blocking. */
+  bool TryLock() { return m_Mutex.try_lock(); }
+
+  /** @brief Tries to lock the mutex within a timeout in milliseconds. */
+  bool TryLockFor(int timeout_ms) {
+      if (timeout_ms < 0) { Lock(); return true; }
+      return m_Mutex.try_lock_for(std::chrono::milliseconds(timeout_ms));
+  }
+
+  /** @brief RAII helper for scoped locking. */
+  class ScopedLock {
+  public:
+    ScopedLock(RecursiveMutex &mutex) : m_Mutex(mutex) { m_Mutex.Lock(); }
+    ~ScopedLock() { m_Mutex.Unlock(); }
+  private:
+    RecursiveMutex &m_Mutex;
+    ScopedLock(const ScopedLock&) = delete;
+    ScopedLock& operator=(const ScopedLock&) = delete;
+  };
+
+private:
+  std::recursive_timed_mutex m_Mutex;
+  RecursiveMutex(const RecursiveMutex &) = delete;
+  RecursiveMutex &operator=(const RecursiveMutex &) = delete;
+};
+
+/**
+ * @brief Monitor class provides a base for objects that need thread-safe access.
+ */
+template <typename T>
+class Monitor {
+protected:
+  T* m_Resource;
+  Mutex m_Mutex;
+
+public:
+  Monitor(T* resource) : m_Resource(resource) {}
+  virtual ~Monitor() { delete m_Resource; }
+
+  /** @brief Thread-safe access to the resource through a lambda. */
+  template <typename F>
+  auto Access(F f) -> decltype(f(*m_Resource)) {
+    Mutex::ScopedLock lock(m_Mutex);
+    return f(*m_Resource);
+  }
+};
+
+} // namespace uLib
+
+#endif // U_CORE_MONITOR_H

src/Core/Object.cpp

@@ -23,177 +23,233 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
-
 #include "config.h"
 
 #include "Object.h"
 #include "Vector.h"
 
-#include "boost/archive/polymorphic_xml_oarchive.hpp"
-#include "boost/archive/polymorphic_xml_iarchive.hpp"
-#include "boost/archive/polymorphic_text_oarchive.hpp"
-#include "boost/archive/polymorphic_text_iarchive.hpp"
-#include "boost/archive/polymorphic_binary_oarchive.hpp"
 #include "boost/archive/polymorphic_binary_iarchive.hpp"
+#include "boost/archive/polymorphic_binary_oarchive.hpp"
+#include "boost/archive/polymorphic_text_iarchive.hpp"
+#include "boost/archive/polymorphic_text_oarchive.hpp"
+#include "boost/archive/polymorphic_xml_iarchive.hpp"
+#include "boost/archive/polymorphic_xml_oarchive.hpp"
 
-
+#include <vector>
+#include "Property.h"
 
 namespace uLib {
 
-
-const char *Version::PackageName   = PACKAGE_NAME;
+const char *Version::PackageName = PACKAGE_NAME;
 const char *Version::VersionNumber = PACKAGE_VERSION;
-const char *Version::Release       = "x"; //SVN_REVISION;
-
+const char *Version::Release = "x"; // SVN_REVISION;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Object Private //
 
 class ObjectPrivate {
 public:
+  struct Signal {
+    GenericMFPtr sigptr;
+    std::string sigstr;
+    SignalBase *signal;
+  };
 
-    struct Signal {
-        GenericMFPtr  sigptr;
-        std::string   sigstr;
-        SignalBase   *signal;
-    };
+  struct Slot {
+    GenericMFPtr sloptr;
+    std::string slostr;
+  };
   
-    struct Slot {
-        GenericMFPtr sloptr;
-        std::string  slostr;
-    };
-
-
-    Vector<Signal> sigv;
-    Vector<Slot>   slov;
+  std::string m_InstanceName;
+  std::vector<Signal> sigv;
+  std::vector<Slot> slov;
+  std::vector<PropertyBase*> m_Properties;
+  std::vector<PropertyBase*> m_DynamicProperties;
+  bool m_SignalsBlocked;
 };
 
+// Implementations of Property methods
+void Object::RegisterProperty(PropertyBase* prop) {
+    if (prop) {
+        d->m_Properties.push_back(prop);
+    }
+}
 
+void Object::RegisterDynamicProperty(PropertyBase* prop) {
+    if (prop) {
+        for (auto* existing : d->m_DynamicProperties) {
+            if (existing == prop) return;
+        }
+        d->m_DynamicProperties.push_back(prop);
+    }
+}
 
+const std::vector<PropertyBase*>& Object::GetProperties() const {
+    return d->m_Properties;
+}
+
+PropertyBase* Object::GetProperty(const std::string& name) const {
+    for (auto* p : d->m_Properties) {
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
+    }
+    for (auto* p : d->m_DynamicProperties) {
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
+    }
+    return nullptr;
+}
+
+// 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.
+
+template <class ArchiveT>
+void Object::serialize(ArchiveT &ar, const unsigned int version) {
+    ar & boost::serialization::make_nvp("InstanceName", d->m_InstanceName);
+    for (auto* prop : d->m_Properties) {
+        prop->serialize(ar, version);
+    }
+}
+
+void Object::Updated() { ULIB_SIGNAL_EMIT(Object::Updated); }
+
+template <class ArchiveT>
+void Object::save_override(ArchiveT &ar, const unsigned int version) {}
+
+// Explicitly instantiate for all uLib archives
+template void Object::serialize(Archive::xml_oarchive &, const unsigned int);
+template void Object::serialize(Archive::xml_iarchive &, const unsigned int);
+template void Object::serialize(Archive::text_oarchive &, const unsigned int);
+template void Object::serialize(Archive::text_iarchive &, const unsigned int);
+template void Object::serialize(Archive::hrt_oarchive &, const unsigned int);
+template void Object::serialize(Archive::hrt_iarchive &, const unsigned int);
+template void Object::serialize(Archive::log_archive &, const unsigned int);
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // OBJECT IMPLEMENTATION
 
+Object::Object() : d(new ObjectPrivate) {
+    d->m_SignalsBlocked = false;
+}
+Object::Object(const Object &copy) : d(new ObjectPrivate) {
+    if (copy.d) {
+        d->m_InstanceName = copy.d->m_InstanceName;
+        d->m_SignalsBlocked = copy.d->m_SignalsBlocked;
+    }
+}
 
-
-Object::Object() :
-    d(new ObjectPrivate)
-{}
-
-Object::Object(const Object &copy) :
-    ObjectPropable(copy),
-    d(new ObjectPrivate(*copy.d))
-{}
+Object& Object::operator=(const Object &other) {
+    // Intentionally does NOT share 'd'. Each Object owns its own ObjectPrivate.
+    // Without this, the compiler-generated operator= would copy the 'd' pointer,
+    // causing two objects to share the same ObjectPrivate. When both are
+    // destroyed, 'd' would be deleted twice, corrupting the heap.
+    if (this != &other && other.d) {
+        d->m_InstanceName = other.d->m_InstanceName;
+        d->m_SignalsBlocked = other.d->m_SignalsBlocked;
+    }
+    return *this;
+}
 
 Object::~Object() {
+    for (auto* p : d->m_DynamicProperties) {
+        delete p;
+    }
     delete d;
 }
 
-void Object::DeepCopy(const Object &copy)
-{
-    // should lock to be tread safe //
-    memcpy(d,copy.d,sizeof(ObjectPrivate));
-    // ERROR! does not copy parameters ...                                      <<<< FIXXXXX
+void Object::DeepCopy(const Object &copy) {
+    if (this == &copy) return;
+    if (copy.d) d->m_InstanceName = copy.d->m_InstanceName;
+    std::cout << "Object DeepCopy: from d=" << copy.d << " to d=" << d << std::endl;
+    // Note: signals, slots and properties are intentionally not copied 
+    // to maintain instance uniquely and avoid duplicate registrations.
+    this->Updated();
 }
 
-
-
-
-
-void Object::SaveXml(std::ostream &os, Object &ob)
-{
-    Archive::xml_oarchive ar(os);
-    ar << boost::serialization::make_nvp("Object",ob);
+void Object::SaveXml(std::ostream &os, Object &ob) {
+  Archive::xml_oarchive ar(os);
+  ar << boost::serialization::make_nvp("Object", ob);
 }
 
-void Object::LoadXml(std::istream &is, Object &ob)
-{
-    Archive::xml_iarchive ar(is);
-    ar >> boost::serialization::make_nvp("Object",ob);
+void Object::LoadXml(std::istream &is, Object &ob) {
+  Archive::xml_iarchive ar(is);
+  ar >> boost::serialization::make_nvp("Object", ob);
 }
 
-
 // FINIRE
-void Object::SaveConfig(std::ostream &os, int version)
-{   
-    Archive::xml_oarchive ar(os);
-    ObjectPropable::serialize(ar,0);
+void Object::SaveConfig(std::ostream &os, int version) {
+  Archive::xml_oarchive ar(os);
 }
 
-void Object::LoadConfig(std::istream &is, int version)
-{
-    if(!props()) this->init_properties();
-    Archive::xml_iarchive ar(is);
-    ObjectPropable::serialize(ar,0);
+void Object::LoadConfig(std::istream &is, int version) {
+  Archive::xml_iarchive ar(is);
 }
 
-
-
-
-
-void Object::PrintSelf(std::ostream &o) const
-{
-    o << "OBJECT signals: ------------------\n";
-    Vector<ObjectPrivate::Signal>::Iterator itr;
-    for(itr = d->sigv.begin(); itr<d->sigv.end(); itr++)
-    {
-        o << "  signal:[ " << itr->sigstr << " ]\n";
-    }
-    o << "--------------------------------------\n\n";
+void Object::PrintSelf(std::ostream &o) const {
+  o << "OBJECT signals: ------------------\n";
+  for (const auto& sig : d->sigv) {
+    o << "  signal:[ " << sig.sigstr << " ]\n";
+  }
+  o << "--------------------------------------\n\n";
 }
 
-
-bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name)
-{
-    ObjectPrivate::Signal s = {fptr,std::string(name),sig};
-    d->sigv.push_back(s);
+bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
+                           const char *name) {
+  ObjectPrivate::Signal s = {fptr, std::string(name), sig};
+  d->sigv.push_back(s);
+  return true;
 }
 
-bool Object::addSlotImpl(GenericMFPtr fptr, const char *name)
-{
-    ObjectPrivate::Slot s = {fptr,std::string(name)};
-    d->slov.push_back(s);
+bool Object::addSlotImpl(GenericMFPtr fptr, const char *name) {
+  ObjectPrivate::Slot s = {fptr, std::string(name)};
+  d->slov.push_back(s);
+  return true;
 }
 
-SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const
-{
-    for(int i=0; i<d->sigv.size(); ++i)
-    {
-        if(d->sigv[i].sigptr == fptr)
-            return d->sigv[i].signal;
-    }
-    return NULL;
+SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const {
+  for (int i = 0; i < d->sigv.size(); ++i) {
+    if (d->sigv[i].sigptr == fptr)
+      return d->sigv[i].signal;
+  }
+  return NULL;
 }
 
-SignalBase *Object::findSignalImpl(const char *name) const
-{
-    std::string in(name);
-    for(int i=0; i<d->sigv.size(); ++i)
-    {
-        if(d->sigv[i].sigstr == in)
-            return d->sigv[i].signal;
-    }
-    return NULL;
+SignalBase *Object::findSignalImpl(const char *name) const {
+  std::string in(name);
+  for (int i = 0; i < d->sigv.size(); ++i) {
+    if (d->sigv[i].sigstr == in)
+      return d->sigv[i].signal;
+  }
+  return NULL;
 }
 
-GenericMFPtr *Object::findSlotImpl(const char *name) const
-{
-    std::string in(name);
-    for(int i=0; i<d->slov.size(); ++i)
-    {
-        if(d->slov[i].slostr == in)
-            return &d->slov[i].sloptr;
-    }
-    return NULL;
+GenericMFPtr *Object::findSlotImpl(const char *name) const {
+  std::string in(name);
+  for (int i = 0; i < d->slov.size(); ++i) {
+    if (d->slov[i].slostr == in)
+      return &d->slov[i].sloptr;
+  }
+  return NULL;
 }
 
+const std::string& Object::GetInstanceName() const {
+  return d->m_InstanceName;
+}
 
+void Object::SetInstanceName(const std::string& name) {
+  d->m_InstanceName = name;
+  this->Updated();
+}
  
+bool Object::blockSignals(bool block) {
+  bool old = d->m_SignalsBlocked;
+  d->m_SignalsBlocked = block;
+  return old;
+}
+ 
+bool Object::signalsBlocked() const {
+  return d->m_SignalsBlocked;
+}
 
 // std::ostream &
 // operator << (std::ostream &os, uLib::Object &ob)
@@ -218,10 +274,4 @@ GenericMFPtr *Object::findSlotImpl(const char *name) const
 //     return is;
 // }
 
-
-
-
-} // uLib
-
-
-
+} // namespace uLib

src/Core/Object.h

@@ -23,200 +23,231 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_OBJECT_H
 #define U_CORE_OBJECT_H
 
 #include <iostream>
+#include <string>
 
 // WARNING: COPILE ERROR if this goes after mpl/vector //
-//#include "Core/Vector.h"
+// #include "Core/Vector.h"
 
-#include "Core/Types.h"
 #include "Core/Debug.h"
+#include "Core/Types.h"
 
 #include "Core/Function.h"
 #include "Core/Signal.h"
 
 #include "Core/Mpl.h"
 #include "Core/Serializable.h"
-#include "Core/ObjectProps.h"
 #include "Core/Uuid.h"
 
 namespace boost {
 namespace archive {
 class polymorphic_iarchive;
 class polymorphic_oarchive;
-} // archive
-} // boost
-
+} // namespace archive
+} // namespace boost
 
 namespace uLib {
 
+class PropertyBase;
 
 class Version {
 public:
-    static const char *PackageName;
-    static const char *VersionNumber;
-    static const char *Release;
+  static const char *PackageName;
+  static const char *VersionNumber;
+  static const char *Release;
 };
 
-
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 //// OBJECT ////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
-
 /**
  * @brief Object class is the object base implementation for uLib Framework.
  */
-class Object : public ObjectPropable
-{
-
+class Object {
 
 public:
-    //    std::string name;
-    //    void PrintName() { std::cout << "Ob name: " << name << "\n"; }
+  //    std::string name;
+  //    void PrintName() { std::cout << "Ob name: " << name << "\n"; }
 
-    Object();
-    Object(const Object &copy);
-    ~Object();
+  Object();
+  Object(const Object &copy);
+  virtual ~Object();
 
-    ////////////////////////////////////////////////////////////////////////////
-    // PARAMETERS //
+  virtual const char * GetClassName() const { return "Object"; }
 
-    // FIXX !!!
-    virtual void DeepCopy(const Object &copy);
+  const std::string& GetInstanceName() const;
+  void SetInstanceName(const std::string& name);
   
+  /** @brief Temporarily blocks all signal emissions from this object. Returns previous state. */
+  bool blockSignals(bool block);
   
-    ////////////////////////////////////////////////////////////////////////////
-    // SERIALIZATION //
+  /** @brief Checks if signals are currently blocked. */
+  bool signalsBlocked() const;
 
-    template <class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version)    {
-                ObjectPropable::serialize(ar,version);
+  ////////////////////////////////////////////////////////////////////////////
+  // PROPERTIES //
+  void RegisterProperty(PropertyBase* prop);
+  void RegisterDynamicProperty(PropertyBase* prop);
+  const std::vector<PropertyBase*>& GetProperties() const;
+  PropertyBase* GetProperty(const std::string& name) const;
+
+  ////////////////////////////////////////////////////////////////////////////
+  // PARAMETERS //
+
+  // FIXX !!!
+  virtual void DeepCopy(const Object &copy);
+
+  ////////////////////////////////////////////////////////////////////////////
+  // SERIALIZATION //
+
+  template <class ArchiveT>
+  void serialize(ArchiveT &ar, const unsigned int version);
+
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::log_archive & ar, const unsigned int version) {}
+
+  template <class ArchiveT>
+  void save_override(ArchiveT &ar, const unsigned int version);
+
+  void SaveConfig(std::ostream &os, int version = 0);
+  void LoadConfig(std::istream &is, int version = 0);
+
+  static void SaveXml(std::ostream &os, Object &ob);
+  static void LoadXml(std::istream &is, Object &ob);
+
+  ////////////////////////////////////////////////////////////////////////////
+  // SIGNALS //
+
+  signals:
+  virtual void Updated();
+
+  // Qt4 style connector //
+  static bool connect(const Object *ob1, const char *signal_name,
+                      const Object *receiver, const char *slot_name) {
+    //        // NOT WORKING YET //
+    //        1) find slot pointer from name
+    //        SignalBase   *sig = ob1->findSignal(signal_name);
+    //        GenericMFPtr *slo = receiver->findSlot(slot_name);
+    //        if(sig && slo)
+    //            return Object::connect(sig,slo->operator ()(),receiver);
+    //        else return false;
+    return false;
+  }
+
+  // Qt5 style connector //
+  template <typename Func1, typename Func2>
+  static Connection
+  connect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
+          typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
+    SignalBase *sigb = sender->findOrAddSignal(sigf);
+    return ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(sigb, slof,
+                                                                    receiver);
+  }
+
+  // Lambda/Function object connector //
+  template <typename Func1, typename SlotT>
+  static Connection connect(typename FunctionPointer<Func1>::Object *sender,
+                      Func1 sigf, SlotT slof) {
+    SignalBase *sigb = sender->findOrAddSignal(sigf);
+    typedef typename FunctionPointer<Func1>::SignalSignature SigSignature;
+    typedef typename Signal<SigSignature>::type SigT;
+    return reinterpret_cast<SigT *>(sigb)->connect(slof);
+  }
+
+  template <typename Func1, typename Func2>
+  static bool
+  disconnect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
+             typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
+    // TODO: implement actual disconnect in Signal.h //
+    return true;
+  }
+
+  template <typename FuncT>
+  static inline Connection connect(SignalBase *sigb, FuncT slof, Object *receiver) {
+    return ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(sigb, slof,
+                                                                    receiver);
+  }
+
+  template <typename FuncT>
+  inline
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+      addSignal(FuncT fun, const char *name) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    SignalBase *sig = NewSignal(fun);
+    addSignalImpl(sig, fun, name);
+    return (SigT *)sig;
+  }
+
+  template <typename FuncT> inline bool addSlot(FuncT fun, const char *name) {
+    return this->addSlotImpl(GenericMFPtr(fun), name);
+  }
+
+  template <typename FuncT>
+  inline
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+      findSignal(FuncT fptr) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    return (SigT *)findSignalImpl(GenericMFPtr(fptr));
+  }
+
+  template <typename FuncT>
+  inline
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+      findOrAddSignal(FuncT fptr) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    SignalBase *sig = findSignalImpl(GenericMFPtr(fptr));
+    if (!sig) {
+      sig = NewSignal(fptr);
+      addSignalImpl(sig, fptr, "signal_name_to_be_implemented");
     }
-    template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version) {}
+    return (SigT *)sig;
+  }
 
-    void SaveConfig(std::ostream &os, int version = 0);
-    void LoadConfig(std::istream &is, int version = 0);
+  inline SignalBase *findSignal(const char *name) const {
+    return findSignalImpl(name);
+  }
 
-    static void SaveXml(std::ostream &os, Object &ob);
-    static void LoadXml(std::istream &is, Object &ob);
+  inline GenericMFPtr *findSlot(const char *name) const {
+    return findSlotImpl(name);
+  }
 
+  void PrintSelf(std::ostream &o) const;
 
-
-    ////////////////////////////////////////////////////////////////////////////
-    // SIGNALS //
-
-    // Qt4 style connector //
-    static bool connect(const Object *ob1, const char *signal_name, const Object *receiver, const char *slot_name) {
-        //        // NOT WORKING YET //
-        //        1) find slot pointer from name
-        //        SignalBase   *sig = ob1->findSignal(signal_name);
-        //        GenericMFPtr *slo = receiver->findSlot(slot_name);
-        //        if(sig && slo)
-        //            return Object::connect(sig,slo->operator ()(),receiver);
-        //        else return false;
-    }
-
-    // Qt5 style connector //
-    template <typename Func1, typename Func2>
-    static bool connect( typename FunctionPointer<Func1>::Object *sender,   Func1 sigf,
-                         typename FunctionPointer<Func2>::Object *receiver, Func2 slof)
-    {
-        SignalBase *sigb = sender->findOrAddSignal(sigf);
-        typedef boost::signals2::signal<typename FunctionPointer<Func2>::SignalSignature> SigT;
-        ConnectSignal(sigb,slof,receiver);
-    }
-
-    template <typename FuncT>
-    static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
-        ConnectSignal(sigb,slof,receiver);
-    }
-
-
-    template< typename FuncT >
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    addSignal(FuncT fun, const char *name) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        SignalBase *sig = NewSignal(fun);
-        addSignalImpl(sig,fun,name);
-        return (SigT *)sig;
-    }
-
-    template< typename FuncT>
-    inline bool addSlot(FuncT fun, const char *name) {
-        this->addSlotImpl(GenericMFPtr(fun),name);
-    }
-
-    template < typename FuncT >
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    findSignal(FuncT fptr)
-    {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        return (SigT *)findSignalImpl(GenericMFPtr(fptr));
-    }
-
-    template < typename FuncT >
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    findOrAddSignal(FuncT fptr)
-    {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        SignalBase *sig = findSignalImpl(GenericMFPtr(fptr));
-        if(!sig) {
-            sig = NewSignal(fptr);
-            addSignalImpl(sig,fptr,"signal_name_to_be_implemented");
-        }
-        return (SigT *)sig;
-    }
-
-
-    inline SignalBase *
-    findSignal(const char *name) const
-    {
-        return findSignalImpl(name);
-    }
-
-    inline GenericMFPtr *
-    findSlot(const char *name) const
-    {
-        return findSlotImpl(name);
-    }
-
-
-    void PrintSelf(std::ostream &o) const;
-
-    inline const Object& operator = (const Object &copy)
-    { this->DeepCopy(copy); return *this; }
-
+  Object &operator=(const Object &other);
 
 private:
-    bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
-    bool addSlotImpl(GenericMFPtr fptr, const char *name);
-    SignalBase   *findSignalImpl(const GenericMFPtr &fptr) const;
-    SignalBase   *findSignalImpl(const char *name) const;
-    GenericMFPtr *findSlotImpl(const char *name) const;
+  bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
+  bool addSlotImpl(GenericMFPtr fptr, const char *name);
+  SignalBase *findSignalImpl(const GenericMFPtr &fptr) const;
+  SignalBase *findSignalImpl(const char *name) const;
+  GenericMFPtr *findSlotImpl(const char *name) const;
 
-    friend class boost::serialization::access;
-    friend class ObjectPrivate;
-    class ObjectPrivate *d;
+  friend class boost::serialization::access;
+  friend class ObjectPrivate;
+  class ObjectPrivate *d;
 };
 
-
-
-} // uLib
+} // namespace uLib
 
 ////////////////////////////////////////////////////////////////////////////////
 
-//std::ostream & operator << (std::ostream &os, uLib::Object &ob);
-//std::ostream & operator << (std::ostream &os, uLib::Object *ob);
-//std::istream & operator >> (std::istream &is, uLib::Object &ob);
-
+// std::ostream & operator << (std::ostream &os, uLib::Object &ob);
+// std::ostream & operator << (std::ostream &os, uLib::Object *ob);
+// std::istream & operator >> (std::istream &is, uLib::Object &ob);
 
 #endif // U_OBJECT_H

src/Core/ObjectFactory.cpp

@@ -0,0 +1,32 @@
+#include "ObjectFactory.h"
+
+namespace uLib {
+
+ObjectFactory& ObjectFactory::Instance() {
+    static ObjectFactory instance;
+    return instance;
+}
+
+void ObjectFactory::Register(const std::string& className, FactoryFunction func) {
+    if (m_factoryMap.find(className) == m_factoryMap.end()) {
+        m_factoryMap[className] = func;
+    }
+}
+
+Object* ObjectFactory::Create(const std::string& className) {
+    auto it = m_factoryMap.find(className);
+    if (it != m_factoryMap.end()) {
+        return (it->second)();
+    }
+    return nullptr;
+}
+
+std::vector<std::string> ObjectFactory::GetRegisteredClasses() const {
+    std::vector<std::string> classes;
+    for (auto const& [name, func] : m_factoryMap) {
+        classes.push_back(name);
+    }
+    return classes;
+}
+
+} // namespace uLib

src/Core/ObjectFactory.h

@@ -0,0 +1,68 @@
+#ifndef U_CORE_OBJECTFACTORY_H
+#define U_CORE_OBJECTFACTORY_H
+
+#include <string>
+#include <map>
+#include <vector>
+#include <functional>
+#include "Core/Object.h"
+
+namespace uLib {
+
+/**
+ * @brief Singleton factory for dynamic Object instantiation based on class name.
+ */
+class ObjectFactory {
+public:
+    typedef std::function<Object*()> FactoryFunction;
+
+    /** @brief Get the singleton instance. */
+    static ObjectFactory& Instance();
+
+    /** @brief Register a factory function for a given class name. */
+    void Register(const std::string& className, FactoryFunction func);
+
+    /** @brief Create a new instance of the specified class. */
+    Object* Create(const std::string& className);
+
+    /** @brief Get the names of all registered classes. */
+    std::vector<std::string> GetRegisteredClasses() const;
+
+private:
+    ObjectFactory() = default;
+    ~ObjectFactory() = default;
+
+    // Prevent copy and assignment
+    ObjectFactory(const ObjectFactory&) = delete;
+    ObjectFactory& operator=(const ObjectFactory&) = delete;
+
+    std::map<std::string, FactoryFunction> m_factoryMap;
+};
+
+/**
+ * @brief Helper class to statically register a factory function.
+ */
+template <typename T>
+class ObjectRegistrar {
+public:
+    ObjectRegistrar(const std::string& className) {
+        ObjectFactory::Instance().Register(className, []() -> Object* { return new T(); });
+    }
+};
+
+#define ULIB_REG_CONCAT_IMPL(a, b) a##b
+#define ULIB_REG_CONCAT(a, b) ULIB_REG_CONCAT_IMPL(a, b)
+
+/**
+ * @brief Macro to register a class to the factory.
+ * Put this in the .cpp file of the class.
+ */
+#define ULIB_REGISTER_OBJECT(className) \
+    static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(g_ObjectRegistrar_, __LINE__)(#className);
+
+#define ULIB_REGISTER_OBJECT_NAME(className, registeredName) \
+    static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(g_ObjectRegistrar_, __LINE__)(registeredName);
+
+} // namespace uLib
+
+#endif // U_CORE_OBJECTFACTORY_H

src/Core/ObjectProps.h

@@ -1,278 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#ifndef U_OBJECTPROPS_H
-#define U_OBJECTPROPS_H
-
-
-
-#include <boost/algorithm/string/replace.hpp>
-
-#include <Core/Mpl.h>
-#include <Core/Types.h>
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// MACROS //
-
-
-#define ULIB_props() \
-    public: struct ObjectProps;		                               \
-    virtual void init_properties();                                \
-    inline struct ObjectProps &p() { /* static const unsigned int offset = props_offset(this); */ \
-    /* NON FUNZIA!  return * (struct ObjectProps *)(reinterpret_cast<char*>(props())+offset);  */ \
-    return *props()->ptr<ObjectProps>(); }                                                        \
-    typedef uLib::mpl::bool_<true>::type propable_trait;                                          \
-    public: struct DLL_PUBLIC ObjectProps
-
-#define properties() ULIB_props()
-
-#define default(vlaue)
-
-#define $$ p()
-
-#define $(_name) props_ref<_name>()
-
-#define $_init()                                                               \
-    if(props(this)) return;                                                    \
-    props_new(this);                                                           \
-    uLib::detail::ObjectProps::initializer::init_object_baselist(this);
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-namespace boost {
-namespace serialization {
-class access;
-}
-}
-
-
-namespace uLib {
-
-namespace detail {
-
-struct ObjectProps {
-
-    /** Define a trait has_member to find if an Object is Propable*/
-    BOOST_MPL_HAS_XXX_TRAIT_DEF(propable_trait)
-
-    /** IsA ProbapleObject Implementation Template */
-    template <class T>
-    struct IsA : has_propable_trait<T> {};
-
-    /** Lambda to get Props member type */
-    template <class T>
-    struct props_type {
-        typedef typename T::ObjectProps type;
-    };
-
-    template <typename T>
-    struct get_props {
-
-        /** CFList has result but this method check for has BaseList */
-        typedef typename detail::TypeIntrospection::child_first<T>::type CFTypeList;
-
-        /** Filter List items that have not Propable feature */
-        typedef typename mpl::filter_view< CFTypeList, IsA<mpl::_> >::type FilteredCFTypeList;
-
-        /** Get Props from each Parent in Seq */
-        typedef typename mpl::transform_view< FilteredCFTypeList, props_type<mpl::_> >::type type;
-
-
-        // qui sotto ho un problema che ho temporaneamente tamponato          //
-        // ovvero ho usato child_first_impl per ottenere la lista delle basi  //
-        // vorrei farlo facendo un pop_back ma non va forse perche il tipo    //
-        // non e' corretto. //
-
-        /** Get Parent list from CFTypeList */
-        typedef typename detail::TypeIntrospection::child_first_impl<T>::Childs CFBaseList;
-
-        /** Filter Parents that have not Propable feature */
-        typedef typename mpl::filter_view< CFBaseList, IsA<mpl::_> >::type FilteredCFBaseList;
-    };
-
-
-
-    // TODO: convert to pp const value,
-    // (non so se sia possibile con il dinamic casting intanto funziona cosi' )
-    template <typename T1, typename T2>
-    static unsigned int measure_offset(T1 base, T2 derived) {
-        return reinterpret_cast<char*>(derived) - reinterpret_cast<char*>(base);
-    }
-
-    struct initializer {
-
-        template <class _ObjectT>
-        struct lambda_init_object {
-            _ObjectT *o;
-            lambda_init_object(_ObjectT *o) : o(o) {}
-            template<class T> void operator()(T) {
-                o->T::init_properties();
-            }
-        };
-
-
-        /**
-         * This calls the internal init_properties() virtual function for each
-         * object parent defined in BaseList only if it is propable
-         */
-        template <class T>
-        static void init_object_baselist(T *o) {
-            typedef typename uLib::detail::ObjectProps::get_props<T>::FilteredCFBaseList CFBaseList;
-            mpl::for_each<CFBaseList>(lambda_init_object<T>(o));
-        }
-
-        /**
-         * This calls the internal init_properties() virtual function only if
-         * object is propable ( implementation if not propable )
-         */
-        template <class T>
-        static
-        typename boost::enable_if<mpl::not_<IsA<T> >,void>::type
-        init_object(T *o) {
-            ; // do nothing //
-        }
-
-        /**
-         * This calls the internal init_properties() virtual function only if
-         * object is propable ( implementation if propable )
-         */
-        template <class T>
-        static
-        typename boost::enable_if<IsA<T>,void>::type
-        init_object(T *o) {
-            o->init_properties();
-        }
-
-    };
-
-    template <class ThisClass, class Archive>
-    struct serialize_baselist {
-        ThisClass & m_object;
-        Archive   & m_ar;
-        serialize_baselist(ThisClass &o, Archive &ar) : m_object(o), m_ar(ar) {}
-        template <class T> void operator()(T &o) {
-            // T is taken fron get_props<BaseList>::FilteredPList types to get
-            // type_info_name that is the type name defined by Type macro
-            typedef typename props_type<T>::type PType;
-            std::string name(TypeIntrospection::access<T>::type_info::name);
-            boost::algorithm::replace_all(name,"::","_");
-            m_ar & boost::serialization::make_nvp(
-                        name.c_str() ,
-                        boost::serialization::base_object<PType>(m_object));
-        }
-    };
-
-};
-
-} // detail
-
-
-
-
-
-struct ObjectPropsBase {
-    virtual ~ObjectPropsBase() {}
-    virtual ObjectPropsBase *copy() = 0;
-
-    template <class T> inline T *ptr() { return dynamic_cast<T*>(this); }
-
-    template<class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) {}
-};
-
-
-
-template <class T>
-struct ObjectPropsImpl :
-        ObjectPropsBase,
-        ULIB_MPL_INHERIT_NOFOLD_SEQ(typename uLib::detail::ObjectProps::get_props<T>::type)
-{    
-    typedef ObjectPropsImpl<T> ThisClass;
-    typedef typename uLib::detail::ObjectProps::get_props<T>::type CFList;
-    typedef typename uLib::detail::ObjectProps::get_props<T>::FilteredCFTypeList FilteredCFTypeList;
-    ObjectPropsBase *copy() { return new ThisClass(*this); }
-
-    template<class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) {
-        boost::serialization::void_cast_register<ThisClass,ObjectPropsBase>();
-        mpl::for_each<FilteredCFTypeList>(detail::ObjectProps::serialize_baselist<ThisClass,ArchiveT>(*this,ar));
-    }
-};
-
-
-class ObjectPropable {
-
-    ObjectPropsBase *m_props;
-    friend class uLib::detail::ObjectProps;
-    friend class boost::serialization::access;
-public:
-    ObjectPropable() : m_props(NULL) {}
-    ObjectPropable(const ObjectPropable &c) { if(c.m_props) m_props = c.m_props->copy(); else m_props = NULL; }
-    ~ObjectPropable() { if(m_props) delete m_props; }
-
-
-    template <class T> inline typename T::ObjectProps&  props_ref() const { if(m_props) return *m_props->ptr<typename T::ObjectProps>(); else exit(1); }
-    template <class T> inline typename T::ObjectProps*  props(T *ptr = NULL) const { if(m_props) return m_props->ptr<typename T::ObjectProps>(); else return NULL; }
-protected:
-    ObjectPropsBase *props() const { return m_props; }
-    template <class T> inline void props_new(T* ptr = NULL) { if(!m_props) m_props = new ObjectPropsImpl<T>; }
-
-    /** NOT working dynamic cache casting */
-    template <class T> inline unsigned int props_offset(T *ptr) const
-    { if(m_props) return detail::ObjectProps::measure_offset(m_props,m_props->ptr<T>()); else return -1; }
-
-
-    template<class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) {
-        if(m_props) ar & boost::serialization::make_nvp("properties",m_props);
-    }
-
-public:
-    /**
-     * ObjectPropable is not directly propable itself to prevent Basclass
-     * duplication in inherit_nofold. And for the same reason ANY VIRTUAL BASE
-     * SHOULD NOT BE PROPABLE
-     */
-    virtual void init_properties() {}
-
-};
-
-} // uLib
-
-
-
-
-
-
-
-#endif // U_OBJECTPROPS_H

src/Core/ObjectsContext.cpp

@@ -0,0 +1,63 @@
+#include "Core/ObjectsContext.h"
+#include <algorithm>
+
+namespace uLib {
+
+ObjectsContext::ObjectsContext() : Object() {}
+
+ObjectsContext::~ObjectsContext() {}
+
+void ObjectsContext::AddObject(Object* obj) {
+    if (obj && std::find(m_objects.begin(), m_objects.end(), obj) == m_objects.end()) {
+        m_objects.push_back(obj);
+        // Connect child's update to context's update to trigger re-renders
+        Object::connect(obj, &Object::Updated, this, &Object::Updated);
+        ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
+        this->Updated(); // Signal that the context has been updated
+    }
+}
+
+void ObjectsContext::RemoveObject(Object* obj) {
+    auto it = std::find(m_objects.begin(), m_objects.end(), obj);
+    if (it != m_objects.end()) {
+        Object* removedObj = *it;
+        m_objects.erase(it);
+        ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, removedObj);
+        this->Updated(); // Signal that the context has been updated
+    }
+}
+
+void ObjectsContext::Clear() {
+    if (!m_objects.empty()) {
+        for (auto obj : m_objects) {
+            ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, obj);
+        }
+        m_objects.clear();
+        this->Updated();
+    }
+}
+
+const std::vector<Object*>& ObjectsContext::GetObjects() const {
+    return m_objects;
+}
+
+size_t ObjectsContext::GetCount() const {
+    return m_objects.size();
+}
+
+Object* ObjectsContext::GetObject(size_t index) const {
+    if (index < m_objects.size()) {
+        return m_objects[index];
+    }
+    return nullptr;
+}
+
+void ObjectsContext::ObjectAdded(Object* obj) {
+    ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
+}
+
+void ObjectsContext::ObjectRemoved(Object* obj) {
+    ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, obj);
+}
+
+} // namespace uLib

src/Core/ObjectsContext.h

@@ -0,0 +1,67 @@
+#ifndef U_CORE_OBJECTS_CONTEXT_H
+#define U_CORE_OBJECTS_CONTEXT_H
+
+#include "Core/Object.h"
+#include <vector>
+
+namespace uLib {
+
+/**
+ * @brief ObjectsContext represents a collection of Object instances.
+ */
+class ObjectsContext : virtual public Object {
+public:
+    ObjectsContext();
+    virtual ~ObjectsContext();
+
+    virtual const char * GetClassName() const { return "ObjectsContext"; }
+
+    /**
+     * @brief Adds an object to the context.
+     * @param obj Pointer to the object to add.
+     */
+    virtual void AddObject(Object* obj);
+
+    /**
+     * @brief Removes an object from the context.
+     * @param obj Pointer to the object to remove.
+     */
+    virtual void RemoveObject(Object* obj);
+
+    /**
+     * @brief Clears all objects from the context.
+     */
+    void Clear();
+
+    /**
+     * @brief Returns the collection of objects.
+     * @return Const reference to the vector of object pointers.
+     */
+    const std::vector<Object*>& GetObjects() const;
+    
+    signals:
+    /** @brief Signal emitted when an object is added. */
+    virtual void ObjectAdded(Object* obj);
+    /** @brief Signal emitted when an object is removed. */
+    virtual void ObjectRemoved(Object* obj);
+
+    /**
+     * @brief Returns the number of objects in the context.
+     * @return Size of the collection.
+     */
+    size_t GetCount() const;
+
+    /**
+     * @brief Returns an object by index.
+     * @param index The index of the object.
+     * @return Pointer to the object or nullptr if index is out of bounds.
+     */
+    Object* GetObject(size_t index) const;
+
+private:
+    std::vector<Object*> m_objects;
+};
+
+} // namespace uLib
+
+#endif // U_CORE_OBJECTS_CONTEXT_H

src/Core/Options.cpp

@@ -31,6 +31,9 @@
 
 #include <boost/program_options.hpp>
 
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/ini_parser.hpp>
+
 
 //class boost::program_options::error_with_option_name;
 //template<> boost::program_options::typed_value<int> boost::program_options::value<int>();
@@ -74,6 +77,23 @@ void Options::parse_config_file(const char *fname)
     }
 }
 
+void Options::save_config_file(const char *fname) {
+    std::ofstream os;
+    os.open(fname);
+    
+    using boost::property_tree::ptree;
+
+    ptree root;
+
+
+    std::cout << m_configuration << "\n";
+    std::cout << m_global << "\n";
+
+    write_ini( std::cout, root );
+
+}
+
+
 bool Options::count(const char *str) const
 {
     return (m_vm.count(str));

src/Core/Options.h

@@ -160,6 +160,8 @@ public:
 
     void parse_config_file(const char *fname);
 
+    void save_config_file(const char *fname);
+
     template <typename T>
     static inline boost::program_options::typed_value<T>* value(T *v, T dvalue) {
         boost::program_options::typed_value<T> *r = boost::program_options::value<T>(v);

src/Core/Property.h

@@ -0,0 +1,303 @@
+#ifndef U_CORE_PROPERTY_H
+#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"
+
+namespace uLib {
+
+/**
+ * @brief Base class for properties to allow runtime listing and identification.
+ */
+class PropertyBase : public Object {
+public:
+  virtual ~PropertyBase() {}
+  virtual const std::string& GetName() const = 0;
+  virtual const char* GetTypeName() const = 0;
+  virtual std::string GetValueAsString() const = 0;
+  virtual std::type_index GetTypeIndex() const = 0; // Added
+  virtual const std::string& GetUnits() const = 0;
+  virtual void SetUnits(const std::string& units) = 0;
+  virtual const std::vector<std::string>& GetEnumLabels() const {
+      static std::vector<std::string> empty;
+      return empty;
+  }
+  virtual const std::string& GetGroup() const = 0;
+  virtual void SetGroup(const std::string& group) = 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;
+};
+
+/**
+ * @brief Template class for typed properties.
+ */
+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 = "", const std::string& group = "")
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(valuePtr), m_own(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 = "", const std::string& group = "")
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(new T(defaultValue)), m_own(true) {
+      if (m_owner) {
+          m_owner->RegisterProperty(this);
+      }
+  }
+
+  virtual ~Property() {
+      if (m_own) delete m_value;
+  }
+
+  // Identification
+  virtual const std::string& GetName() const override { return m_name; }
+  virtual const char* GetTypeName() const override { return typeid(T).name(); }
+  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 {
+      try {
+          return boost::lexical_cast<std::string>(*m_value);
+      } catch (const boost::bad_lexical_cast&) {
+          std::stringstream ss;
+          ss << *m_value;
+          return ss.str();
+      }
+  }
+
+  // Accessors
+  const T& Get() const { return *m_value; }
+  void Set(const T& value) {
+    if (*m_value != value) {
+      *m_value = value;
+      ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged);
+      this->Updated();
+      if (m_owner) m_owner->Updated();
+    }
+  }
+
+  // Operators for seamless usage
+  operator const T&() const { return *m_value; }
+  Property& operator=(const T& value) {
+    Set(value);
+    return *this;
+  }
+
+  // Signals
+  signals:
+  virtual void PropertyChanged() { ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged); }
+
+  // Serialization
+  template <class ArchiveT>
+  void serialize_impl(ArchiveT & ar, const unsigned int version) {
+    ar & boost::serialization::make_nvp(m_name.c_str(), *m_value);
+  }
+
+  void serialize(Archive::xml_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  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;
+};
+
+/**
+ * @brief Conveninent typedefs for common property types.
+ */
+typedef Property<std::string> StringProperty;
+typedef Property<int>           IntProperty;
+typedef Property<unsigned int>  UIntProperty;
+typedef Property<long>          LongProperty;
+typedef Property<unsigned long> ULongProperty;
+typedef Property<float>         FloatProperty;
+typedef Property<double>        DoubleProperty;
+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 = "", 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"; }
+  virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(EnumProperty)); }
+
+private:
+  std::vector<std::string> m_Labels;
+};
+
+/**
+ * @brief Macro to simplify property declaration within a class.
+ * Usage: ULIB_PROPERTY(float, Width, 1.0f)
+ * It creates a raw member m_Width and a Property proxy Width.
+ */
+#define ULIB_PROPERTY(type, name, defaultValue) \
+    type m_##name = defaultValue; \
+    Property<type> name = Property<type>(this, #name, &m_##name);
+
+
+} // namespace uLib
+
+namespace uLib {
+namespace Archive {
+class property_register_archive;
+} // namespace Archive
+} // namespace uLib
+
+namespace boost {
+namespace archive {
+namespace detail {
+template <>
+class interface_oarchive<uLib::Archive::property_register_archive>
+    : public uLib_interface_oarchive<uLib::Archive::property_register_archive> {};
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+namespace uLib {
+namespace Archive {
+
+/**
+ * @brief A special archive that creates and registers Property proxies
+ * for any member it encounters wrapped in HRP().
+ */
+class property_register_archive : 
+    public boost::archive::detail::common_oarchive<property_register_archive>
+{
+    Object* m_Object;
+public:
+    friend class boost::archive::detail::interface_oarchive<property_register_archive>;
+    friend class boost::archive::save_access;
+
+    typedef boost::archive::detail::common_oarchive<property_register_archive> detail_common_oarchive;
+
+    property_register_archive(Object* obj) : 
+        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() : "", GetCurrentGroup());
+            m_Object->RegisterDynamicProperty(p);
+        }
+    }
+
+    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() : "", GetCurrentGroup());
+            m_Object->RegisterDynamicProperty(p);
+        }
+    }
+
+    // Handle standard NVPs by recursing (important for base classes)
+    template<class T>
+    void save_override(const boost::serialization::nvp<T> &t) {
+        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();
+    }
+
+    // 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) {}
+    void save_override(const boost::archive::object_reference_type & t) {}
+    void save_override(const boost::archive::version_type & t) {}
+    void save_override(const boost::archive::class_id_type & t) {}
+    void save_override(const boost::archive::class_id_optional_type & t) {}
+    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 
+ * 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); }
+
+} // namespace Archive
+} // namespace uLib
+
+#endif // U_CORE_PROPERTY_H

src/Core/Serializable.h

@@ -23,8 +23,6 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_SERIALIZABLE_H
 #define U_SERIALIZABLE_H
 
@@ -38,9 +36,6 @@ TODO:
 
 */
 
-
-
-
 #include <boost/serialization/access.hpp>
 #include <boost/serialization/export.hpp>
 
@@ -48,26 +43,22 @@ TODO:
 #include <boost/mpl/remove_if.hpp>
 #include <boost/serialization/nvp.hpp>
 
-//#include <boost/archive/xml_iarchive.hpp>
-//#include <boost/archive/xml_oarchive.hpp>
-//#include <boost/archive/text_iarchive.hpp>
-//#include <boost/archive/text_oarchive.hpp>
-//#include "boost/archive/polymorphic_iarchive.hpp"
-//#include "boost/archive/polymorphic_oarchive.hpp"
+// #include <boost/archive/xml_iarchive.hpp>
+// #include <boost/archive/xml_oarchive.hpp>
+// #include <boost/archive/text_iarchive.hpp>
+// #include <boost/archive/text_oarchive.hpp>
+// #include "boost/archive/polymorphic_iarchive.hpp"
+// #include "boost/archive/polymorphic_oarchive.hpp"
 
-#include <boost/preprocessor/comma_if.hpp>
-#include <boost/preprocessor/repeat.hpp>
-#include <boost/preprocessor/inc.hpp>
 #include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/comma_if.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/repeat.hpp>
 #include <boost/preprocessor/tuple/to_seq.hpp>
 
-
-#include "Core/Mpl.h"
-#include "Core/ObjectProps.h"
 #include "Core/Archives.h"
 #include "Core/Export.h"
-
-
+#include "Core/Mpl.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -80,63 +71,78 @@ namespace serialization {
 // ACCESS 2 //
 template <class T> struct access2 {};
 
-
 // NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------
-template<class T>
-class hrp :
-        public wrapper_traits<const hrp< T > >
-{
-    const char *m_name;
-    T *m_value;
-    std::string *m_str;
+template <class T>
+class hrp : public boost::serialization::wrapper_traits<hrp<T>> {
+  const char *m_name;
+  const char *m_units;
+  T &m_value;
 
 public:
-    explicit hrp(const char * name_, T &t) :
-        m_str(new std::string),
-        m_name(name_), m_value(&t) {}
+  explicit hrp(const char *name_, T &t, const char* units_ = nullptr) : m_name(name_), m_units(units_), m_value(t) {}
 
-    const char * name() const {
-        return this->m_name;
-    }
+  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; }
 
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
 
-    template<class Archivex>
-    void save( Archivex & ar, const unsigned int /* file_version */) const {
-        ////        ar.operator<<(const_value());
-        //        std::stringstream ss;
-        //        uLib::Archive::hrt_oarchive har(ss);
-        //        har << make_nvp(m_name,*m_value);
-        //        //        (*m_str) = ss.str();
-        ////        ar.operator << (make_nvp(m_name, ss.str());
-    }
-    template<class Archivex>
-    void load( Archivex & ar, const unsigned int /* file_version */) {
-//        ar.operator>>(value());
-    }
-    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>
-inline
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-const
-#endif
-hrp< T > make_hrp(const char * name, T & t){
-    return hrp< T >(name, t);
+template <class T>
+inline hrp<T> make_hrp(const char *name, T &t, const char* units = nullptr) {
+  return hrp<T>(name, t, units);
 }
 
-#define HRP(name) \
-    boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
+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) {}
 
-} // serialization
-} // boost
+  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);
+  }
+};
 
+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)
+
+} // namespace serialization
+} // namespace boost
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -151,9 +157,7 @@ hrp< T > make_hrp(const char * name, T & t){
 
 namespace uLib {
 
-
-
-#define _AR_OP(r,data,elem) data&BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);
+#define _AR_OP(r, data, elem) data &BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);
 
 #define NVP(data) BOOST_SERIALIZATION_NVP(data)
 
@@ -166,51 +170,53 @@ namespace uLib {
 // SO LEAVE ULIB_CFG_INTRUSIVE_SERIALIZATION NOT DEFINED
 
 #ifdef ULIB_CFG_INTRUSIVE_SERIALIZATION_OBJECT
-#  define ULIB_SERIALIZABLE_OBJECT        _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT
-#  define ULIB_SERIALIZE_OBJECT(_Ob,...)  _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__)
-#  define _AR_(_name)                     _ULIB_DETAIL_INTRUSIVE_AR_(_name)
+#define ULIB_SERIALIZABLE_OBJECT _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT
+#define ULIB_SERIALIZE_OBJECT(_Ob, ...)                                        \
+  _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
+#define _AR_(_name) _ULIB_DETAIL_INTRUSIVE_AR_(_name)
 #else
-#  define ULIB_SERIALIZABLE(_Ob)           _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \
-                                            ULIB_CLASS_EXPORT_KEY(_Ob)
-#  define ULIB_SERIALIZE(_Ob,...)          _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)
-#  define ULIB_SERIALIZE_DERIVED(_Ob,...)  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob,__VA_ARGS__)
-#  define ULIB_SERIALIZABLE_OBJECT(_Ob)    _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \
-                                            ULIB_CLASS_EXPORT_OBJECT_KEY(_Ob)
-#  define ULIB_SERIALIZE_OBJECT(_Ob,...)   _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__)
-#  define ULIB_SERIALIZE_OBJECT_PROPS(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob)
-#  define AR(_name)                        _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
-#  define HR(_name)                        _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
+#define ULIB_SERIALIZABLE(_Ob)                                                 \
+  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob)                                   \
+  ULIB_CLASS_EXPORT_KEY(_Ob)
+#define ULIB_SERIALIZE(_Ob, ...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)
+#define ULIB_SERIALIZE_DERIVED(_Ob, ...)                                       \
+  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob, __VA_ARGS__)
+#define ULIB_SERIALIZABLE_OBJECT(_Ob)                                          \
+  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob)                            \
+  ULIB_CLASS_EXPORT_OBJECT_KEY(_Ob)
+#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)
 #endif
 
+#define ULIB_SERIALIZE_ACCESS                                                  \
+  friend class boost::serialization::access;                                   \
+  template <class T> friend class boost::serialization::access2;
 
-#define ULIB_SERIALIZE_ACCESS                                        \
-    friend class boost::serialization::access;                       \
-    template <class T> friend class boost::serialization::access2;
+#define ULIB_CLASS_EXPORT_KEY(_FullNamespaceClass)                             \
+  BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)
 
-#define ULIB_CLASS_EXPORT_KEY(_FullNamespaceClass)                   \
-    BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)
-
-#define ULIB_CLASS_EXPORT_OBJECT_KEY(_FullNamespaceClass)            \
-    BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)                      \
-    BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass::ObjectProps)         \
-    BOOST_CLASS_EXPORT_KEY(uLib::ObjectPropsImpl<_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 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)
 
 /** Solving virtual class check problem */
-#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base,_Derived)    namespace boost{ template<> struct is_virtual_base_of<_Base,_Derived>: public boost::mpl::true_ {}; }
-#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP(r,data,elem) _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem,data)
-
-
+#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base, _Derived)               \
+  namespace boost {                                                            \
+  template <>                                                                  \
+  struct is_virtual_base_of<_Base, _Derived> : public boost::mpl::true_ {};    \
+  }
+#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP(r, data, elem)              \
+  _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem, data)
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -220,38 +226,57 @@ namespace uLib {
 ////////////////////////////////////////////////////////////////////////////////
 // INTRUSIVE SERIALIZATION ( NOT WORKING YET !! ) //
 
-#define _ULIB_DETAIL_INTRUSIVE_AR_(name) ar & BOOST_SERIALIZATION_NVP(name);
+#define _ULIB_DETAIL_INTRUSIVE_AR_(name) ar &BOOST_SERIALIZATION_NVP(name);
 
-#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(Class,Archive) \
-    template void Class::serialize(Archive &ar,const unsigned int);
+#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(Class, Archive)                  \
+  template void Class::serialize(Archive &ar, const unsigned int);
 
-#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP(r,data,elem) _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(data,elem);
-
-#define _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT \
-    typedef boost::mpl::bool_<true> serializable;                                                \
-    typedef boost::mpl::remove_if< TypeList, IsUnSerializable >::type SerilizableTypeList;       \
-    void PrintSerializableListId() { boost::mpl::for_each<SerilizableTypeList>(PrintTypeId()); } \
-    template <class ArchiveT> void serialize(ArchiveT &ar,const unsigned int version);           \
-    template <class ArchiveT> void serialize_parents(ArchiveT &ar,const unsigned int version);   \
-    template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version);
-
-#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob,...) \
-    template <class ArchiveT> void _Ob::serialize(ArchiveT &ar, const unsigned int version) { \
-    boost::serialization::void_cast_register<_Ob,_Ob::BaseClass>(static_cast<_Ob *>(NULL),static_cast<_Ob::BaseClass *>(NULL));   \
-    _Ob::serialize_parents(ar,version); \
-    _Ob::save_override(ar,version); }\
-    template <class ArchiveT> void _Ob::serialize_parents(ArchiveT &ar, const unsigned int v) { \
-    BOOST_PP_SEQ_FOR_EACH(_AR_OP,ar,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); } \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
-    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
-    namespace boost { \
-    namespace serialization { \
-    template<class ArchiveT> inline void load_construct_data(ArchiveT & ar, _Ob *o, const unsigned int file_version) \
-    { ::new(o)_Ob(); o->init_parameters(); } }}\
-    template <class ArchiveT> void _Ob::save_override(ArchiveT &ar, const unsigned int version)
+#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP(r, data, elem)                \
+  _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(data, elem);
 
+#define _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT                             \
+  typedef boost::mpl::bool_<true> serializable;                                \
+  typedef boost::mpl::remove_if<TypeList, IsUnSerializable>::type              \
+      SerilizableTypeList;                                                     \
+  void PrintSerializableListId() {                                             \
+    boost::mpl::for_each<SerilizableTypeList>(PrintTypeId());                  \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, const unsigned int version);                    \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, const unsigned int version);            \
+  template <class ArchiveT>                                                    \
+  void save_override(ArchiveT &ar, const unsigned int version);
 
+#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob, ...)                      \
+  template <class ArchiveT>                                                    \
+  void _Ob::serialize(ArchiveT &ar, const unsigned int version) {              \
+    boost::serialization::void_cast_register<_Ob, _Ob::BaseClass>(             \
+        static_cast<_Ob *>(NULL), static_cast<_Ob::BaseClass *>(NULL));        \
+    _Ob::serialize_parents(ar, version);                                       \
+    _Ob::save_override(ar, version);                                           \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void _Ob::serialize_parents(ArchiveT &ar, const unsigned int v) {            \
+    BOOST_PP_SEQ_FOR_EACH(_AR_OP, ar, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));   \
+  }                                                                            \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP, _Ob,         \
+                        _SERIALIZE_IMPL_SEQ)                                   \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP, _Ob,       \
+                        BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)))                  \
+  ULIB_CLASS_EXPORT_IMPLEMENT(_Ob)                                             \
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  inline void load_construct_data(ArchiveT &ar, _Ob *o,                        \
+                                  const unsigned int file_version) {           \
+    ::new (o) _Ob();                                                           \
+    o->init_parameters();                                                      \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void _Ob::save_override(ArchiveT &ar, const unsigned int version)
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -261,152 +286,171 @@ namespace uLib {
 ////////////////////////////////////////////////////////////////////////////////
 // UNINTRUSIVE SERIALIZATION
 
-#define _UNAR_OP(r,data,elem) ar&boost::serialization::make_nvp(BOOST_PP_STRINGIZE(elem),boost::serialization::base_object<elem>(ob));
+#define _UNAR_OP(r, data, elem)                                                \
+  ar &boost::serialization::make_nvp(                                          \
+      BOOST_PP_STRINGIZE(elem), boost::serialization::base_object<elem>(ob));
 
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(Class,Archive) \
-    template void boost::serialization::serialize(Archive &ar, Class &ob, const unsigned int i);
-
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP(r,data,elem) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(data,elem)
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(Class, Archive)                \
+  template void boost::serialization::serialize(Archive &ar, Class &ob,        \
+                                                const unsigned int i);
 
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP(r, data, elem)              \
+  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(data, elem)
 
 // NOTE: becouse of BOOST_PP_VARIADIC_SIZE issue of some boost macro has two
 // different implementation
 
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize         (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-    template <class ArchiveT> void serialize_parents (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-    template <> struct access2< _Ob > { template <class ArchiveT> static void save_override (ArchiveT &ar, _Ob &ob, const unsigned int version); }; }}
-
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob) \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {} \
-    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
-    serialize_parents(ar,ob,version);  \
-    access2< _Ob >::save_override(ar,ob,version); } }}\
-    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
-    template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)
-
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob,...) \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) { \
-    BOOST_PP_IF(BOOST_PP_VARIADIC_SIZE((__VA_ARGS__)),BOOST_PP_SEQ_FOR_EACH(_UNAR_OP,ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));,) } \
-    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
-    serialize_parents(ar,ob,version);  \
-    access2< _Ob >::save_override    (ar,ob,version); } }}\
-    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ) \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
-    template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)
-
-
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize         (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-    template <class ArchiveT> void serialize_parents (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-    template <> struct access2< _Ob > { template <class ArchiveT> static void save_override (ArchiveT &ar, _Ob &ob, const unsigned int version); }; \
-    template <class ArchiveT> void serialize         (ArchiveT &ar, class _Ob::ObjectProps &ob, const unsigned int version); \
-    template <class ArchiveT> void save_override     (ArchiveT &ar, class _Ob::ObjectProps &ob, const unsigned int version); }}
-
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,...) \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> 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) );*/ } \
-    template<class ArchiveT> inline void load_construct_data(ArchiveT & ar, _Ob *ob, const unsigned int file_version) { \
-    ::new(ob)_Ob(); uLib::detail::ObjectProps::initializer::init_object(ob); } \
-    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
-    void_cast_register<_Ob,_Ob::BaseClass>(static_cast<_Ob *>(NULL),static_cast<_Ob::BaseClass *>(NULL)); /*fix*/  \
-    serialize_parents(ar,ob,version);  \
-    access2< _Ob >::save_override    (ar,ob,version); } }}\
-    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
-    template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)
-
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob) \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob::ObjectProps &ob, const unsigned int version) { \
-    save_override    (ar,ob,version); } }}\
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob::ObjectProps,_SERIALIZE_IMPL_SEQ)\
-    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob::ObjectProps) \
-    ULIB_CLASS_EXPORT_IMPLEMENT(uLib::ObjectPropsImpl<_Ob>) \
-    template <class ArchiveT> void boost::serialization::save_override(ArchiveT &ar, _Ob::ObjectProps &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_SERIALIZABLE(_Ob)                             \
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version);           \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int version);   \
+  template <> struct access2<_Ob> {                                            \
+    template <class ArchiveT>                                                  \
+    static void save_override(ArchiveT &ar, _Ob &ob,                           \
+                              const unsigned int version);                     \
+  };                                                                           \
+  }                                                                            \
+  }
 
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)                                \
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {}       \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version) {          \
+    serialize_parents(ar, ob, version);                                        \
+    access2<_Ob>::save_override(ar, ob, version);                              \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
+  ULIB_CLASS_EXPORT_IMPLEMENT(_Ob)                                             \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP, _Ob,       \
+                        _SERIALIZE_IMPL_SEQ)                                   \
+  template <class ArchiveT>                                                    \
+  void boost::serialization::access2<_Ob>::save_override(                      \
+      ArchiveT &ar, _Ob &ob, const unsigned int version)
 
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob, ...)                   \
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {        \
+    BOOST_PP_IF(BOOST_PP_VARIADIC_SIZE((__VA_ARGS__)),                         \
+                BOOST_PP_SEQ_FOR_EACH(_UNAR_OP, ob,                            \
+                                      BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));   \
+                , )                                                            \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version) {          \
+    serialize_parents(ar, ob, version);                                        \
+    access2<_Ob>::save_override(ar, ob, version);                              \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
+  ULIB_CLASS_EXPORT_IMPLEMENT(_Ob)                                             \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP, _Ob,       \
+                        _SERIALIZE_IMPL_SEQ)                                   \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP, _Ob,       \
+                        BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)))                  \
+  template <class ArchiveT>                                                    \
+  void boost::serialization::access2<_Ob>::save_override(                      \
+      ArchiveT &ar, _Ob &ob, const unsigned int version)
 
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob)                      \
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version);           \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int version);   \
+  template <> struct access2<_Ob> {                                            \
+    template <class ArchiveT>                                                  \
+    static void save_override(ArchiveT &ar, _Ob &ob,                           \
+                              const unsigned int version);                     \
+  };                                                                           \
+  }                                                                            \
+  }
 
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob, ...)                    \
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  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) );*/ }                                                          \
+  template <class ArchiveT>                                                    \
+  inline void load_construct_data(ArchiveT &ar, _Ob *ob,                       \
+                                  const unsigned int file_version) {           \
+    ::new (ob) _Ob();                                                          \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version) {          \
+    void_cast_register<_Ob, _Ob::BaseClass>(                                   \
+        static_cast<_Ob *>(NULL),                                              \
+        static_cast<_Ob::BaseClass *>(NULL)); /*fix*/                          \
+    serialize_parents(ar, ob, version);                                        \
+    access2<_Ob>::save_override(ar, ob, version);                              \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
+  ULIB_CLASS_EXPORT_IMPLEMENT(_Ob)                                             \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP, _Ob,       \
+                        BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)))                  \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP, _Ob,       \
+                        _SERIALIZE_IMPL_SEQ)                                   \
+  template <class ArchiveT>                                                    \
+  void boost::serialization::access2<_Ob>::save_override(                      \
+      ArchiveT &ar, _Ob &ob, const unsigned int version)
 
+#define _ULIB_DETAIL_UNINTRUSIVE_AR_(name)                                     \
+  boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), ob.name)
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
-
 namespace detail {
 
 struct Serializable {
 
-    /**
-     * Serializable trait to check if an object type is serializable.
-     * This only works if UNINTRUSIVE SERIALIZATION is applyed; in intrusive
-     * cases a has_serialize trait should be implemented
-     */
-    template <class T>
-    struct serializable_trait : mpl::bool_<false> {};
-
-    /**
-     * IsA Serializable Implementation Template
-     */
-    template <class T>
-    struct IsA : serializable_trait<T> {};
-
-    template <class ThisClass, class Archive>
-    struct serialize_baseobject {
-        ThisClass & m_object;
-        Archive   & m_ar;
-        serialize_baseobject(ThisClass &o, Archive &ar) : m_object(o), m_ar(ar) {}
-        template <class T> void operator()(T &o) {
-            m_ar & boost::serialization::make_nvp(
-                        typeid(T).name() ,
-                        boost::serialization::base_object<T>(m_object));
-        }
-    };
+  /**
+   * Serializable trait to check if an object type is serializable.
+   * This only works if UNINTRUSIVE SERIALIZATION is applyed; in intrusive
+   * cases a has_serialize trait should be implemented
+   */
+  template <class T> struct serializable_trait : mpl::bool_<false> {};
 
+  /**
+   * IsA Serializable Implementation Template
+   */
+  template <class T> struct IsA : serializable_trait<T> {};
 
+  template <class ThisClass, class Archive> struct serialize_baseobject {
+    ThisClass &m_object;
+    Archive &m_ar;
+    serialize_baseobject(ThisClass &o, Archive &ar) : m_object(o), m_ar(ar) {}
+    template <class T> void operator()(T &o) {
+      m_ar &boost::serialization::make_nvp(
+          typeid(T).name(), boost::serialization::base_object<T>(m_object));
+    }
+  };
 };
 
-
-} // detail
-
-
-
-
+} // namespace detail
 
 struct Serializable {
-    friend class boost::serialization::access;
-    template <class T> friend class boost::serialization::access2;
-    virtual ~Serializable() {}
+  friend class boost::serialization::access;
+  template <class T> friend class boost::serialization::access2;
+  virtual ~Serializable() {}
+
 protected:
 };
 
-
-
-
-
-} // uLib
-
-
-
-
-
+} // namespace uLib
 
 #endif // U_SERIALIZABLE_H

src/Core/Signal.h

@@ -23,21 +23,21 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_SIGNAL_H
 #define U_CORE_SIGNAL_H
 
 #include <boost/typeof/typeof.hpp>
 
 #include <boost/signals2/signal.hpp>
-#include <boost/signals2/slot.hpp>
 #include <boost/signals2/signal_type.hpp>
+#include <boost/signals2/slot.hpp>
+#include <boost/signals2/connection.hpp>
+#include <boost/signals2/shared_connection_block.hpp>
 
 #include "Function.h"
+#include <boost/bind/bind.hpp>
 
-
-
+using namespace boost::placeholders;
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -45,15 +45,32 @@
 // Signals macro //
 
 #define default(vlaue)
-#define slots
+#ifndef Q_MOC_RUN
+#ifndef signals
 #define signals /*virtual void init_signals();*/ public
+#endif
+#ifndef slots
+#define slots
+#endif
+#ifndef emit
 #define emit
-#define SLOT(a)     BOOST_STRINGIZE(a)
-#define SIGNAL(a)   BOOST_STRINGIZE(a)
+#endif
+#endif
+#ifndef SLOT
+#define SLOT(a) BOOST_STRINGIZE(a)
+#endif
+#ifndef SIGNAL
+#define SIGNAL(a) BOOST_STRINGIZE(a)
+#endif
 
-#define _ULIB_DETAIL_SIGNAL_EMIT(_name,...)                       \
-        static BOOST_AUTO(sig,this->findOrAddSignal(&_name));     \
-        sig->operator()(__VA_ARGS__);
+#define _ULIB_DETAIL_SIGNAL_EMIT(_name, ...)                                   \
+  do {                                                                         \
+    if (!this->signalsBlocked()) {                                             \
+        BOOST_AUTO(sig, this->findOrAddSignal(&_name));                        \
+        if (sig)                                                               \
+          sig->operator()(__VA_ARGS__);                                        \
+    }                                                                          \
+  } while (0)
 
 /**
  * Utility macro to implement signal emission implementa una delle seguenti:
@@ -66,103 +83,102 @@
  * // cast automatico //
  * static BOOST_AUTO(sig,this->findOrAddSignal(&Ob1::V0));
  *   sig->operator()();
-*/
-#define ULIB_SIGNAL_EMIT(_name,...) _ULIB_DETAIL_SIGNAL_EMIT(_name,__VA_ARGS__)
-
+ */
+#define ULIB_SIGNAL_EMIT(_name, ...)                                           \
+  _ULIB_DETAIL_SIGNAL_EMIT(_name, __VA_ARGS__)
 
 namespace uLib {
 
-
 // A boost::signal wrapper structure ///////////////////////////////////////////
 
 // TODO ...
 
 typedef boost::signals2::signal_base SignalBase;
+typedef boost::signals2::connection Connection;
 
-template <typename T>
-struct Signal {
-    typedef boost::signals2::signal<T> type;
+template <typename T> struct Signal {
+  typedef boost::signals2::signal<T> type;
 };
 
-
-
 ////////////////////////////////////////////////////////////////////////////////
 
-
 namespace detail {
 
-
-template <typename FuncT, int arity>
+template <typename FuncT, typename SigSignature, int arity>
 struct ConnectSignal {};
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 0 > {
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(slof);
-    }
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 0> {
+  static Connection connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    return reinterpret_cast<SigT *>(sigb)->connect(slof);
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 1 > {
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver));
-    }
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 1> {
+  static Connection connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    return reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 2 > {
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1));
-    }
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 2> {
+  static Connection connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    return reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 3 > {
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2));
-    }
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 3> {
+  static Connection connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    return reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2));
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 4 > {
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3));
-    }
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 4> {
+  static Connection connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    return reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2, _3));
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 5 > {
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3,_4));
-    }
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 5> {
+  static Connection connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    return reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2, _3, _4));
+  }
 };
 
+} // namespace detail
 
-} // detail
-
-
-
-template <typename FuncT>
-SignalBase *NewSignal(FuncT f) {
-    // seems to work wow !
-    return new Signal<void()>::type;
+template <typename FuncT> SignalBase *NewSignal(FuncT f) {
+  return new
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type;
 }
 
-template <typename FuncT>
-void ConnectSignal(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver)
-{
-    detail::ConnectSignal< FuncT, FunctionPointer<FuncT>::arity >::connect(sigb,slof,receiver);
+template <typename SigSignature, typename FuncT>
+Connection ConnectSignal(SignalBase *sigb, FuncT slof,
+                   typename FunctionPointer<FuncT>::Object *receiver) {
+  return detail::ConnectSignal<FuncT, SigSignature,
+                         FunctionPointer<FuncT>::arity>::connect(sigb, slof,
+                                                                 receiver);
 }
 
-
-
-
-} // uLib
+} // namespace uLib
 
 #endif // SIGNAL_H

src/Core/Threads.cpp

@@ -0,0 +1,202 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#include "Threads.h"
+#include <chrono>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+#ifdef __linux__
+#include <pthread.h>
+#include <sched.h>
+#endif
+
+namespace uLib {
+
+Thread::Thread() : m_Running(false) {}
+
+Thread::~Thread() {
+  if (m_Thread.joinable()) {
+    m_Thread.detach();
+  }
+}
+
+void Thread::Start() {
+  Mutex::ScopedLock lock(m_ThreadMutex);
+  if (m_Running) return;
+  
+  m_Running = true;
+  m_Thread = std::thread(&Thread::ThreadEntryPoint, this);
+}
+
+void Thread::Join() {
+  if (m_Thread.joinable()) {
+    m_Thread.join();
+  }
+}
+
+void Thread::Detach() {
+  if (m_Thread.joinable()) {
+    m_Thread.detach();
+  }
+}
+
+bool Thread::IsJoinable() const {
+  return m_Thread.joinable();
+}
+
+bool Thread::IsRunning() const {
+  return m_Running;
+}
+
+void Thread::Run() {
+  // Override in subclasses
+}
+
+void Thread::ThreadEntryPoint() {
+  this->Run();
+  m_Running = false;
+}
+
+void Thread::Sleep(int milliseconds) {
+  std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+}
+
+void Thread::Yield() {
+  std::this_thread::yield();
+}
+
+void Thread::SetAffinity(int cpu) {
+#ifdef __linux__
+  if (m_Thread.joinable()) {
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    CPU_SET(cpu, &cpuset);
+    pthread_setaffinity_np(m_Thread.native_handle(), sizeof(cpu_set_t), &cpuset);
+  }
+#endif
+}
+
+void Thread::SetAffinity(const std::vector<int>& cpus) {
+#ifdef __linux__
+  if (m_Thread.joinable()) {
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    for (int cpu : cpus) {
+        CPU_SET(cpu, &cpuset);
+    }
+    pthread_setaffinity_np(m_Thread.native_handle(), sizeof(cpu_set_t), &cpuset);
+  }
+#endif
+}
+
+void Thread::SetNumThreads(int n) {
+#ifdef _OPENMP
+  omp_set_num_threads(n);
+#endif
+}
+
+int Thread::GetNumThreads() {
+#ifdef _OPENMP
+  return omp_get_max_threads();
+#else
+  return 1;
+#endif
+}
+
+int Thread::GetThreadNum() {
+#ifdef _OPENMP
+  return omp_get_thread_num();
+#else
+  return 0;
+#endif
+}
+
+// Team Implementation //
+
+Team::Team(int num_threads) : m_Size(num_threads), m_UseOpenMP(false) {
+#ifdef _OPENMP
+  m_UseOpenMP = true;
+  if (m_Size > 0) omp_set_num_threads(m_Size);
+  else m_Size = omp_get_max_threads();
+#else
+  if (m_Size <= 0) m_Size = 1;
+#endif
+}
+
+Team::~Team() {
+  Wait();
+}
+
+void Team::Run(Task* task) {
+  if (!task) return;
+#ifdef _OPENMP
+  if (m_UseOpenMP) {
+    #pragma omp task
+    task->Execute();
+    return;
+  }
+#endif
+  // Fallback to synchronous execution if no OpenMP
+  task->Execute();
+}
+
+void Team::Wait() {
+#ifdef _OPENMP
+  if (m_UseOpenMP) {
+    #pragma omp taskwait
+  }
+#endif
+}
+
+void Team::SetSize(int n) {
+  m_Size = n;
+#ifdef _OPENMP
+  if (m_UseOpenMP) omp_set_num_threads(m_Size);
+#endif
+}
+
+void Team::SetAffinity(const std::vector<int>& cpus) {
+  if (cpus.empty()) return;
+#ifdef __linux__
+#ifdef _OPENMP
+  if (m_UseOpenMP) {
+    #pragma omp parallel
+    {
+      int tid = omp_get_thread_num();
+      int cpu = cpus[tid % cpus.size()];
+      cpu_set_t cpuset;
+      CPU_ZERO(&cpuset);
+      CPU_SET(cpu, &cpuset);
+      pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+    }
+  }
+#endif
+#endif
+}
+
+} // namespace uLib

src/Core/Threads.h

@@ -0,0 +1,147 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_CORE_THREADS_H
+#define U_CORE_THREADS_H
+
+#include <thread>
+#include <functional>
+#include <atomic>
+#include <vector>
+#include <deque>
+#include "Core/Monitor.h"
+#include "Core/Object.h"
+
+namespace uLib {
+
+/**
+ * @brief Thread class wraps std::thread and provides a common interface.
+ */
+class Thread : public Object {
+public:
+  Thread();
+  virtual ~Thread();
+
+  /** @brief Starts the thread by calling Run(). */
+  void Start();
+
+  /** @brief Joins the thread. */
+  void Join();
+
+  /** @brief Detaches the thread. */
+  void Detach();
+
+  /** @brief Returns true if the thread is currently joinable. */
+  bool IsJoinable() const;
+  
+  /** @brief Returns true if the thread is currently running. */
+  bool IsRunning() const;
+
+  /** @brief The entry point for the thread. Override this in subclasses. */
+  virtual void Run();
+
+  /** @brief Static helper to sleep the current thread. */
+  static void Sleep(int milliseconds);
+
+  /** @brief Static helper to yield the current thread. */
+  static void Yield();
+
+  /** @brief Returns the native handle of the thread. */
+  std::thread::native_handle_type GetNativeHandle() { return m_Thread.native_handle(); }
+
+  /** @brief Sets CPU affinity for the thread. (Linux only) */
+  void SetAffinity(int cpu);
+  
+  /** @brief Sets CPU affinity for the thread using a list of CPUs. (Linux only) */
+  void SetAffinity(const std::vector<int>& cpus);
+
+  // OpenMP Support //
+  
+  /** @brief Sets the number of threads for OpenMP parallel regions. */
+  static void SetNumThreads(int n);
+  
+  /** @brief Returns the number of threads for OpenMP parallel regions. */
+  static int GetNumThreads();
+
+  /** @brief Returns the ID of the current thread in an OpenMP parallel region. */
+  static int GetThreadNum();
+
+protected:
+  // Internal thread entry point
+  void ThreadEntryPoint();
+
+  std::thread m_Thread;
+  std::atomic<bool> m_Running;
+  mutable Mutex m_ThreadMutex;
+};
+
+/**
+ * @brief Task class wraps a function call to be executed by a Team.
+ */
+class Task : public Object {
+public:
+  Task(std::function<void()> func) : m_Func(func) {}
+  virtual ~Task() = default;
+
+  /** @brief Executes the task. */
+  virtual void Execute() { if (m_Func) m_Func(); }
+
+protected:
+  std::function<void()> m_Func;
+};
+
+/**
+ * @brief Team class manages a group of threads and can execute Tasks.
+ * This is designed to be compatible with OpenMP tasks and teams.
+ */
+class Team : public Object {
+public:
+  Team(int num_threads = -1);
+  virtual ~Team();
+
+  /** @brief Runs a task within the team. Uses OpenMP task if available. */
+  void Run(Task* task);
+
+  /** @brief Waits for all tasks in the team to finish. */
+  void Wait();
+
+  /** @brief Sets the number of threads for this team. */
+  void SetSize(int n);
+
+  /** @brief Returns the number of threads in the team. */
+  int GetSize() const { return m_Size; }
+
+  /** @brief Sets CPU affinity for all threads in the team. */
+  void SetAffinity(const std::vector<int>& cpus);
+
+protected:
+  int m_Size;
+  bool m_UseOpenMP;
+  std::vector<Thread*> m_Threads;
+};
+
+} // namespace uLib
+
+#endif // U_CORE_THREADS_H

src/Core/Types.h

@@ -23,8 +23,6 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_TYPES_H
 #define U_CORE_TYPES_H
 
@@ -33,253 +31,183 @@
 
 #include <boost/preprocessor.hpp>
 
-//#include <ltk/ltktypes.h>
+// #include <ltk/ltktypes.h>
 
 #include "Core/Macros.h"
 #include "Core/Mpl.h"
 
-
-
-
-
-
-
 namespace uLib {
 
-
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace detail {
 
 struct TypeIntrospection {
 
-    // BOOST IMPL  //
-    BOOST_MPL_HAS_XXX_TRAIT_DEF(type_info)
+  // BOOST IMPL  //
+  BOOST_MPL_HAS_XXX_TRAIT_DEF(type_info)
 
-    // SFINAE IMPL //
-    /*
-    template <typename T>
-    struct has_type_info {
-        typedef char yes[1];
-        typedef char no[2];
-        template <typename U> static yes& test(typename U::type_info::BaseList*);
-        template <typename   > static no&  test(...);
-        //        struct apply {
-        static const bool value = sizeof(test<T>(0)) == sizeof(yes);
-        typedef boost::mpl::bool_<value> type;
-        //        };
-    };
-    */
+  // SFINAE IMPL //
+  /*
+  template <typename T>
+  struct has_type_info {
+      typedef char yes[1];
+      typedef char no[2];
+      template <typename U> static yes& test(typename U::type_info::BaseList*);
+      template <typename   > static no&  test(...);
+      //        struct apply {
+      static const bool value = sizeof(test<T>(0)) == sizeof(yes);
+      typedef boost::mpl::bool_<value> type;
+      //        };
+  };
+  */
 
-    /** IsA Introspectable Object Implementation Template */
-    template <class T>
-    struct IsIntrospectable : has_type_info<T> {};
+  /** IsA Introspectable Object Implementation Template */
+  template <class T> struct IsIntrospectable : has_type_info<T> {};
 
-    template <typename T> struct access {
-        typedef typename T::type_info type_info;
+  template <typename T> struct access {
+    typedef typename T::type_info type_info;
+  };
+
+  template <typename T> struct child_first_impl {
+
+    template <class T1, bool cond> struct lambda_CFList_f {
+      typedef mpl::vector<T1> type;
     };
 
-    template <typename T>
-    struct child_first_impl {
-
-        template <class T1, bool cond>
-        struct lambda_CFList_f {
-            typedef mpl::vector<T1> type;
-        };
-
-        template <class T1>
-        struct lambda_CFList_f<T1,true> {
-            //            typedef typename T1::type_info::CFList type;
-            typedef typename access<T1>::type_info::CFList type;
-        };
-
-        template <class T1>
-        struct lambda_CFList : lambda_CFList_f<T1, has_type_info<T1>::value> {};
-
-        /** Transforms all Base Type into proper CFList */
-        typedef typename mpl::transform_view < typename access<T>::type_info::BaseList
-                                             , lambda_CFList<mpl::_>
-                                             >::type CFListSeq;
-
-        /** Folds each CFList into a new sequence */
-        typedef typename mpl::fold< CFListSeq
-                                  , mpl::vector<>
-                                  , mpl::copy< mpl::_1
-                                             , mpl::back_inserter<mpl::_2>
-                                             >
-                                  >::type Childs;
-
-        /** Add This Class to final CFList sequence */
-        typedef typename mpl::copy< Childs
-                                  , mpl::back_inserter< mpl::vector<T> >
-                                  >::type type;
+    template <class T1> struct lambda_CFList_f<T1, true> {
+      //            typedef typename T1::type_info::CFList type;
+      typedef typename access<T1>::type_info::CFList type;
     };
 
+    template <class T1>
+    struct lambda_CFList : lambda_CFList_f<T1, has_type_info<T1>::value> {};
 
-    /**
-     * Tests if T has a member called type_info then compile type CFList
-     */
-    template <typename T>
-    struct child_first : mpl::if_< has_type_info<T>
-                                 , child_first_impl<T>
-                                 , mpl::vector<>
-                                 >::type {};
+    /** Transforms all Base Type into proper CFList */
+    typedef
+        typename mpl::transform_view<typename access<T>::type_info::BaseList,
+                                     lambda_CFList<mpl::_>>::type CFListSeq;
 
+    /** Folds each CFList into a new sequence */
+    typedef typename mpl::fold<
+        CFListSeq, mpl::vector<>,
+        mpl::copy<mpl::_1, mpl::back_inserter<mpl::_2>>>::type Childs;
 
+    /** Add This Class to final CFList sequence */
+    typedef typename mpl::copy<Childs, mpl::back_inserter<mpl::vector<T>>>::type
+        type;
+  };
+
+  /**
+   * Tests if T has a member called type_info then compile type CFList
+   */
+  template <typename T>
+  struct child_first
+      : mpl::if_<has_type_info<T>, child_first_impl<T>, mpl::vector<>>::type {};
 };
 
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // TYPE ADAPTERS // FINIRE !!!
 
-//#define _REPETITION_V(vz,vn,vdata)
-
-
-//template < class TypeList >
-//class TypeAdapterInputInterface {
-//    virtual ~TypeAdapterInputInterface() {}
-//public:
-
+// #define _REPETITION_V(vz,vn,vdata)
 
+// template < class TypeList >
+// class TypeAdapterInputInterface {
+//     virtual ~TypeAdapterInputInterface() {}
+// public:
 
 //    virtual void operator()(int val)         {}
 //    virtual void operator()(std::string val) {}
 //};
 
-
-
-
-
-
-
-} // detail ////////////////////////////////////////////////////////////////////
-
+} // namespace detail
 
 #define CONSTEXPR BOOST_CONSTEXPR
 
-
-//typedef ltk::Real_t      Real_t;
+// typedef ltk::Real_t      Real_t;
 #ifndef LTK_DOUBLE_PRECISION
-typedef float      Real_t;
+typedef float Real_t;
 #else
-typedef double     Real_t;
+typedef double Real_t;
 #endif
-//typedef ltk::Id_t        Id_t;
-typedef id_t       Id_t;
+// typedef ltk::Id_t        Id_t;
+typedef id_t Id_t;
 ////typedef ltk::Size_t      Size_t;
-//typedef ltk::Pointer_t   Pointer_t;
-typedef void *     Pointer_t;
-typedef bool             Bool_t;      //Boolean (0=false, 1=true) (bool)
-
+// typedef ltk::Pointer_t   Pointer_t;
+typedef void *Pointer_t;
+typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
 
 
 //--- bit manipulation ---------------------------------------------------------
 #ifndef BIT
-#define BIT(n)       (1ULL << (n))
+#define BIT(n) (1ULL << (n))
 #endif
 
 #ifndef SETBIT
-#define SETBIT(n,i)  ((n) |= BIT(i))
+#define SETBIT(n, i) ((n) |= BIT(i))
 #endif
 
 #ifndef CLRBIT
-#define CLRBIT(n,i)  ((n) &= ~BIT(i))
+#define CLRBIT(n, i) ((n) &= ~BIT(i))
 #endif
 
 #ifndef TESTBIT
-#define TESTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))
+#define TESTBIT(n, i) ((Bool_t)(((n) & BIT(i)) != 0))
 #endif
 
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // TYPE INTROSPECTION FOR OBJECTS //
 
-
-
-#define uLibTypeMacro(thisClass,...) \
-    \
-    /* Friendship detail for accessing introspection */ \
-    template <typename> friend class uLib::detail::TypeIntrospection::access;       \
-    \
-    /* type info structure*/ public: \
-    /* in GCC 4.8 must be public or dynamic_cast wont work */ \
-    struct type_info { \
-      /*WARNING: -std=c++0x required for this! */ \
-      constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass);            \
-      typedef BOOST_PP_VARIADIC_ELEM(0,__VA_ARGS__) BaseClass;                      \
-      typedef thisClass ThisClass;                                                  \
-      typedef uLib::mpl::vector<__VA_ARGS__,thisClass> TypeList;                    \
-      typedef uLib::mpl::vector<__VA_ARGS__>           BaseList;                    \
-      typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type CFList; \
-    }; \
-    \
-    public: \
-    typedef type_info::BaseClass BaseClass; \
-    virtual const char *type_name() const { return type_info::name; } \
-    /* Object Props fwd declaration*/ \
-    struct ObjectProps; \
-    /**/
-
+#define uLibTypeMacro(thisClass, ...)                                          \
+                                                                               \
+  /* Friendship detail for accessing introspection */                          \
+  template <typename> friend class uLib::detail::TypeIntrospection::access;    \
+                                                                               \
+/* type info structure*/ public:                                               \
+  /* in GCC 4.8 must be public or dynamic_cast wont work */                    \
+  struct type_info {                                                           \
+    /*WARNING: -std=c++0x required for this! */                                \
+    constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass);         \
+    typedef BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) BaseClass;                  \
+    typedef thisClass ThisClass;                                               \
+    typedef uLib::mpl::vector<__VA_ARGS__, thisClass> TypeList;                \
+    typedef uLib::mpl::vector<__VA_ARGS__> BaseList;                           \
+    typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type      \
+        CFList;                                                                \
+  };                                                                           \
+                                                                               \
+public:                                                                        \
+  typedef type_info::BaseClass BaseClass;                                      \
+  virtual const char *type_name() const { return type_info::name; }            \
+  /**/
 
 /**
  * TypeList inheritance introspection
  */
 struct TypeIntrospection {
-    template <typename T>
-    struct child_first : detail::TypeIntrospection::child_first<T> {};
-
+  template <typename T>
+  struct child_first : detail::TypeIntrospection::child_first<T> {};
 };
 
-
-
-
-
-
 // SISTEMARE //
 struct PrintTypeId {
-    template <class T>
-    void operator()(T) const
-    { std::cout << typeid(T).name() << std::endl; }
+  template <class T> void operator()(T) const {
+    std::cout << typeid(T).name() << std::endl;
+  }
 
-    template <typename SeqT>
-    static void PrintMplSeq(SeqT *p = NULL) { boost::mpl::for_each<SeqT>(PrintTypeId()); }
+  template <typename SeqT> static void PrintMplSeq(SeqT *p = NULL) {
+    boost::mpl::for_each<SeqT>(PrintTypeId());
+  }
 
-    template <typename Class>
-    static void PrintType(Class *p = NULL) { std::cout << typeid(Class).name() << std::endl; }
+  template <typename Class> static void PrintType(Class *p = NULL) {
+    std::cout << typeid(Class).name() << std::endl;
+  }
 };
 
-
-
-
-
-
-
-} // uLib
+} // namespace uLib
 
 #endif // U_CORE_TYPES_H
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

src/Core/Uuid.h

@@ -23,69 +23,49 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_UUID_H
 #define U_CORE_UUID_H
 
 #include <iostream>
 #include <vector>
 
-#include <boost/uuid/uuid.hpp>
 #include <boost/uuid/name_generator.hpp>
 #include <boost/uuid/random_generator.hpp>
+#include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_io.hpp>
 
 #include "Core/Mpl.h"
 #include "Core/Object.h"
 
-
 namespace uLib {
 
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // Object Registration //
 
-
 typedef boost::uuids::uuid uuid_t;
 
 extern uuid_t uLib_dns_uuid;
 
-template < typename T >
-class type_id : public boost::uuids::uuid {
+template <typename T> class type_id : public boost::uuids::uuid {
 public:
-    type_id() :
-        m_size(sizeof(T)),
-        uuid(boost::uuids::name_generator(uLib_dns_uuid)(typeid(T).name()))
-    {
-        std::cout << "Request for register new type\n" <<
-                     "name: " << typeid(T).name() << "\n" <<
-                     "uuid: " << to_string(*this) << "\n";
-    }
+  type_id()
+      : m_size(sizeof(T)),
+        uuid(boost::uuids::name_generator(uLib_dns_uuid)(typeid(T).name())) {
+    std::cout << "Request for register new type\n"
+              << "name: " << typeid(T).name() << "\n"
+              << "uuid: " << to_string(*this) << "\n";
+  }
 
-    explicit type_id(boost::uuids::uuid const& u)
-            : boost::uuids::uuid(u) {}
+  explicit type_id(boost::uuids::uuid const &u) : boost::uuids::uuid(u) {}
 
-    operator boost::uuids::uuid() {
-        return static_cast<boost::uuids::uuid&>(*this);
-    }
-
-    operator boost::uuids::uuid() const {
-        return static_cast<boost::uuids::uuid const&>(*this);
-    }
-
-    unsigned int size() const { return m_size; }
+  unsigned int size() const { return m_size; }
 
 private:
-    unsigned int m_size;
+  unsigned int m_size;
 };
 
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -94,70 +74,57 @@ private:
 namespace detail {
 
 class TypeRegister {
-    typedef boost::uuids::name_generator IDGen_t;
+  typedef boost::uuids::name_generator IDGen_t;
+
 public:
-    struct RegisterEntry {
-        uuid_t id;
-        int size;
-    };
+  struct RegisterEntry {
+    uuid_t id;
+    int size;
+  };
 
-    TypeRegister(uuid_t const &dns) :
-        gen(dns) {}
-
-
-    template< typename T >
-    RegisterEntry * AddType(T *t = NULL) {
-        RegisterEntry en = { gen(typeid(T).name()), sizeof(T) };
-        for(int i=0; i < m_registry.size(); ++i)
-            if(en.id == m_registry[i].id) return &(m_registry[i]);
-        m_registry.push_back(en);
-        return &m_registry.back();
-    }
-
-    void PrintSelf(std::ostream &o) {
-        std::cout << "RegisterController: \n";
-        for (int i=0; i<m_registry.size(); ++i)
-            o << "type [" << i << "]: "
-              << to_string(m_registry[i].id) << " "
-              << m_registry[i].size << "\n";
-        o << "\n";
-    }
+  TypeRegister(uuid_t const &dns) : gen(dns) {}
 
+  template <typename T> RegisterEntry *AddType(T *t = NULL) {
+    RegisterEntry en = {gen(typeid(T).name()), sizeof(T)};
+    for (int i = 0; i < m_registry.size(); ++i)
+      if (en.id == m_registry[i].id)
+        return &(m_registry[i]);
+    m_registry.push_back(en);
+    return &m_registry.back();
+  }
 
+  void PrintSelf(std::ostream &o) {
+    std::cout << "RegisterController: \n";
+    for (int i = 0; i < m_registry.size(); ++i)
+      o << "type [" << i << "]: " << to_string(m_registry[i].id) << " "
+        << m_registry[i].size << "\n";
+    o << "\n";
+  }
 
 private:
-    IDGen_t gen;
-    std::vector<RegisterEntry> m_registry;
-
+  IDGen_t gen;
+  std::vector<RegisterEntry> m_registry;
 };
 
-} // detail
-
-
-
+} // namespace detail
 
 class TypeRegister : public detail::TypeRegister {
 public:
-    typedef detail::TypeRegister                BaseClass;
-    typedef detail::TypeRegister::RegisterEntry Entry;
+  typedef detail::TypeRegister BaseClass;
+  typedef detail::TypeRegister::RegisterEntry Entry;
 
-    static TypeRegister* Controller();
+  static TypeRegister *Controller();
 
 private:
-    TypeRegister();                  // Blocks constructor
-    static TypeRegister *s_Instance; // Singleton instance
+  TypeRegister();                  // Blocks constructor
+  static TypeRegister *s_Instance; // Singleton instance
 };
 
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // OBJECT REGISTER //
 
-
-
-} // uLib
+} // namespace uLib
 
 #endif // UUID_H

src/Core/Vector.h

@@ -23,156 +23,433 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_VECTOR_H
 #define U_CORE_VECTOR_H
 
-#include <vector>
 #include <iostream>
+#include <map>
+#include <mutex>
+#include <vector>
+
+#include <Core/DataAllocator.h>
 
-#include <Core/StaticInterface.h>
-#include <Core/SmartPointer.h>
 #include <Core/CommaInitializer.h>
+#include <Core/SmartPointer.h>
+#include <Core/StaticInterface.h>
 
+#ifdef USE_CUDA
+#include <thrust/device_ptr.h>
+#include <thrust/device_vector.h>
+#endif
 
 namespace uLib {
 
-// Vector Implemetation ... wraps std::vector
-template <typename T>
-class Vector : public std::vector<T, std::allocator<T> >
-{    
-    typedef std::vector< T,std::allocator<T> > BaseClass;
-    typedef std::allocator<T> Allocator;
+// MetaAllocator Implementation ...
+template <typename T> class MetaAllocator {
 public:
-    typedef T TypeData;
-    typedef __gnu_cxx::__normal_iterator<T*, BaseClass >       Iterator;
-    typedef __gnu_cxx::__normal_iterator<const T*, BaseClass>  ConstIterator;
+  using value_type = T;
+  using pointer = T *;
+  using const_pointer = const T *;
+  using reference = T &;
+  using const_reference = const T &;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
 
-    typedef CommaInitializer< Vector<T> , T > VectorCommaInit;
+  template <class U> struct rebind {
+    using other = MetaAllocator<U>;
+  };
 
-    Vector(unsigned int size) : BaseClass(size) {}
-    Vector(unsigned int size, T &value) : BaseClass(size,value) {}
-    Vector() : BaseClass(0) {}
+  MetaAllocator() noexcept = default;
 
-    inline VectorCommaInit operator <<(T scalar) {
-        return VectorCommaInit(this, scalar);
-    }
+  template <class U>
+  constexpr MetaAllocator(const MetaAllocator<U> &) noexcept {}
 
-    inline void PrintSelf(std::ostream &o);
+  T *allocate(std::size_t n) {
+    if (n == 0)
+      return nullptr;
 
-    void remove_element(unsigned int index) {
-        std::swap(this->at(index),this->back());
-        this->pop_back();
-    }
+    DataAllocator<T> *da = new DataAllocator<T>(n, false);
+    T *ptr = da->GetRAMData();
 
-    void remove_element(T &t) {
-      std::swap(t, this->back());
-      this->pop_back();
-    }   
-
-};
-
-template<typename T>
-void Vector<T>::PrintSelf(std::ostream &o)
-{
-    o << " *** uLib Vector *** \n";
-    o << " n. of items = " << this->size() << "\n";
-    for(int i=0; i< this->size(); ++i)
-        o << (T)this->at(i) << " ";
-    o << "\n";
-}
-
-template <typename T>
-std::ostream & operator << (std::ostream &o, const Vector<T> &v) {
-    for(int i=0; i< v.size(); ++i)
-        o << (T)v.at(i) << " ";
-    o << "\n";
-    return o;
-}
-
-template <typename T>
-std::ofstream & operator << (std::ofstream &o, const Vector<T> &v) {
-    for(int i=0; i< v.size(); ++i)
-        o << (T)v.at(i) << " ";
-    return o;
-}
-
-
-template < typename T >
-std::istream & operator >> (std::istream &is, Vector<T> &v) {
-    T value;
-    while( is >> value ) {
-        if(is.fail()) v.push_back(0);
-        else v.push_back( value );
-    }
-    return is;
-}
-
-
-
-// Smart pointer Vector Implementation //
-
-
-template <typename T>
-class SmartVector : public SmartPointer< Vector<T> > {
-    typedef SmartPointer< Vector<T> > Base;
-public:
-
-  SmartVector() : Base(new Vector<T>()) { }
-  SmartVector( const SmartVector &copy) : Base(copy) { }
-  SmartVector(unsigned int size) : Base(new Vector<T>((int)size)) { }
-
-  virtual ~SmartVector() {}
-
-  T& operator[](int p) {
-      return Base::get()->at(p);
+    std::lock_guard<std::mutex> lock(GetMutex());
+    GetAllocationMap()[ptr] = da;
+    return ptr;
   }
 
-  void swap_elements(unsigned int first, unsigned int second) {
-      std::swap(Base::get()->at(first),Base::get()->at(second));
+  void deallocate(T *p, std::size_t /*n*/) noexcept {
+    if (!p)
+      return;
+
+    std::lock_guard<std::mutex> lock(GetMutex());
+    auto &map = GetAllocationMap();
+    auto it = map.find(p);
+    if (it != map.end()) {
+      delete it->second;
+      map.erase(it);
+    }
+  }
+
+  static DataAllocator<T> *GetDataAllocator(T *p) {
+    if (!p)
+      return nullptr;
+    std::lock_guard<std::mutex> lock(GetMutex());
+    auto &map = GetAllocationMap();
+    auto it = map.find(p);
+    if (it != map.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+
+private:
+  static std::map<T *, DataAllocator<T> *> &GetAllocationMap() {
+    static std::map<T *, DataAllocator<T> *> allocMap;
+    return allocMap;
+  }
+
+  static std::mutex &GetMutex() {
+    static std::mutex mtx;
+    return mtx;
+  }
+};
+
+template <class T, class U>
+bool operator==(const MetaAllocator<T> &, const MetaAllocator<U> &) {
+  return true;
+}
+template <class T, class U>
+bool operator!=(const MetaAllocator<T> &, const MetaAllocator<U> &) {
+  return false;
+}
+
+// Vector Implemetation ... wraps std::vector
+template <typename T> class Vector : public std::vector<T, MetaAllocator<T>> {
+  typedef std::vector<T, MetaAllocator<T>> BaseClass;
+  typedef MetaAllocator<T> Allocator;
+
+public:
+  typedef T TypeData;
+  typedef __gnu_cxx::__normal_iterator<T *, BaseClass> Iterator;
+  typedef __gnu_cxx::__normal_iterator<const T *, BaseClass> ConstIterator;
+
+  typedef CommaInitializer<Vector<T>, T> VectorCommaInit;
+  typedef typename BaseClass::iterator iterator;
+  typedef typename BaseClass::const_iterator const_iterator;
+  typedef typename BaseClass::size_type size_type;
+  typedef typename BaseClass::reference reference;
+
+  Vector(unsigned int size) : BaseClass(size) {}
+  Vector(unsigned int size, T &value) : BaseClass(size, value) {}
+  Vector() : BaseClass(0) {}
+  Vector(std::initializer_list<T> init) : BaseClass(init) {}
+
+  inline VectorCommaInit operator<<(T scalar) {
+    return VectorCommaInit(this, scalar);
+  }
+
+  void MoveToVRAM() {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(BaseClass::data())) {
+      alloc->MoveToVRAM();
+    }
+  }
+
+  void MoveToRAM() {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(BaseClass::data())) {
+      alloc->MoveToRAM();
+    }
+  }
+
+  T *GetVRAMData() {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(BaseClass::data())) {
+      return alloc->GetVRAMData();
+    }
+    return nullptr;
+  }
+
+  const T *GetVRAMData() const {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(
+            const_cast<T *>(BaseClass::data()))) {
+      return alloc->GetVRAMData();
+    }
+    return nullptr;
+  }
+
+#ifdef USE_CUDA
+  /// Returns a thrust::device_ptr to the VRAM data (valid after MoveToVRAM()).
+  /// thrust::device_ptr<T> is itself a random-access iterator compatible with
+  /// all thrust algorithms (thrust::transform, thrust::sort,
+  /// thrust::for_each…).
+  thrust::device_ptr<T> DeviceData() {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(BaseClass::data())) {
+      return thrust::device_pointer_cast(alloc->GetVRAMData());
+    }
+    return thrust::device_ptr<T>(nullptr);
+  }
+
+  thrust::device_ptr<const T> DeviceData() const {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(
+            const_cast<T *>(BaseClass::data()))) {
+      return thrust::device_pointer_cast(
+          static_cast<const T *>(alloc->GetVRAMData()));
+    }
+    return thrust::device_ptr<const T>(nullptr);
+  }
+
+  /// Device-side begin iterator (valid after MoveToVRAM()).
+  thrust::device_ptr<T> DeviceBegin() { return DeviceData(); }
+
+  /// Device-side end iterator (valid after MoveToVRAM()).
+  thrust::device_ptr<T> DeviceEnd() {
+    return DeviceData() + static_cast<std::ptrdiff_t>(BaseClass::size());
+  }
+
+  thrust::device_ptr<const T> DeviceBegin() const { return DeviceData(); }
+
+  thrust::device_ptr<const T> DeviceEnd() const {
+    return DeviceData() + static_cast<std::ptrdiff_t>(BaseClass::size());
+  }
+#endif // USE_CUDA
+
+  inline void PrintSelf(std::ostream &o);
+
+  // Overrides for auto-sync //
+  T &operator[](size_t i) {
+    this->MoveToRAM();
+    return BaseClass::operator[](i);
+  }
+  const T &operator[](size_t i) const {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::operator[](i);
+  }
+  T &at(size_t i) {
+    this->MoveToRAM();
+    return BaseClass::at(i);
+  }
+  const T &at(size_t i) const {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::at(i);
+  }
+  T &front() {
+    this->MoveToRAM();
+    return BaseClass::front();
+  }
+  const T &front() const {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::front();
+  }
+  T &back() {
+    this->MoveToRAM();
+    return BaseClass::back();
+  }
+  const T &back() const {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::back();
+  }
+  T *data() noexcept {
+    this->MoveToRAM();
+    return BaseClass::data();
+  }
+  const T *data() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::data();
+  }
+  Iterator begin() noexcept {
+    this->MoveToRAM();
+    return BaseClass::begin();
+  }
+  ConstIterator begin() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::begin();
+  }
+  Iterator end() noexcept {
+    this->MoveToRAM();
+    return BaseClass::end();
+  }
+  ConstIterator end() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::end();
+  }
+  auto rbegin() noexcept {
+    this->MoveToRAM();
+    return BaseClass::rbegin();
+  }
+  auto rbegin() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::rbegin();
+  }
+  auto rend() noexcept {
+    this->MoveToRAM();
+    return BaseClass::rend();
+  }
+  auto rend() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::rend();
+  }
+
+  void push_back(const T &x) {
+    this->MoveToRAM();
+    BaseClass::push_back(x);
+  }
+  void push_back(T &&x) {
+    this->MoveToRAM();
+    BaseClass::push_back(std::move(x));
+  }
+  template <typename... Args> reference emplace_back(Args &&...args) {
+    this->MoveToRAM();
+    return BaseClass::emplace_back(std::forward<Args>(args)...);
+  }
+  void pop_back() {
+    this->MoveToRAM();
+    BaseClass::pop_back();
+  }
+
+  template <typename... Args>
+  iterator emplace(const_iterator pos, Args &&...args) {
+    this->MoveToRAM();
+    return BaseClass::emplace(pos, std::forward<Args>(args)...);
+  }
+  iterator insert(const_iterator pos, const T &x) {
+    this->MoveToRAM();
+    return BaseClass::insert(pos, x);
+  }
+  iterator insert(const_iterator pos, T &&x) {
+    this->MoveToRAM();
+    return BaseClass::insert(pos, std::move(x));
+  }
+  template <typename InputIt>
+  iterator insert(const_iterator pos, InputIt first, InputIt last) {
+    this->MoveToRAM();
+    return BaseClass::insert(pos, first, last);
+  }
+  iterator erase(const_iterator pos) {
+    this->MoveToRAM();
+    return BaseClass::erase(pos);
+  }
+  iterator erase(const_iterator first, const_iterator last) {
+    this->MoveToRAM();
+    return BaseClass::erase(first, last);
+  }
+
+  void resize(size_t n) {
+    this->MoveToRAM();
+    BaseClass::resize(n);
+  }
+  void resize(size_t n, const T &x) {
+    this->MoveToRAM();
+    BaseClass::resize(n, x);
+  }
+  void reserve(size_t n) {
+    this->MoveToRAM();
+    BaseClass::reserve(n);
+  }
+  void clear() noexcept {
+    this->MoveToRAM();
+    BaseClass::clear();
+  }
+  template <typename InputIt> void assign(InputIt first, InputIt last) {
+    this->MoveToRAM();
+    BaseClass::assign(first, last);
+  }
+  void assign(size_type count, const T &value) {
+    this->MoveToRAM();
+    BaseClass::assign(count, value);
   }
 
   void remove_element(unsigned int index) {
-      std::swap(Base::get()->at(index),Base::get()->back());
-      Base::get()->pop_back();
+    this->MoveToRAM();
+    std::swap(this->at(index), this->back());
+    this->pop_back();
+  }
+
+  void remove_element(T &t) {
+    this->MoveToRAM();
+    std::swap(t, this->back());
+    this->pop_back();
+  }
+};
+
+template <typename T> void Vector<T>::PrintSelf(std::ostream &o) {
+  o << " *** uLib Vector *** \n";
+  o << " n. of items = " << this->size() << "\n";
+  for (int i = 0; i < this->size(); ++i)
+    o << (T)this->at(i) << " ";
+  o << "\n";
+}
+
+template <typename T>
+std::ostream &operator<<(std::ostream &o, const Vector<T> &v) {
+  for (int i = 0; i < v.size(); ++i)
+    o << (T)v.at(i) << " ";
+  o << "\n";
+  return o;
+}
+
+template <typename T>
+std::ofstream &operator<<(std::ofstream &o, const Vector<T> &v) {
+  for (int i = 0; i < v.size(); ++i)
+    o << (T)v.at(i) << " ";
+  return o;
+}
+
+template <typename T> std::istream &operator>>(std::istream &is, Vector<T> &v) {
+  T value;
+  while (is >> value) {
+    if (is.fail())
+      v.push_back(0);
+    else
+      v.push_back(value);
+  }
+  return is;
+}
+
+// Smart pointer Vector Implementation //
+
+template <typename T> class SmartVector : public SmartPointer<Vector<T>> {
+  typedef SmartPointer<Vector<T>> Base;
+
+public:
+  SmartVector() : Base(new Vector<T>()) {}
+  SmartVector(const SmartVector &copy) : Base(copy) {}
+  SmartVector(unsigned int size) : Base(new Vector<T>((int)size)) {}
+
+  virtual ~SmartVector() {}
+
+  T &operator[](int p) { return Base::get()->at(p); }
+
+  void swap_elements(unsigned int first, unsigned int second) {
+    std::swap(Base::get()->at(first), Base::get()->at(second));
+  }
+
+  void remove_element(unsigned int index) {
+    std::swap(Base::get()->at(index), Base::get()->back());
+    Base::get()->pop_back();
   }
 
   void remove_element(T &t) {
     std::swap(t, Base::get()->back());
     Base::get()->pop_back();
-    }
+  }
 };
 
-
-
-
 // ------ Utils ------------------------------------------------------------- //
 
-
-
 // RIFARE con iteratore !
 template <typename _Tp, class _CmpT>
-inline const unsigned long
-VectorSplice(const _Tp &_it, const _Tp &_end, const float value, _CmpT _comp)
-{
-    _Tp it = _it;
-    _Tp end = _end-1;
-    for(it; it != end;)
-    {
-        if (_comp(*it,value))       ++it;
-        else if(_comp(*end,value))  std::swap(*it,*end--);
-        else                        --end;
-    }
-    return it - _it;
+inline unsigned long VectorSplice(const _Tp &_it, const _Tp &_end,
+                                  const float value, _CmpT _comp) {
+  _Tp it = _it;
+  _Tp end = _end - 1;
+  for (; it != end;) {
+    if (_comp(*it, value))
+      ++it;
+    else if (_comp(*end, value))
+      std::swap(*it, *end--);
+    else
+      --end;
+  }
+  return it - _it;
 }
 
-
-
-} // uLib
-
-
-
-
+} // namespace uLib
 
 #endif // VECTOR_H

src/Core/testing/AffinityTest.cpp

@@ -0,0 +1,65 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <vector>
+#include <cassert>
+
+#ifdef __linux__
+#include <pthread.h>
+#include <sched.h>
+#endif
+
+using namespace uLib;
+
+void TestThreadAffinity() {
+    std::cout << "Testing Thread Affinity..." << std::endl;
+#ifdef __linux__
+    Thread t;
+    t.Start();
+    t.SetAffinity(0); // Bind to CPU 0
+    
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
+    assert(CPU_ISSET(0, &cpuset));
+    
+    t.Join();
+    std::cout << "  Passed (Thread bound to CPU 0)." << std::endl;
+#else
+    std::cout << "  Affinity not supported on this OS, skipping." << std::endl;
+#endif
+}
+
+void TestTeamAffinity() {
+    std::cout << "Testing Team Affinity..." << std::endl;
+#ifdef __linux__
+#ifdef _OPENMP
+    Team team(2);
+    std::vector<int> cpus = {0, 1};
+    team.SetAffinity(cpus);
+    
+    // We check affinity inside a parallel region
+    #pragma omp parallel
+    {
+        cpu_set_t cpuset;
+        CPU_ZERO(&cpuset);
+        pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+        int tid = Thread::GetThreadNum();
+        int expected_cpu = cpus[tid % cpus.size()];
+        assert(CPU_ISSET(expected_cpu, &cpuset));
+    }
+    std::cout << "  Passed (Team threads bound correctly)." << std::endl;
+#endif
+#else
+    std::cout << "  Affinity not supported on this OS, skipping." << std::endl;
+#endif
+}
+
+// Helper to get native handle if needed (oops, I forgot to add it to Thread class)
+// I'll add GetNativeHandle() to Thread class in Threads.h
+
+int main() {
+    TestThreadAffinity();
+    TestTeamAffinity();
+    std::cout << "All Affinity tests finished!" << std::endl;
+    return 0;
+}

src/Core/testing/CMakeLists.txt

@@ -8,7 +8,7 @@ set( TESTS
         ObjectCopyTest
         StaticInterfaceTest
         CommaInitTest
-        DebugTTreeDumpTest
+        # DebugTTreeDumpTest
         BoostTest
         BoostAccumulatorTest
         PropertiesTest
@@ -16,18 +16,32 @@ set( TESTS
         SerializeTest
         SerializeDreadDiamondTest
         DreadDiamondParameters
-        ObjectPropableTest
         UuidTest
         TypeIntrospectionTraversal
         OptionsTest
+        PingPongTest
+        VectorMetaAllocatorTest
+        PropertyTypesTest
+        HRPTest
+        PropertyGroupingTest
+        MutexTest
+        ThreadsTest
+        OpenMPTest
+        TeamTest
+        AffinityTest
 )
 
 set(LIBRARIES
        ${PACKAGE_LIBPREFIX}Core
        ${PACKAGE_LIBPREFIX}Math
-       ${Boost_SERIALIZATION_LIBRARY}
-       ${Boost_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
+       Boost::serialization
+       Boost::program_options
        ${ROOT_LIBRARIES}
+       OpenMP::OpenMP_CXX
 )
-uLib_add_tests(${uLib-module})
+uLib_add_tests(Core)
+
+if(USE_CUDA)
+    set_source_files_properties(VectorMetaAllocatorTest.cpp PROPERTIES LANGUAGE CUDA)
+endif()
+

src/Core/testing/HRPTest.cpp

@@ -0,0 +1,83 @@
+#include <iostream>
+#include <sstream>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Serializable.h"
+#include "Core/Archives.h"
+
+using namespace uLib;
+
+struct SimpleObject {
+    int value;
+    std::string name;
+ 
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & HRP(value);
+        ar & HRP(name);
+    }
+};
+ 
+struct DynamicObject : public Object {
+    float width;
+    int height;
+ 
+    DynamicObject() : width(10.0f), height(20) {
+        // Automatic registration of properties based on serialize/HRP
+        ULIB_ACTIVATE_PROPERTIES(*this);
+    }
+ 
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & HRP(width);
+        ar & HRP(height);
+    }
+};
+
+int main() {
+    SimpleObject obj;
+    obj.value = 42;
+    obj.name = "TestObject";
+
+    std::cout << "Testing HRP Serialization to Log..." << std::endl;
+    std::stringstream ss;
+    {
+        uLib::Archive::log_archive ar(ss);
+        ar << boost::serialization::make_nvp("Object", obj);
+    }
+    std::cout << ss.str() << std::endl;
+
+    std::cout << "Testing HRP Serialization to HRT..." << std::endl;
+    ss.str("");
+    {
+        uLib::Archive::hrt_oarchive ar(ss);
+        ar << obj;
+    }
+    std::cout << ss.str() << std::endl;
+ 
+    std::cout << "Testing HRP Serialization to XML..." << std::endl;
+    ss.str("");
+    {
+        uLib::Archive::xml_oarchive ar(ss);
+        ar << boost::serialization::make_nvp("Object", obj);
+    }
+    std::cout << ss.str() << std::endl;
+ 
+    std::cout << "Testing Dynamic Property Creation via ULIB_ACTIVATE_PROPERTIES macro..." << std::endl;
+    DynamicObject dynObj;
+    // (properties were already created in DynamicObject constructor via macro)
+    
+    std::cout << "Registered Properties in dynObj:" << std::endl;
+    const auto& props = dynObj.GetProperties();
+    for (auto* p : props) {
+        std::cout << "  - [" << p->GetTypeName() << "] " << p->GetName() << " = " << p->GetValueAsString() << std::endl;
+    }
+    
+    if (props.size() == 2) {
+        std::cout << "Dynamic Property Creation SUCCESS!" << std::endl;
+    } else {
+        std::cout << "Dynamic Property Creation FAILED (Expected 2, got " << props.size() << ")" << std::endl;
+    }
+ 
+    return 0;
+}

src/Core/testing/Makefile.am

@@ -19,7 +19,6 @@ TESTS = SmartPointerTest \
 	SerializeTest \
 	SerializeDreadDiamondTest \
 	DreadDiamondParameters \
-	ObjectPropableTest \
 	TypeIntrospectionTraversal \
         OptionsTest
 

src/Core/testing/MutexTest.cpp

@@ -0,0 +1,109 @@
+#include "Core/Monitor.h"
+#include <iostream>
+#include <chrono>
+#include <thread>
+#include <vector>
+#include <cassert>
+
+using namespace uLib;
+
+void TestBasicLock() {
+    std::cout << "Testing basic Mutex Lock/Unlock..." << std::endl;
+    Mutex m;
+    m.Lock();
+    m.Unlock();
+    assert(m.TryLock());
+    m.Unlock();
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestScopedLock() {
+    std::cout << "Testing Mutex::ScopedLock..." << std::endl;
+    Mutex m;
+    {
+        Mutex::ScopedLock lock(m);
+        assert(!m.TryLock());
+    }
+    assert(m.TryLock());
+    m.Unlock();
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestTimedLock() {
+    std::cout << "Testing Mutex TryLockFor..." << std::endl;
+    Mutex m;
+    m.Lock();
+    auto start = std::chrono::steady_clock::now();
+    bool locked = m.TryLockFor(100);
+    auto end = std::chrono::steady_clock::now();
+    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+    
+    assert(!locked);
+    assert(diff >= 100);
+    m.Unlock();
+    std::cout << "  Passed (waited " << diff << "ms)." << std::endl;
+}
+
+void TestMacros() {
+    std::cout << "Testing ULIB_STATIC_LOCK and ULIB_MUTEX_LOCK macros..." << std::endl;
+    
+    int counter = 0;
+    auto task = [&]() {
+        for(int i=0; i<500; ++i) {
+            ULIB_STATIC_LOCK(-1) {
+                counter++;
+            }
+        }
+    };
+    
+    std::vector<std::thread> threads;
+    for(int i=0; i<4; ++i) threads.emplace_back(task);
+    for(auto& t : threads) t.join();
+    
+    assert(counter == 2000);
+    
+    Mutex m;
+    int counter2 = 0;
+    ULIB_MUTEX_LOCK(m, -1) {
+        counter2++;
+    }
+    assert(counter2 == 1);
+    
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestMonitor() {
+    std::cout << "Testing Monitor pattern..." << std::endl;
+    struct Resource {
+        int value = 0;
+        void increment() { value++; }
+    };
+    
+    Monitor<Resource> monitor(new Resource());
+    
+    auto task = [&]() {
+        for(int i=0; i<1000; ++i) {
+            monitor.Access([](Resource& r) {
+                r.increment();
+            });
+        }
+    };
+    
+    std::vector<std::thread> threads;
+    for(int i=0; i<5; ++i) threads.emplace_back(task);
+    for(auto& t : threads) t.join();
+    
+    int final_value = monitor.Access([](Resource& r) { return r.value; });
+    assert(final_value == 5000);
+    std::cout << "  Passed (final value: " << final_value << ")." << std::endl;
+}
+
+int main() {
+    TestBasicLock();
+    TestScopedLock();
+    TestTimedLock();
+    TestMacros();
+    TestMonitor();
+    std::cout << "All Mutex and Monitor tests passed!" << std::endl;
+    return 0;
+}

src/Core/testing/ObjectPropableTest.cpp

@@ -1,237 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#include <iostream>
-#include <fstream>
-#include <typeinfo>
-#include <string>
-
-
-#include "Core/Types.h"
-#include "Core/Object.h"
-#include "Core/ObjectProps.h"
-#include "Core/StringReader.h"
-#include "Math/Dense.h"
-
-#include "boost/archive/text_oarchive.hpp"
-#include "boost/archive/text_iarchive.hpp"
-
-
-#include "testing-prototype.h"
-
-
-
-
-using namespace uLib;
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// STRUCTURES //
-
-
-struct A : virtual Object {
-
-    uLibTypeMacro(A, Object)
-
-    properties() {
-        int      p_a;
-        Vector3f p_3f;
-    };
-
-    int m_a;
-};
-
-void A::init_properties() {
-    $_init();
-    $$.p_a   = 0;
-    $$.p_3f << 1,2,3;
-}
-
-ULIB_SERIALIZABLE_OBJECT(A)
-ULIB_SERIALIZE_OBJECT(A, Object) { ar & AR(m_a); }
-ULIB_SERIALIZE_OBJECT_PROPS(A)   { ar & AR(p_a) & AR(p_3f); }
-
-
-
-
-struct B : A {
-    uLibTypeMacro(B,A)
-
-    properties() {
-        std::string p;
-    };
-
-    B() : m_b(324) {}
-
-    int m_b;
-};
-
-
-void B::init_properties() {
-    $_init();
-    $$.p = "ciao";
-}
-
-ULIB_SERIALIZABLE_OBJECT(B)
-ULIB_SERIALIZE_OBJECT(B,A)     { ar & AR(m_b); }
-ULIB_SERIALIZE_OBJECT_PROPS(B) { ar & AR(p);   }
-
-
-
-struct C {
-    int m_c;    
-    std::string m_str;
-};
-
-ULIB_SERIALIZABLE(C)
-ULIB_SERIALIZE(C) { ar & AR(m_c) & AR(m_str); }
-
-
-
-struct D : virtual Object, B {
-    uLibTypeMacro(D,Object,B)
-
-    properties() {
-        C p_c;
-    };
-};
-
-void D::init_properties() {
-    $_init();
-    $$.p_c.m_c = 1234;
-}
-
-ULIB_SERIALIZABLE_OBJECT(D)
-ULIB_SERIALIZE_OBJECT(D,Object) {}
-ULIB_SERIALIZE_OBJECT_PROPS(D) {
- ar & AR(p_c);
-}
-
-
-
-class E : public C, public D {
-    uLibTypeMacro(E,D,C)
-public:
-        E() : m_Ea(5552368) {}
-        int m_Ea;
-};
-
-ULIB_SERIALIZABLE_OBJECT(E)
-ULIB_SERIALIZE_OBJECT(E,C,D) {
-    ar & AR(m_Ea);
-}
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// TESTS //
-
-
-int test_xml_direct() {
-    // TEST ARCHIVE SAVE AND LOAD direct //
-    E o; o.init_properties();
-    o.$$.p_c.m_str = "works";
-    {
-        std::ofstream file("test.xml");
-        Archive::xml_oarchive ar(file);
-        ar << NVP(o);
-    }
-    o.$$.p_c.m_str = "hola";
-    {
-        std::ifstream file("test.xml");
-        Archive::xml_iarchive ar(file);
-        ar >> NVP(o);
-    }
-    std::cout << o.$$.p_c.m_str << "\n";
-    return ( o.$$.p_c.m_str == "works" );
-}
-
-
-int test_xml_pointer() {
-    // TEST ARCHIVE SAVE AND LOAD from pointer //
-    E *o = new E; o->init_properties();
-    o->$$.p_c.m_str = "works";
-    {
-        std::ofstream file("test.xml");
-        Archive::xml_oarchive ar(file);
-        ar << NVP(o);
-    }
-    o->$$.p_c.m_str = "hola";
-    {
-        std::ifstream file("test.xml");
-        Archive::xml_iarchive ar(file);
-        ar >> NVP(o);
-    }
-    std::cout << o->$$.p_c.m_str << "\n";
-    return ( o->$$.p_c.m_str == "works" );
-}
-
-
-int test_xml_objsave() {
-    // TEST SELF SAVE
-    E o; o.init_properties();
-    o.$(B).p = "works";
-    {
-        std::ofstream file("test.xml");
-        Object::SaveXml(file,o);
-    }
-    o.$(B).p = "hola";
-    {
-        std::ifstream file("test.xml");
-        Object::LoadXml(file,o);
-    }
-
-    std::cout << o.$(B).p << "\n";
-    return ( o.$(B).p == "works" );
-}
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// MAIN //
-
-int main()
-{
-    BEGIN_TESTING(PropableTest);
-
-    TEST1( test_xml_direct()  );
-    TEST1( test_xml_pointer() );
-    TEST1( test_xml_objsave() );
-
-    END_TESTING;
-}
-
-

src/Core/testing/OpenMPTest.cpp

@@ -0,0 +1,47 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <cassert>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+using namespace uLib;
+
+class OpenMPThread : public Thread {
+public:
+    void Run() override {
+#ifdef _OPENMP
+        Thread::SetNumThreads(2);
+        int max = Thread::GetNumThreads();
+        std::cout << "  OpenMP max threads in uLib::Thread: " << max << std::endl;
+        
+        int shared_counter = 0;
+        #pragma omp parallel reduction(+:shared_counter)
+        {
+            shared_counter += 1;
+        }
+        std::cout << "  Parallel region executed with " << shared_counter << " threads." << std::endl;
+        assert(shared_counter <= max);
+#else
+        std::cout << "  OpenMP not available, skipping parallel check." << std::endl;
+        assert(Thread::GetNumThreads() == 1);
+#endif
+    }
+};
+
+int main() {
+    std::cout << "Testing OpenMP compatibility..." << std::endl;
+#ifdef _OPENMP
+    std::cout << "  OpenMP is AVAILABLE." << std::endl;
+#else
+    std::cout << "  OpenMP is NOT available." << std::endl;
+#endif
+
+    OpenMPThread t;
+    t.Start();
+    t.Join();
+
+    std::cout << "OpenMP compatibility test finished!" << std::endl;
+    return 0;
+}

src/Core/testing/PingPongTest.cpp

@@ -0,0 +1,52 @@
+#include "Core/Object.h"
+#include "Core/Signal.h"
+#include "testing-prototype.h"
+#include <iostream>
+
+using namespace uLib;
+
+class Ping : public Object {
+public:
+signals:
+  void PingSignal(int count);
+public slots:
+  void OnPong(int count) {
+    std::cout << "Ping received Pong " << count << std::endl;
+    if (count > 0)
+      ULIB_SIGNAL_EMIT(Ping::PingSignal, count - 1);
+  }
+};
+
+void Ping::PingSignal(int count) { ULIB_SIGNAL_EMIT(Ping::PingSignal, count); }
+
+class Pong : public Object {
+public:
+signals:
+  void PongSignal(int count);
+public slots:
+  void OnPing(int count) {
+    std::cout << "Pong received Ping " << count << std::endl;
+    if (count > 0)
+      ULIB_SIGNAL_EMIT(Pong::PongSignal, count - 1);
+  }
+};
+
+void Pong::PongSignal(int count) { ULIB_SIGNAL_EMIT(Pong::PongSignal, count); }
+
+int main() {
+  BEGIN_TESTING(PingPong);
+  Ping ping;
+  Pong pong;
+
+  std::cout << "Connecting ping to pong" << std::endl;
+  Object::connect(&ping, &Ping::PingSignal, &pong, &Pong::OnPing);
+
+  std::cout << "Connecting pong to ping" << std::endl;
+  Object::connect(&pong, &Pong::PongSignal, &ping, &Ping::OnPong);
+
+  std::cout << "Emitting PingSignal(5)" << std::endl;
+  ping.PingSignal(5);
+
+  END_TESTING;
+  return 0;
+}

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

src/Core/testing/PropertySystemTest.cpp

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <sstream>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include <cassert>
+
+using namespace uLib;
+
+class TestObject : public Object {
+public:
+  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;
+};
+
+int main() {
+  TestObject obj;
+  
+  std::cout << "Testing Properties..." << std::endl;
+  
+  // 1. Check registration
+  const auto& props = obj.GetProperties();
+  assert(props.size() == 2);
+  assert(props[0]->GetName() == "IntProp");
+  assert(props[1]->GetName() == "StringProp");
+  
+  // 2. Check value access and signals
+  bool signalCalled = false;
+  uLib::Object::connect(&obj.IntProp, &Property<int>::PropertyChanged, [&signalCalled]() {
+      signalCalled = true;
+  });
+  
+  assert(obj.IntProp.Get() == 10);
+  obj.IntProp = 20;
+  assert(obj.IntProp.Get() == 20);
+  assert(signalCalled == true);
+  
+  // 3. Check serialization
+  std::stringstream ss;
+  Object::SaveXml(ss, obj);
+  std::string xml = ss.str();
+  std::cout << "Serialized XML: \n" << xml << std::endl;
+  
+  assert(xml.find("<IntProp>20</IntProp>") != std::string::npos);
+  assert(xml.find("<StringProp>Initial</StringProp>") != std::string::npos);
+  
+  // 4. Check deserialization
+  TestObject obj2;
+  std::stringstream ss2(xml);
+  Object::LoadXml(ss2, obj2);
+  
+  assert(obj2.IntProp.Get() == 20);
+  assert(obj2.StringProp.Get() == "Initial");
+  
+  std::cout << "All Property Tests PASSED!" << std::endl;
+  
+  return 0;
+}

src/Core/testing/PropertyTypesTest.cpp

@@ -0,0 +1,68 @@
+#include <iostream>
+#include <sstream>
+#include <cassert>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Math/Dense.h"
+
+using namespace uLib;
+
+class TestObject : public Object {
+public:
+  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);
+  FloatProperty   FloatProp  = FloatProperty(this, "FloatProp", 3.14f);
+  BoolProperty    BoolProp   = BoolProperty(this, "BoolProp", true);
+
+  // Use new macro
+  ULIB_PROPERTY(Matrix3f, MatrixProp, Matrix3f::Identity())
+
+  // Use new Dense typedefs
+  Vector3fProperty Vector3fProp = Vector3fProperty(this, "Vector3fProp", Vector3f(1.1f, 2.2f, 3.3f));
+  Matrix4fProperty Matrix4fProp = Matrix4fProperty(this, "Matrix4fProp", Matrix4f::Identity());
+};
+
+int main() {
+  TestObject obj;
+  
+  std::cout << "Testing Property Types..." << std::endl;
+  
+  // 1. Verify string representation
+  std::cout << "StringProp: " << obj.StringProp.GetValueAsString() << std::endl;
+  assert(obj.StringProp.GetValueAsString() == "Initial");
+
+  std::cout << "IntProp: " << obj.IntProp.GetValueAsString() << std::endl;
+  assert(obj.IntProp.GetValueAsString() == "42");
+
+  std::cout << "FloatProp: " << obj.FloatProp.GetValueAsString() << std::endl;
+  // boost::lexical_cast might have different precision, but for 3.14 it should be okay or we check find
+  assert(obj.FloatProp.GetValueAsString().find("3.14") != std::string::npos);
+
+  std::cout << "BoolProp: " << obj.BoolProp.GetValueAsString() << std::endl;
+  // Bool might be "1" or "true" depending on lexical_cast/stringstream
+  assert(obj.BoolProp.GetValueAsString() == "1" || obj.BoolProp.GetValueAsString() == "true");
+
+  // 2. Verify Matrix/Vector string representation (uses operator<<)
+  std::cout << "MatrixProp: \n" << obj.MatrixProp.GetValueAsString() << std::endl;
+  assert(obj.MatrixProp.GetValueAsString().find("1 0 0") != std::string::npos);
+
+  std::cout << "Vector3fProp: " << obj.Vector3fProp.GetValueAsString() << std::endl;
+  assert(obj.Vector3fProp.GetValueAsString().find("1.1 2.2 3.3") != std::string::npos);
+
+  std::cout << "Matrix4fProp: \n" << obj.Matrix4fProp.GetValueAsString() << std::endl;
+  assert(obj.Matrix4fProp.GetValueAsString().find("1 0 0 0") != std::string::npos);
+
+  // 3. Verify updates and signals
+  obj.IntProp = 100;
+  assert(obj.IntProp.Get() == 100);
+  assert(obj.IntProp.GetValueAsString() == "100");
+
+  std::cout << "All Property Type Tests PASSED!" << std::endl;
+  
+  return 0;
+}

src/Core/testing/SerializeDreadDiamondTest.cpp

@@ -23,13 +23,10 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
-#include <iostream>
 #include <fstream>
-#include <typeinfo>
+#include <iostream>
 #include <string>
+#include <typeinfo>
 
 #include "Core/Object.h"
 
@@ -37,78 +34,43 @@
 
 using namespace uLib;
 
-
-
-
-
-
-
-struct A :  Object {
-    uLibTypeMacro(A,Object)
-    A() : numa(5552368) {}
-    int numa;
+struct A : Object {
+  uLibTypeMacro(A, Object) A() : numa(5552368) {}
+  int numa;
 };
 
-
 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) {}
-    int numb;
+  uLibTypeMacro(B, Object) B() : numb(5552369) {}
+  int numb;
 };
 
 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) {}
-    int numc;
+  uLibTypeMacro(C, B) C() : numc(5552370) {}
+  int numc;
 };
 
 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)
+struct D : A, B {
+  uLibTypeMacro(D, A, B)
 
-    D() : numd(5552371) {}
-    int numd;
+      D()
+      : numd(5552371) {}
+  int numd;
 };
 
 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;
 
-
-main() {
-    A o; o.init_properties();
-
-    Archive::xml_oarchive(std::cout) << NVP(o);
-
+  Archive::xml_oarchive(std::cout) << NVP(o);
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

src/Core/testing/SerializeTest.cpp

@@ -23,20 +23,16 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
-#include <iostream>
 #include <fstream>
+#include <iostream>
 
-#include "Core/Object.h"
 #include "Core/Archives.h"
+#include "Core/Object.h"
 
 #include "testing-prototype.h"
 
 using namespace uLib;
 
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -45,63 +41,51 @@ using namespace uLib;
 
 struct V3f {
 
-    float x,y,z;
-    V3f()
-    { x = y = z =0; }
+  float x, y, z;
+  V3f() { x = y = z = 0; }
 
-    V3f(float x, float y, float z) :
-        x(x), y(y), z(z) {}
+  V3f(float x, float y, float z) : x(x), y(y), z(z) {}
 
-    template <class Archive>
-    void serialize (Archive &ar,unsigned int v) {
-        ar
-                & "<" & NVP(x) & NVP(y) & NVP(z) & ">";
-    }
+  template <class Archive> void serialize(Archive &ar, unsigned int v) {
+    ar & "<" & NVP(x) & NVP(y) & NVP(z) & ">";
+  }
 };
 
 ULIB_CLASS_EXPORT_KEY(V3f);
 ULIB_CLASS_EXPORT_IMPLEMENT(V3f);
 
-
-inline std::ostream &
-operator <<(std::ostream &o, const V3f &v) {
-    Archive::hrt_oarchive(o) << v;
-    return o;
+inline std::ostream &operator<<(std::ostream &o, const V3f &v) {
+  Archive::hrt_oarchive(o) << v;
+  return o;
 }
 
-inline std::istream &
-operator >>(std::istream &is, V3f &v) {
-    Archive::hrt_iarchive(is) >> v;
-    return is;
+inline std::istream &operator>>(std::istream &is, V3f &v) {
+  Archive::hrt_iarchive(is) >> v;
+  return is;
 }
 
-
-
-
 int test_V3f() {
-    // testing human readble archive with simple serializable structure //
+  // testing human readble archive with simple serializable structure //
 
-    V3f v1(1,2,3),v2,v3,v4;
-    std::cout << "v    --> " << v1 << "\n";
+  V3f v1(1, 2, 3), v2, v3, v4;
+  std::cout << "v    --> " << v1 << "\n";
 
-    std::stringstream ss; ss << v1;
-    std::cout << "ss.v --> " << ss.str() << "\n";
+  std::stringstream ss;
+  ss << v1;
+  std::cout << "ss.v --> " << ss.str() << "\n";
 
-    Archive::hrt_iarchive ar(ss); ar >> v2;
-    std::cout << "v2   --> " << v2 << "\n";
+  Archive::hrt_iarchive ar(ss);
+  ar >> v2;
+  std::cout << "v2   --> " << v2 << "\n";
 
-    std::stringstream("<2 3 4>") >> v3;
-    std::cout << "v3   --> " << v3 << "\n";
+  std::stringstream("<2 3 4>") >> v3;
+  std::cout << "v3   --> " << v3 << "\n";
 
-    //    std::cout << "insert V3f string to parse: "; std::cin >> v4;
-    //    std::cout << "v4   --> " << v4 << "\n";
-    return (1);
+  //    std::cout << "insert V3f string to parse: "; std::cin >> v4;
+  //    std::cout << "v4   --> " << v4 << "\n";
+  return (1);
 }
 
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -109,104 +93,72 @@ int test_V3f() {
 // OBJECT SERIALIZATION //
 
 class A : public virtual Object {
-    uLibTypeMacro(A,Object)
-    ULIB_SERIALIZE_ACCESS
-public:
-    A() : m_a(5552368) {}
+uLibTypeMacro(A, Object) ULIB_SERIALIZE_ACCESS public : A() : m_a(5552368) {}
 
-    properties() {
-        std::string p_a;
-    };
+  void init_properties();
+  std::string p_a;
+
+  uLibRefMacro(a, int);
 
-    uLibRefMacro (a,int);
 private:
-    int m_a;
+  int m_a;
 };
 
-void A::init_properties() {
-    $_init();
-    $$.p_a = "A property string";
-}
+void A::init_properties() { p_a = "A property string"; }
 
 ULIB_SERIALIZABLE_OBJECT(A)
-ULIB_SERIALIZE_OBJECT(A,Object) {
-    ar
-            & "Object A : "
-            & "--> m_a = " & AR(m_a)
-            & "\n";
+ULIB_SERIALIZE_OBJECT(A, Object) {
+  ar & "Object A : " & "--> m_a = " & AR(m_a) & "\n" & "Object A properties: " &
+      "---> p_a = " & AR(p_a) & "\n";
 }
 
-ULIB_SERIALIZE_OBJECT_PROPS(A) {
-    ar
-            & "Object A properties: "
-            & "---> p_a = " & AR(p_a) & "\n";
-}
-
-
-
 int testing_xml_class() {
 
-    A a; a.init_properties();
+  A a;
+  a.init_properties();
 
-    {
-        std::ofstream file("test.xml");
-        Archive::xml_oarchive(file) << NVP(a);
-    }
-    a.a() = 0;
-    a.$$.p_a = "zero string";
-    {
-        std::ifstream file("test.xml");
-        Archive::xml_iarchive(file) >> NVP(a);
-    }
+  {
+    std::ofstream file("test.xml");
+    Archive::xml_oarchive(file) << NVP(a);
+  }
+  a.a() = 0;
+  a.p_a = "zero string";
+  {
+    std::ifstream file("test.xml");
+    Archive::xml_iarchive(file) >> NVP(a);
+  }
 
-    Archive::xml_oarchive(std::cout) << NVP(a);
-    return ( a.a() == 5552368 && a.$$.p_a == "A property string" );
+  Archive::xml_oarchive(std::cout) << NVP(a);
+  return (a.a() == 5552368 && a.p_a == "A property string");
 }
 
 int testing_hrt_class() {
 
-    A a; a.init_properties();
+  A a;
+  a.init_properties();
 
-    {
-        std::ofstream file("test.xml");
-        Archive::hrt_oarchive(file) << NVP(a);
-    }
-    a.a() = 0;
-    a.$$.p_a = "zero string";
-    {
-        // ERRORE FIX !
-        //        std::ifstream file("test.xml");
-        //        Archive::hrt_iarchive(file) >> NVP(a);
-    }
+  {
+    std::ofstream file("test.xml");
+    Archive::hrt_oarchive(file) << NVP(a);
+  }
+  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" );
+  Archive::hrt_oarchive(std::cout) << NVP(a);
+  return (a.a() == 5552368 && a.p_a == "A property string");
 }
 
-
-
-
-
-
 int main() {
-    BEGIN_TESTING(Serialize Test);
+  BEGIN_TESTING(Serialize Test);
 
-    TEST1( test_V3f() );
-    TEST1( testing_xml_class() );
-    //    testing_hrt_class(); ///// << ERRORE in HRT with properties
+  TEST1(test_V3f());
+  TEST1(testing_xml_class());
+  //    testing_hrt_class(); ///// << ERRORE in HRT with properties
 
-    END_TESTING;
+  END_TESTING;
 }
-
-
-
-
-
-
-
-
-
-
-
-
-

src/Core/testing/SignalTest.cpp

@@ -23,93 +23,63 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #include <iostream>
 #include <typeinfo>
 
-
-#include "testing-prototype.h"
-#include "Core/Types.h"
 #include "Core/Object.h"
 #include "Core/Signal.h"
-
+#include "Core/Types.h"
+#include "testing-prototype.h"
 
 using namespace uLib;
 
-
-
-
 class Ob1 : public Object {
 public:
-
-
 signals:
-    void V0();
-
-    int V1(int a);
+  void V0();
 
+  void V1(int a);
 };
 
-
-
-
 // should be done by moc //
-void Ob1::V0() {
-    ULIB_SIGNAL_EMIT(Ob1::V0);
-}
-
-int Ob1::V1(int a) {
-    ULIB_SIGNAL_EMIT(Ob1::V1,a);
-}
-
-
-
+void Ob1::V0() { ULIB_SIGNAL_EMIT(Ob1::V0); }
 
+void Ob1::V1(int a) { ULIB_SIGNAL_EMIT(Ob1::V1, a); }
 
 class Ob2 : public Object {
 
 public slots:
-    void PrintV0() {
-        std::cout << "Ob2 prints V0\n" << std::flush;
-    }
+  void PrintV0() { std::cout << "Ob2 prints V0\n" << std::flush; }
 };
 
 class Ob3 : public Object {
 
 public slots:
-    void PrintV0() {
-        std::cout << "Ob3 prints V0\n" << std::flush;
-    }
+  void PrintV0() { std::cout << "Ob3 prints V0\n" << std::flush; }
 
-    void PrintNumber(int n) {
-        std::cout << "Ob3 is printing number: " << n << "\n";
-    }
+  void PrintNumber(int n) {
+    std::cout << "Ob3 is printing number: " << n << "\n";
+  }
 };
 
-
-
-
 int main() {
-    BEGIN_TESTING(Signals);
+  BEGIN_TESTING(Signals);
 
-    Ob1 ob1;
-    Ob2 ob2;
-    Ob3 ob3;
+  Ob1 ob1;
+  Ob2 ob2;
+  Ob3 ob3;
 
-    Object::connect(&ob1,&Ob1::V0,&ob2,&Ob2::PrintV0);
-    Object::connect(&ob1,&Ob1::V0,&ob3,&Ob3::PrintV0);
-    Object::connect(&ob1,&Ob1::V1,&ob3,&Ob3::PrintNumber);
+  Object::connect(&ob1, &Ob1::V0, &ob2, &Ob2::PrintV0);
+  Object::connect(&ob1, &Ob1::V0, &ob3, &Ob3::PrintV0);
+  Object::connect(&ob1, &Ob1::V1, &ob3, &Ob3::PrintNumber);
 
-    //  not working yet
-    //    Object::connect(&ob1,SIGNAL(V0(),&ob2,SLOT(PrintV0())
+  //  not working yet
+  //    Object::connect(&ob1,SIGNAL(V0(),&ob2,SLOT(PrintV0())
 
-    ob1.PrintSelf(std::cout);
+  ob1.PrintSelf(std::cout);
 
-    emit ob1.V0();
-    emit ob1.V1(5552368);
+  emit ob1.V0();
+  emit ob1.V1(5552368);
 
-    END_TESTING;
+  END_TESTING;
 }
-
-

src/Core/testing/StaticInterfaceTest.cpp

@@ -23,90 +23,73 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
 #include <iostream>
 
 #include "testing-prototype.h"
 #include <Core/StaticInterface.h>
 
-
-
 namespace uLib {
 
 //// INTERFACE TO COMPLEX CLASS /////
 
 namespace Interface {
 struct Test {
-    MAKE_TRAITS
-    template<class Self> void check_structural() {
-        uLibCheckFunction(Self,test,bool,int,float);
-        uLibCheckMember(Self,testmemb,int);
-    }
+  MAKE_TRAITS
+  template <class Self> void check_structural() {
+    uLibCheckFunction(Self, test, bool, int, float);
+    uLibCheckMember(Self, testmemb, int);
+  }
 };
-}
+} // namespace Interface
 
 struct Test {
-    bool test(int i, float f){}
-    int testmemb;
+  bool test(int i, float f) { return true; }
+  int testmemb;
 };
 
-
-
 //// INTERFAC TO SIMPLE CLASS ///////////
 
 namespace Interface {
 struct Simple {
-    MAKE_TRAITS
-    template<class Self> void check_structural() {
-        uLibCheckMember(Self,memb1,int);
-        uLibCheckMember(Self,memb2,float);
-    }
+  MAKE_TRAITS
+  template <class Self> void check_structural() {
+    uLibCheckMember(Self, memb1, int);
+    uLibCheckMember(Self, memb2, float);
+  }
 };
-}
+} // namespace Interface
 
 struct Simple {
-    int memb1;
-    float memb2;
+  int memb1;
+  float memb2;
 };
 
-
 /////////////////////////
 
-template <class T>
-class UseTest {
+template <class T> class UseTest {
 public:
-    UseTest() {
-        Interface::IsA<T,Interface::Test>();
-        T t;
-        int i; float f;
-        t.test(i,f);
-    }
+  UseTest() {
+    Interface::IsA<T, Interface::Test>();
+    T t;
+    int i;
+    float f;
+    t.test(i, f);
+  }
 };
 
-template <class T>
-class UseSimple {
+template <class T> class UseSimple {
 public:
-    UseSimple() {
-        Interface::IsA<T,Interface::Simple>();
-    }
+  UseSimple() { Interface::IsA<T, Interface::Simple>(); }
 };
 
+} // namespace uLib
 
+int main() {
+  BEGIN_TESTING(Static Interface);
 
+  uLib::UseTest<uLib::Test> u;
+
+  uLib::UseSimple<uLib::Simple> s;
+
+  END_TESTING;
 }
-
-int main()
-{
-    BEGIN_TESTING(Static Interface);
-
-
-
-    uLib::UseTest<uLib::Test> u;
-
-    uLib::UseSimple<uLib::Simple> s;
-
-    END_TESTING;
-}
-

src/Core/testing/TeamTest.cpp

@@ -0,0 +1,40 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <atomic>
+#include <cassert>
+#include <vector>
+
+using namespace uLib;
+
+void TestTaskTeam() {
+    std::cout << "Testing Task and Team..." << std::endl;
+    
+    std::atomic<int> counter(0);
+    auto task_func = [&]() {
+        counter++;
+        Thread::Sleep(10);
+    };
+    
+    Team team(4);
+    std::cout << "  Team size: " << team.GetSize() << std::endl;
+
+#ifdef _OPENMP
+    #pragma omp parallel
+    #pragma omp single
+#endif
+    {
+        for (int i = 0; i < 20; ++i) {
+            team.Run(new Task(task_func));
+        }
+        team.Wait();
+    }
+    
+    assert(counter == 20);
+    std::cout << "  Passed (counter: " << counter << ")." << std::endl;
+}
+
+int main() {
+    TestTaskTeam();
+    std::cout << "All Team tests passed!" << std::endl;
+    return 0;
+}

src/Core/testing/ThreadsTest.cpp

@@ -0,0 +1,72 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <atomic>
+#include <cassert>
+
+using namespace uLib;
+
+class MyThread : public Thread {
+public:
+    MyThread() : counter(0) {}
+    void Run() override {
+        for (int i = 0; i < 5; ++i) {
+            counter++;
+            Thread::Sleep(10);
+        }
+    }
+    std::atomic<int> counter;
+};
+
+void TestBasicThread() {
+    std::cout << "Testing basic Thread lifecycle..." << std::endl;
+    MyThread t;
+    assert(!t.IsRunning());
+    t.Start();
+    assert(t.IsRunning());
+    t.Join();
+    assert(!t.IsRunning());
+    assert(t.counter == 5);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestThreadDetach() {
+    std::cout << "Testing Thread Detach..." << std::endl;
+    std::atomic<bool> done(false);
+    
+    // Using a lambda or a simple subclass
+    class DetachedThread : public Thread {
+    public:
+        DetachedThread(std::atomic<bool>& d) : m_done(d) {}
+        void Run() override {
+            Thread::Sleep(50);
+            m_done = true;
+        }
+        std::atomic<bool>& m_done;
+    };
+    
+    {
+        DetachedThread* t = new DetachedThread(done);
+        t->Start();
+        t->Detach();
+        // The thread object 't' is still alive here, 
+        // but it will be destroyed soon if we delete it.
+        // For a detached thread using members, we MUST keep it alive.
+        
+        int wait_count = 0;
+        while(!done && wait_count < 20) {
+            Thread::Sleep(10);
+            wait_count++;
+        }
+        delete t;
+    }
+    
+    assert(done);
+    std::cout << "  Passed." << std::endl;
+}
+
+int main() {
+    TestBasicThread();
+    TestThreadDetach();
+    std::cout << "All Thread tests passed!" << std::endl;
+    return 0;
+}