Minor changed in beam tracing

.gitignore

@@ -1,3 +1,3 @@
 CMakeFiles/
 build/
-.cache/
+

.vscode/settings.json

@@ -1,8 +0,0 @@
-{
-    "clangd.fallbackFlags": [
-        "-I${workspaceFolder}/src",
-        "-I/home/share/micromamba/envs/mutom/include",
-        "-I/home/rigoni/.conan2/p/eigen5481853932f72/p/include/eigen3"
-    ],
-    "clangd.semanticHighlighting.enable": true
-}

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(INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables")
+set(PACKAGE_INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables")
-set(INSTALL_LIB_DIR lib/${PACKAGE_NAME} CACHE PATH "Installation directory for libraries")
+set(PACKAGE_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(PACKAGE_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")
+set(PACKAGE_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(INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")
+set(PACKAGE_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 ${INSTALL_BIN_DIR} COMPONENT bin
+         RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib
+         LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib
-  #         PUBLIC_HEADER DESTINATION ${INSTALL_INC_DIR} COMPONENT dev
+  #         PUBLIC_HEADER DESTINATION ${PACKAGE_INSTALL_INC_DIR} COMPONENT dev
   )
  endif(SOURCES)
 
  if(HEADERS)
   foreach(header ${HEADERS})
-   install(FILES ${header} DESTINATION ${INSTALL_INC_DIR}/${name})
+   install(FILES ${header} DESTINATION ${PACKAGE_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 ${INSTALL_BIN_DIR} COMPONENT bin
+            RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
            )
 ENDMACRO(uLib_add_target)
 

CMakeLists.txt

@@ -3,7 +3,7 @@
 ##### CMAKE LISTS ##############################################################
 ################################################################################
 
-cmake_minimum_required (VERSION 3.26)
+cmake_minimum_required (VERSION 2.6)
 
 ## -------------------------------------------------------------------------- ##
 
@@ -11,7 +11,7 @@ project(uLib)
 
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 6)
+set(PROJECT_VERSION_MINOR 4)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
@@ -33,31 +33,19 @@ message(STATUS "Module path = ${CMAKE_MODULE_PATH}")
 
 ## GLOBALS ------------------------------------------------------------------ ##
 
-# -- move to GnuInstallDirs
+set(PACKAGE_INSTALL_BIN_DIR ${CMAKE_INSTALL_PREFIX}/bin 
-# ref: https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+    CACHE PATH "Installation directory for executables")
-include(GNUInstallDirs)
+set(PACKAGE_INSTALL_LIB_DIR ${CMAKE_INSTALL_PREFIX}/lib/
-set(INSTALL_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR}/${PACKAGE_NAME}
+    CACHE PATH "Installation directory for libraries")
-    CACHE PATH "Location of header files (.../include)" )
+set(PACKAGE_INSTALL_INC_DIR ${CMAKE_INSTALL_PREFIX}/include/${PACKAGE_NAME}
-set(INSTALL_ETC_DIR ${CMAKE_INSTALL_SYSCONFDIR}/${PACKAGE_NAME}
+    CACHE PATH "Installation directory for headers")
-    CACHE PATH "Location of configuration files (.../etc)" )
+set(PACKAGE_INSTALL_DATA_DIR ${CMAKE_INSTALL_PREFIX}/share/${PACKAGE_NAME}
-set(INSTALL_BIN_DIR ${CMAKE_INSTALL_BINDIR}/${PACKAGE_NAME}
+    CACHE PATH "Installation directory for data files")
-    CACHE PATH "Location of executable files (.../bin)" )
+set(PACKAGE_INSTALL_CMAKE_DIR ${CMAKE_INSTALL_PREFIX}/lib/cmake/${PACKAGE_NAME}
-set(INSTALL_LIB_DIR ${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "Installation directory for CMake files")
-    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)
@@ -72,59 +60,27 @@ set(CMAKE_CXX_WARNING_OPTION ""
 set(CMAKE_VERBOSE_MAKEFILE FALSE
     CACHE STRING "Verbose compile output switch")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_WARNING_OPTION}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x ${CMAKE_CXX_WARNING_OPTION}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON")
-
-# CTEST framework
-enable_testing()
 
+#enable_testing()
 
 ## FIND PACKAGES ------------------------------------------------------------ ##
 
 set(Boost_USE_STATIC_LIBS OFF)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
-message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}")
 find_package(Boost 1.45.0 COMPONENTS program_options REQUIRED)
 include_directories(${Boost_INCLUDE_DIRS})
 
 find_package(Eigen3 CONFIG REQUIRED)
-get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+include(${EIGEN3_USE_FILE})
-include_directories(${EIGEN3_INCLUDE_DIRS})
 
 find_package(ROOT CONFIG REQUIRED)
 include(${ROOT_USE_FILE})
 
-find_package(VTK REQUIRED)
+find_package(VTK CONFIG REQUIRED)
-# include(${VTK_USE_FILE})
+include(${VTK_USE_FILE})
-
-
-
-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)
-endif()
 
 set(CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_INCLUDES math.h)
 set(CMAKE_REQUIRED_LIBRARIES CMAKE_REQUIRED_LIBRARIES m)
@@ -163,7 +119,7 @@ configure_file("${PROJECT_SOURCE_DIR}/CMakeConfig.in.h"
                "${PROJECT_BINARY_DIR}/config.h")
 
 install(FILES "${PROJECT_BINARY_DIR}/config.h"
-        DESTINATION ${INSTALL_INC_DIR})
+        DESTINATION ${PACKAGE_INSTALL_INC_DIR})
 
 ## ADD LIBRARIES SUBDIRECTORIES --------------------------------------------- ##
 
@@ -208,8 +164,8 @@ add_subdirectory(${SRC_DIR}/Vtk)
 
 
 # Create the FooBarConfig.cmake and FooBarConfigVersion files
-# file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}"
+file(RELATIVE_PATH REL_INCLUDE_DIR "${PACKAGE_INSTALL_CMAKE_DIR}"
-#    "${INSTALL_INC_DIR}")
+   "${PACKAGE_INSTALL_INC_DIR}")
 
 # ... for the build tree
 #set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}")
@@ -218,53 +174,21 @@ add_subdirectory(${SRC_DIR}/Vtk)
 
 # ... for the install tree
 set(CONF_INCLUDE_DIRS "\${ULIB_CMAKE_DIR}/${REL_INCLUDE_DIR}")
-# [ removed for the configure_config_file ]
+configure_file(uLibConfig.cmake.in
-# configure_file(uLibConfig.cmake.in
+               "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
-#                "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+               @ONLY)
-#                @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 "${INSTALL_CMAKE_DIR}"
+        DESTINATION "${PACKAGE_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 "uLibTargets"
+install(EXPORT "${PROJECT_NAME}Targets"
-        FILE "uLibTargets.cmake"
+        DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}"
-        DESTINATION "${INSTALL_CMAKE_DIR}"
         COMPONENT dev)
 

CMakeUserPresets.json

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

README.md

@@ -7,57 +7,3 @@ 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
-```

build.log

@@ -1,36 +0,0 @@
-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'

conanfile.txt

@@ -1,7 +0,0 @@
-[requires]
-eigen/3.4.0
-boost/1.83.0
-
-[generators]
-CMakeDeps
-CMakeToolchain

condaenv.yml

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

src/Core/CMakeLists.txt

@@ -18,10 +18,10 @@ target_link_libraries(${libname} ${LIBRARIES})
 
 install(TARGETS ${libname}
         EXPORT "${PROJECT_NAME}Targets"
-        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
 
-install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Core)
+install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Core)
 
 
 

src/Core/Makefile.am

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

src/Core/Object.cpp

@@ -23,126 +23,178 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+
+
+
+
 #include "config.h"
 
 #include "Object.h"
 #include "Vector.h"
 
-#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 "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"
+
+
 
 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 Slot {
+    struct Signal {
-    GenericMFPtr sloptr;
+        GenericMFPtr  sigptr;
-    std::string slostr;
+        std::string   sigstr;
-  };
+        SignalBase   *signal;
+    };
 
-  Vector<Signal> sigv;
+    struct Slot {
-  Vector<Slot> slov;
+        GenericMFPtr sloptr;
+        std::string  slostr;
+    };
+
+
+    Vector<Signal> sigv;
+    Vector<Slot>   slov;
 };
 
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // OBJECT IMPLEMENTATION
 
-Object::Object() : d(new ObjectPrivate) {}
 
-Object::Object(const Object &copy) : d(new ObjectPrivate(*copy.d)) {}
 
-Object::~Object() { delete d; }
+Object::Object() :
+    d(new ObjectPrivate)
+{}
 
-void Object::DeepCopy(const Object &copy) {
+Object::Object(const Object &copy) :
-  // should lock to be tread safe //
+    ObjectPropable(copy),
-  memcpy(d, copy.d, sizeof(ObjectPrivate));
+    d(new ObjectPrivate(*copy.d))
-  // ERROR! does not copy parameters ... <<<< FIXXXXX
+{}
+
+Object::~Object() {
+    delete d;
 }
 
-void Object::SaveXml(std::ostream &os, Object &ob) {
+void Object::DeepCopy(const Object &copy)
-  Archive::xml_oarchive ar(os);
+{
-  ar << boost::serialization::make_nvp("Object", ob);
+    // should lock to be tread safe //
+    memcpy(d,copy.d,sizeof(ObjectPrivate));
+    // ERROR! does not copy parameters ...                                      <<<< FIXXXXX
 }
 
-void Object::LoadXml(std::istream &is, Object &ob) {
+
-  Archive::xml_iarchive ar(is);
+
-  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);
+}
+
+
 // FINIRE
-void Object::SaveConfig(std::ostream &os, int version) {
+void Object::SaveConfig(std::ostream &os, int version)
-  Archive::xml_oarchive ar(os);
+{   
+    Archive::xml_oarchive ar(os);
+    ObjectPropable::serialize(ar,0);
 }
 
-void Object::LoadConfig(std::istream &is, int version) {
+void Object::LoadConfig(std::istream &is, int version)
-  Archive::xml_iarchive ar(is);
+{
+    if(!props()) this->init_properties();
+    Archive::xml_iarchive ar(is);
+    ObjectPropable::serialize(ar,0);
 }
 
-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";
+void Object::PrintSelf(std::ostream &o) const
-  }
+{
-  o << "--------------------------------------\n\n";
+    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";
 }
 
-bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
+
-                           const char *name) {
+bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name)
-  ObjectPrivate::Signal s = {fptr, std::string(name), sig};
+{
-  d->sigv.push_back(s);
+    ObjectPrivate::Signal s = {fptr,std::string(name),sig};
+    d->sigv.push_back(s);
 }
 
-bool Object::addSlotImpl(GenericMFPtr fptr, const char *name) {
+bool Object::addSlotImpl(GenericMFPtr fptr, const char *name)
-  ObjectPrivate::Slot s = {fptr, std::string(name)};
+{
-  d->slov.push_back(s);
+    ObjectPrivate::Slot s = {fptr,std::string(name)};
+    d->slov.push_back(s);
 }
 
-SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const {
+SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const
-  for (int i = 0; i < d->sigv.size(); ++i) {
+{
-    if (d->sigv[i].sigptr == fptr)
+    for(int i=0; i<d->sigv.size(); ++i)
-      return d->sigv[i].signal;
+    {
-  }
+        if(d->sigv[i].sigptr == fptr)
-  return NULL;
+            return d->sigv[i].signal;
+    }
+    return NULL;
 }
 
-SignalBase *Object::findSignalImpl(const char *name) const {
+SignalBase *Object::findSignalImpl(const char *name) const
-  std::string in(name);
+{
-  for (int i = 0; i < d->sigv.size(); ++i) {
+    std::string in(name);
-    if (d->sigv[i].sigstr == in)
+    for(int i=0; i<d->sigv.size(); ++i)
-      return d->sigv[i].signal;
+    {
-  }
+        if(d->sigv[i].sigstr == in)
-  return NULL;
+            return d->sigv[i].signal;
+    }
+    return NULL;
 }
 
-GenericMFPtr *Object::findSlotImpl(const char *name) const {
+GenericMFPtr *Object::findSlotImpl(const char *name) const
-  std::string in(name);
+{
-  for (int i = 0; i < d->slov.size(); ++i) {
+    std::string in(name);
-    if (d->slov[i].slostr == in)
+    for(int i=0; i<d->slov.size(); ++i)
-      return &d->slov[i].sloptr;
+    {
-  }
+        if(d->slov[i].slostr == in)
-  return NULL;
+            return &d->slov[i].sloptr;
+    }
+    return NULL;
 }
 
+
+
+
 // std::ostream &
 // operator << (std::ostream &os, uLib::Object &ob)
 // {
@@ -166,4 +218,10 @@ GenericMFPtr *Object::findSlotImpl(const char *name) const {
 //     return is;
 // }
 
-} // namespace uLib
+
+
+
+} // uLib
+
+
+

src/Core/Object.h

@@ -23,183 +23,200 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+
+
 #ifndef U_CORE_OBJECT_H
 #define U_CORE_OBJECT_H
 
 #include <iostream>
 
 // WARNING: COPILE ERROR if this goes after mpl/vector //
-// #include "Core/Vector.h"
+//#include "Core/Vector.h"
 
-#include "Core/Debug.h"
 #include "Core/Types.h"
+#include "Core/Debug.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;
-} // namespace archive
+} // archive
-} // namespace boost
+} // boost
+
 
 namespace uLib {
 
+
 class Version {
 public:
-  static const char *PackageName;
+    static const char *PackageName;
-  static const char *VersionNumber;
+    static const char *VersionNumber;
-  static const char *Release;
+    static const char *Release;
 };
 
+
+
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 //// OBJECT ////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
+
+
 /**
  * @brief Object class is the object base implementation for uLib Framework.
  */
-class Object {
+class Object : public ObjectPropable
+{
+
 
 public:
-  //    std::string name;
+    //    std::string name;
-  //    void PrintName() { std::cout << "Ob name: " << name << "\n"; }
+    //    void PrintName() { std::cout << "Ob name: " << name << "\n"; }
 
-  Object();
+    Object();
-  Object(const Object &copy);
+    Object(const Object &copy);
-  ~Object();
+    ~Object();
 
-  ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
-  // PARAMETERS //
+    // PARAMETERS //
 
-  // FIXX !!!
+    // FIXX !!!
-  virtual void DeepCopy(const Object &copy);
+    virtual void DeepCopy(const Object &copy);
 
-  ////////////////////////////////////////////////////////////////////////////
-  // SERIALIZATION //
 
-  template <class ArchiveT>
+    ////////////////////////////////////////////////////////////////////////////
-  void serialize(ArchiveT &ar, const unsigned int version) {}
+    // SERIALIZATION //
-  template <class ArchiveT>
-  void save_override(ArchiveT &ar, const unsigned int version) {}
 
-  void SaveConfig(std::ostream &os, int version = 0);
+    template <class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version)    {
-  void LoadConfig(std::istream &is, int version = 0);
+                ObjectPropable::serialize(ar,version);
-
-  static void SaveXml(std::ostream &os, Object &ob);
-  static void LoadXml(std::istream &is, Object &ob);
-
-  ////////////////////////////////////////////////////////////////////////////
-  // 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;
+    template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version) {}
-  }
 
-  inline SignalBase *findSignal(const char *name) const {
+    void SaveConfig(std::ostream &os, int version = 0);
-    return findSignalImpl(name);
+    void LoadConfig(std::istream &is, int version = 0);
-  }
 
-  inline GenericMFPtr *findSlot(const char *name) const {
+    static void SaveXml(std::ostream &os, Object &ob);
-    return findSlotImpl(name);
+    static void LoadXml(std::istream &is, Object &ob);
-  }
 
-  void PrintSelf(std::ostream &o) const;
 
-  inline const Object &operator=(const Object &copy) {
+
-    this->DeepCopy(copy);
+    ////////////////////////////////////////////////////////////////////////////
-    return *this;
+    // 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; }
+
 
 private:
-  bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
+    bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
-  bool addSlotImpl(GenericMFPtr fptr, const char *name);
+    bool addSlotImpl(GenericMFPtr fptr, const char *name);
-  SignalBase *findSignalImpl(const GenericMFPtr &fptr) const;
+    SignalBase   *findSignalImpl(const GenericMFPtr &fptr) const;
-  SignalBase *findSignalImpl(const char *name) const;
+    SignalBase   *findSignalImpl(const char *name) const;
-  GenericMFPtr *findSlotImpl(const char *name) const;
+    GenericMFPtr *findSlotImpl(const char *name) const;
 
-  friend class boost::serialization::access;
+    friend class boost::serialization::access;
-  friend class ObjectPrivate;
+    friend class ObjectPrivate;
-  class ObjectPrivate *d;
+    class ObjectPrivate *d;
 };
 
-} // namespace uLib
+
+
+} // uLib
 
 ////////////////////////////////////////////////////////////////////////////////
 
-// std::ostream & operator << (std::ostream &os, uLib::Object &ob);
+//std::ostream & operator << (std::ostream &os, 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);
+//std::istream & operator >> (std::istream &is, uLib::Object &ob);
+
 
 #endif // U_OBJECT_H

src/Core/ObjectProps.h

@@ -0,0 +1,278 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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/Options.cpp

@@ -31,9 +31,6 @@
 
 #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>();
@@ -77,23 +74,6 @@ 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,8 +160,6 @@ 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/Serializable.h

@@ -23,6 +23,8 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+
+
 #ifndef U_SERIALIZABLE_H
 #define U_SERIALIZABLE_H
 
@@ -36,6 +38,9 @@ TODO:
 
 */
 
+
+
+
 #include <boost/serialization/access.hpp>
 #include <boost/serialization/export.hpp>
 
@@ -43,22 +48,26 @@ TODO:
 #include <boost/mpl/remove_if.hpp>
 #include <boost/serialization/nvp.hpp>
 
-// #include <boost/archive/xml_iarchive.hpp>
+//#include <boost/archive/xml_iarchive.hpp>
-// #include <boost/archive/xml_oarchive.hpp>
+//#include <boost/archive/xml_oarchive.hpp>
-// #include <boost/archive/text_iarchive.hpp>
+//#include <boost/archive/text_iarchive.hpp>
-// #include <boost/archive/text_oarchive.hpp>
+//#include <boost/archive/text_oarchive.hpp>
-// #include "boost/archive/polymorphic_iarchive.hpp"
+//#include "boost/archive/polymorphic_iarchive.hpp"
-// #include "boost/archive/polymorphic_oarchive.hpp"
+//#include "boost/archive/polymorphic_oarchive.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/inc.hpp>
+#include <boost/preprocessor/cat.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"
+
+
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -71,47 +80,63 @@ namespace serialization {
 // ACCESS 2 //
 template <class T> struct access2 {};
 
+
 // NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------
-template <class T> class hrp : public wrapper_traits<const hrp<T>> {
+template<class T>
-  const char *m_name;
+class hrp :
-  T *m_value;
+        public wrapper_traits<const hrp< T > >
-  std::string *m_str;
+{
+    const char *m_name;
+    T *m_value;
+    std::string *m_str;
 
 public:
-  explicit hrp(const char *name_, T &t)
+    explicit hrp(const char * name_, T &t) :
-      : m_str(new std::string), m_name(name_), m_value(&t) {}
+        m_str(new std::string),
+        m_name(name_), m_value(&t) {}
 
-  const char *name() const { return this->m_name; }
+    const char * name() const {
+        return this->m_name;
+    }
 
-  template <class Archivex>
+
-  void save(Archivex &ar, const unsigned int /* file_version */) const {
+    template<class Archivex>
-    ////        ar.operator<<(const_value());
+    void save( Archivex & ar, const unsigned int /* file_version */) const {
-    //        std::stringstream ss;
+        ////        ar.operator<<(const_value());
-    //        uLib::Archive::hrt_oarchive har(ss);
+        //        std::stringstream ss;
-    //        har << make_nvp(m_name,*m_value);
+        //        uLib::Archive::hrt_oarchive har(ss);
-    //        //        (*m_str) = ss.str();
+        //        har << make_nvp(m_name,*m_value);
-    ////        ar.operator << (make_nvp(m_name, ss.str());
+        //        //        (*m_str) = ss.str();
-  }
+        ////        ar.operator << (make_nvp(m_name, ss.str());
-  template <class Archivex>
+    }
-  void load(Archivex &ar, const unsigned int /* file_version */) {
+    template<class Archivex>
-    //        ar.operator>>(value());
+    void load( Archivex & ar, const unsigned int /* file_version */) {
-  }
+//        ar.operator>>(value());
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
+    }
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
 };
 
-template <class T>
+
+template<class T>
 inline
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-    const
+const
 #endif
-    hrp<T> make_hrp(const char *name, T &t) {
+hrp< T > make_hrp(const char * name, T & t){
-  return hrp<T>(name, t);
+    return hrp< T >(name, t);
 }
 
-#define HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
+#define HRP(name) \
+    boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
+
+
+} // serialization
+} // boost
+
+
+
+
 
-} // namespace serialization
-} // namespace boost
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -126,7 +151,9 @@ inline
 
 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)
 
@@ -139,53 +166,51 @@ 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_SERIALIZABLE_OBJECT        _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT
-#define ULIB_SERIALIZE_OBJECT(_Ob, ...)                                        \
+#  define ULIB_SERIALIZE_OBJECT(_Ob,...)  _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__)
-  _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
+#  define _AR_(_name)                     _ULIB_DETAIL_INTRUSIVE_AR_(_name)
-#define _AR_(_name) _ULIB_DETAIL_INTRUSIVE_AR_(_name)
 #else
-#define ULIB_SERIALIZABLE(_Ob)                                                 \
+#  define ULIB_SERIALIZABLE(_Ob)           _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \
-  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob)                                   \
+                                            ULIB_CLASS_EXPORT_KEY(_Ob)
-  ULIB_CLASS_EXPORT_KEY(_Ob)
+#  define ULIB_SERIALIZE(_Ob,...)          _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_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_SERIALIZE_DERIVED(_Ob, ...)                                       \
+#  define ULIB_SERIALIZABLE_OBJECT(_Ob)    _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \
-  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob, __VA_ARGS__)
+                                            ULIB_CLASS_EXPORT_OBJECT_KEY(_Ob)
-#define ULIB_SERIALIZABLE_OBJECT(_Ob)                                          \
+#  define ULIB_SERIALIZE_OBJECT(_Ob,...)   _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__)
-  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob)                            \
+#  define ULIB_SERIALIZE_OBJECT_PROPS(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob)
-  ULIB_CLASS_EXPORT_OBJECT_KEY(_Ob)
+#  define AR(_name)                        _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
-#define ULIB_SERIALIZE_OBJECT(_Ob, ...)                                        \
+#  define HR(_name)                        _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
-  _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_CLASS_EXPORT_KEY(_FullNamespaceClass)                             \
+#define ULIB_SERIALIZE_ACCESS                                        \
-  BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)
+    friend class boost::serialization::access;                       \
+    template <class T> friend class boost::serialization::access2;
 
-#define ULIB_CLASS_EXPORT_OBJECT_KEY(_FullNamespaceClass)                      \
+#define ULIB_CLASS_EXPORT_KEY(_FullNamespaceClass)                   \
-  BOOST_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 _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)               \
+#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base,_Derived)    namespace boost{ template<> struct is_virtual_base_of<_Base,_Derived>: public boost::mpl::true_ {}; }
-  namespace boost {                                                            \
+#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP(r,data,elem) _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem,data)
-  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)
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -195,57 +220,38 @@ 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)                  \
+#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(Class,Archive) \
-  template void Class::serialize(Archive &ar, const unsigned int);
+    template void Class::serialize(Archive &ar,const unsigned int);
 
-#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP(r, data, elem)                \
+#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP(r,data,elem) _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(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_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)
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -255,171 +261,152 @@ namespace uLib {
 ////////////////////////////////////////////////////////////////////////////////
 // UNINTRUSIVE SERIALIZATION
 
-#define _UNAR_OP(r, data, elem)                                                \
+#define _UNAR_OP(r,data,elem) ar&boost::serialization::make_nvp(BOOST_PP_STRINGIZE(elem),boost::serialization::base_object<elem>(ob));
-  ar &boost::serialization::make_nvp(                                          \
-      BOOST_PP_STRINGIZE(elem), boost::serialization::base_object<elem>(ob));
 
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(Class, Archive)                \
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(Class,Archive) \
-  template void boost::serialization::serialize(Archive &ar, Class &ob,        \
+    template void boost::serialization::serialize(Archive &ar, Class &ob, const unsigned int i);
-                                                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_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)                             \
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \
-  namespace boost {                                                            \
+    namespace boost { namespace serialization { \
-  namespace serialization {                                                    \
+    template <class ArchiveT> void serialize         (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-  template <class ArchiveT>                                                    \
+    template <class ArchiveT> void serialize_parents (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-  void serialize(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_parents(ArchiveT &ar, _Ob &ob, const unsigned int version);   \
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob) \
-  template <> struct access2<_Ob> {                                            \
+    namespace boost { namespace serialization { \
-    template <class ArchiveT>                                                  \
+    template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {} \
-    static void save_override(ArchiveT &ar, _Ob &ob,                           \
+    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
-                              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_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.
+     * Serializable trait to check if an object type is serializable.
-   * This only works if UNINTRUSIVE SERIALIZATION is applyed; in intrusive
+     * This only works if UNINTRUSIVE SERIALIZATION is applyed; in intrusive
-   * cases a has_serialize trait should be implemented
+     * cases a has_serialize trait should be implemented
-   */
+     */
-  template <class T> struct serializable_trait : mpl::bool_<false> {};
+    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));
+        }
+    };
 
-  /**
-   * 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));
-    }
-  };
 };
 
-} // namespace detail
+
+} // detail
+
+
+
+
 
 struct Serializable {
-  friend class boost::serialization::access;
+    friend class boost::serialization::access;
-  template <class T> friend class boost::serialization::access2;
+    template <class T> friend class boost::serialization::access2;
-  virtual ~Serializable() {}
+    virtual ~Serializable() {}
-
 protected:
 };
 
-} // namespace uLib
+
+
+
+
+} // uLib
+
+
+
+
+
 
 #endif // U_SERIALIZABLE_H

src/Core/Types.h

@@ -23,6 +23,8 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+
+
 #ifndef U_CORE_TYPES_H
 #define U_CORE_TYPES_H
 
@@ -31,182 +33,253 @@
 
 #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 IMPL  //
-  BOOST_MPL_HAS_XXX_TRAIT_DEF(type_info)
+    BOOST_MPL_HAS_XXX_TRAIT_DEF(type_info)
 
-  // SFINAE IMPL //
+    // SFINAE IMPL //
-  /*
+    /*
-  template <typename T>
+    template <typename T>
-  struct has_type_info {
+    struct has_type_info {
-      typedef char yes[1];
+        typedef char yes[1];
-      typedef char no[2];
+        typedef char no[2];
-      template <typename U> static yes& test(typename U::type_info::BaseList*);
+        template <typename U> static yes& test(typename U::type_info::BaseList*);
-      template <typename   > static no&  test(...);
+        template <typename   > static no&  test(...);
-      //        struct apply {
+        //        struct apply {
-      static const bool value = sizeof(test<T>(0)) == sizeof(yes);
+        static const bool value = sizeof(test<T>(0)) == sizeof(yes);
-      typedef boost::mpl::bool_<value> type;
+        typedef boost::mpl::bool_<value> type;
-      //        };
+        //        };
-  };
+    };
-  */
+    */
 
-  /** IsA Introspectable Object Implementation Template */
+    /** IsA Introspectable Object Implementation Template */
-  template <class T> struct IsIntrospectable : has_type_info<T> {};
+    template <class T>
+    struct IsIntrospectable : has_type_info<T> {};
 
-  template <typename T> struct access {
+    template <typename T> struct access {
-    typedef typename T::type_info type_info;
+        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 <class T1> struct lambda_CFList_f<T1, true> {
+    template <typename T>
-      //            typedef typename T1::type_info::CFList type;
+    struct child_first_impl {
-      typedef typename access<T1>::type_info::CFList type;
+
+        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 : lambda_CFList_f<T1, has_type_info<T1>::value> {};
 
-    /** Transforms all Base Type into proper CFList */
+    /**
-    typedef
+     * Tests if T has a member called type_info then compile type CFList
-        typename mpl::transform_view<typename access<T>::type_info::BaseList,
+     */
-                                     lambda_CFList<mpl::_>>::type CFListSeq;
+    template <typename T>
+    struct child_first : mpl::if_< has_type_info<T>
+                                 , child_first_impl<T>
+                                 , mpl::vector<>
+                                 >::type {};
 
-    /** 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)
+//#define _REPETITION_V(vz,vn,vdata)
+
+
+//template < class TypeList >
+//class TypeAdapterInputInterface {
+//    virtual ~TypeAdapterInputInterface() {}
+//public:
+
 
-// template < class TypeList >
-// class TypeAdapterInputInterface {
-//     virtual ~TypeAdapterInputInterface() {}
-// public:
 
 //    virtual void operator()(int val)         {}
 //    virtual void operator()(std::string val) {}
 //};
 
-} // namespace detail
+
+
+
+
+
+
+} // 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 ltk::Id_t        Id_t;
-typedef id_t Id_t;
+typedef id_t       Id_t;
 ////typedef ltk::Size_t      Size_t;
-// typedef ltk::Pointer_t   Pointer_t;
+//typedef ltk::Pointer_t   Pointer_t;
-typedef void *Pointer_t;
+typedef void *     Pointer_t;
-typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
+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 */                          \
+#define uLibTypeMacro(thisClass,...) \
-  template <typename> friend class uLib::detail::TypeIntrospection::access;    \
+    \
-                                                                               \
+    /* Friendship detail for accessing introspection */ \
-/* type info structure*/ public:                                               \
+    template <typename> friend class uLib::detail::TypeIntrospection::access;       \
-  /* in GCC 4.8 must be public or dynamic_cast wont work */                    \
+    \
-  struct type_info {                                                           \
+    /* type info structure*/ public: \
-    /*WARNING: -std=c++0x required for this! */                                \
+    /* in GCC 4.8 must be public or dynamic_cast wont work */ \
-    constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass);         \
+    struct type_info { \
-    typedef BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) BaseClass;                  \
+      /*WARNING: -std=c++0x required for this! */ \
-    typedef thisClass ThisClass;                                               \
+      constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass);            \
-    typedef uLib::mpl::vector<__VA_ARGS__, thisClass> TypeList;                \
+      typedef BOOST_PP_VARIADIC_ELEM(0,__VA_ARGS__) BaseClass;                      \
-    typedef uLib::mpl::vector<__VA_ARGS__> BaseList;                           \
+      typedef thisClass ThisClass;                                                  \
-    typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type      \
+      typedef uLib::mpl::vector<__VA_ARGS__,thisClass> TypeList;                    \
-        CFList;                                                                \
+      typedef uLib::mpl::vector<__VA_ARGS__>           BaseList;                    \
-  };                                                                           \
+      typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type CFList; \
-                                                                               \
+    }; \
-public:                                                                        \
+    \
-  typedef type_info::BaseClass BaseClass;                                      \
+    public: \
-  virtual const char *type_name() const { return type_info::name; }            \
+    typedef type_info::BaseClass BaseClass; \
-  /**/
+    virtual const char *type_name() const { return type_info::name; } \
+    /* Object Props fwd declaration*/ \
+    struct ObjectProps; \
+    /**/
+
 
 /**
  * TypeList inheritance introspection
  */
 struct TypeIntrospection {
-  template <typename T>
+    template <typename T>
-  struct child_first : detail::TypeIntrospection::child_first<T> {};
+    struct child_first : detail::TypeIntrospection::child_first<T> {};
+
 };
 
+
+
+
+
+
 // SISTEMARE //
 struct PrintTypeId {
-  template <class T> void operator()(T) const {
+    template <class T>
-    std::cout << typeid(T).name() << std::endl;
+    void operator()(T) const
-  }
+    { std::cout << typeid(T).name() << std::endl; }
 
-  template <typename SeqT> static void PrintMplSeq(SeqT *p = NULL) {
+    template <typename SeqT>
-    boost::mpl::for_each<SeqT>(PrintTypeId());
+    static void PrintMplSeq(SeqT *p = NULL) { boost::mpl::for_each<SeqT>(PrintTypeId()); }
-  }
 
-  template <typename Class> static void PrintType(Class *p = NULL) {
+    template <typename Class>
-    std::cout << typeid(Class).name() << std::endl;
+    static void PrintType(Class *p = NULL) { std::cout << typeid(Class).name() << std::endl; }
-  }
 };
 
-} // namespace uLib
+
+
+
+
+
+
+} // uLib
 
 #endif // U_CORE_TYPES_H
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/Core/testing/CMakeLists.txt

@@ -16,6 +16,7 @@ set( TESTS
         SerializeTest
         SerializeDreadDiamondTest
         DreadDiamondParameters
+        ObjectPropableTest
         UuidTest
         TypeIntrospectionTraversal
         OptionsTest

src/Core/testing/Makefile.am

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

src/Core/testing/ObjectPropableTest.cpp

@@ -0,0 +1,237 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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/Detectors/CMakeLists.txt

@@ -2,6 +2,5 @@ set(HEADERS MuonScatter.h MuonError.h MuonEvent.h)
 
 set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
 
-
 install(FILES ${HEADERS}
-        DESTINATION ${INSTALL_INC_DIR}/Detectors)
+        DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Detectors)

src/Math/BitCode.h

@@ -27,8 +27,6 @@
 #ifndef U_MATH_BITCODE_H
 #define U_MATH_BITCODE_H
 
-#include <iostream>
-
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/mpl/vector_c.hpp>
@@ -36,7 +34,6 @@
 
 #include <Math/Dense.h>
 
-
 namespace uLib {
 
 

src/Math/CMakeLists.txt

@@ -1,4 +1,3 @@
-
 set(HEADERS ContainerBox.h
             Dense.h
             Geometry.h
@@ -32,9 +31,8 @@ set(SOURCES VoxRaytracer.cpp
             Structured2DGrid.cpp
             Structured4DGrid.cpp)
 
-set(LIBRARIES Eigen3::Eigen
+set(LIBRARIES ${Eigen_LIBRARY}
-              ${ROOT_LIBRARIES}
+              ${ROOT_LIBRARIES})
-              ${VTK_LIBRARIES})
 
 set(libname ${PACKAGE_LIBPREFIX}Math)
 set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
@@ -46,15 +44,10 @@ set_target_properties(${libname} PROPERTIES
                       SOVERSION ${PROJECT_SOVERSION})
 target_link_libraries(${libname} ${LIBRARIES})
 
-
 install(TARGETS ${libname}
         EXPORT "${PROJECT_NAME}Targets"
-        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
 
-install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Math)
+install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Math)
-
-# TESTING
-# include(uLibTargetMacros)
-# add_subdirectory(testing)
 

src/Math/Dense.h

@@ -23,6 +23,9 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+
+
+
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright (C) 2012  Andrea Rigoni Garola <andrea@pcimg05>
@@ -44,6 +47,7 @@
  *
  */
 
+
 #ifndef ULIB_DENSEMATRIX_H
 #define ULIB_DENSEMATRIX_H
 
@@ -51,29 +55,27 @@
 
 #include <Eigen/Dense>
 
+
 //// BOOST SERIALIZATION ///////////////////////////////////////////////////////
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/lexical_cast.hpp>
-#include <boost/serialization/array.hpp>
 #include <boost/serialization/string.hpp>
+#include <boost/serialization/array.hpp>
+
 
 namespace boost {
 namespace serialization {
 
-template <class Archive, class Scalar, int RowsAtCompileTime,
+template<class Archive, class Scalar, int RowsAtCompileTime, int ColsAtCompileTime>
-          int ColsAtCompileTime>
+void serialize(Archive & ar, ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> & m, const unsigned int /*version*/) {
-void serialize(Archive &ar,
+    ar & boost::serialization::make_array(m.data(), RowsAtCompileTime * ColsAtCompileTime);
-               ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> &m,
-               const unsigned int /*version*/) {
-  ar &boost::serialization::make_array(m.data(),
-                                       RowsAtCompileTime * ColsAtCompileTime);
 }
 
-} // namespace serialization
+} //  serialization
-} // namespace boost
+} //  boost
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -82,163 +84,178 @@ void serialize(Archive &ar,
 // this is needed by boost::lexical_cast to cope with Eigens Vectors ///////////
 namespace Eigen {
 template <typename T, int size>
-std::istream &operator>>(std::istream &is, Eigen::Matrix<T, size, 1> &vec) {
+std::istream & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) {
-  std::string str;
+    std::string str;
-  for (unsigned int i = 0; i < size; i++) {
+    for( unsigned int i=0; i<size; i++) {
-    is >> std::skipws;
+        is >> std::skipws;
-    is >> str;
+        is >> str;
-    if (is.fail())
+        if(is.fail()) vec(i) = 0;
-      vec(i) = 0;
+        else vec(i) = boost::lexical_cast<T>(str);
-    else
+    }
-      vec(i) = boost::lexical_cast<T>(str);
+    return is;
-  }
-  return is;
 }
 template <typename T, int size>
-std::ostream &operator<<(std::ostream &os,
+std::ostream & operator << (std::ostream &os, const Eigen::Matrix<T,size,1> &vec) {
-                         const Eigen::Matrix<T, size, 1> &vec) {
+    os << vec.transpose();
-  os << vec.transpose();
+    return os;
-  return os;
 }
-} // namespace Eigen
+} // Eigen
 ////////////////////////////////////////////////////////////////////////////////
 
+
+
 namespace uLib {
 
-typedef id_t Id_t;
+typedef id_t          Id_t;
 
-typedef int Scalari;
+typedef int           Scalari;
-typedef unsigned int Scalarui;
+typedef unsigned int  Scalarui;
-typedef long Scalarl;
+typedef long          Scalarl;
 typedef unsigned long Scalarul;
-typedef float Scalarf;
+typedef float         Scalarf;
-typedef double Scalard;
+typedef double        Scalard;
 
-typedef Eigen::Matrix<int, 1, 1> Matrix1i;
+
+
+typedef Eigen::Matrix<int,1,1> Matrix1i;
 typedef Eigen::Matrix2i Matrix2i;
 typedef Eigen::Matrix3i Matrix3i;
 typedef Eigen::Matrix4i Matrix4i;
 
-typedef Eigen::Matrix<float, 1, 1> Matrix1f;
+typedef Eigen::Matrix<float,1,1> Matrix1f;
 typedef Eigen::Matrix2f Matrix2f;
 typedef Eigen::Matrix3f Matrix3f;
 typedef Eigen::Matrix4f Matrix4f;
 
-typedef Eigen::Matrix<int, 1, 1> Vector1i;
+typedef Eigen::Matrix<int,1,1> Vector1i;
 typedef Eigen::Vector2i Vector2i;
 typedef Eigen::Vector3i Vector3i;
 typedef Eigen::Vector4i Vector4i;
 
-typedef Eigen::Matrix<float, 1, 1> Vector1f;
+typedef Eigen::Matrix<float,1,1> Vector1f;
 typedef Eigen::Vector2f Vector2f;
 typedef Eigen::Vector3f Vector3f;
 typedef Eigen::Vector4f Vector4f;
 
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // Vector String interaction ///////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 /*! Given a string consisting of a series of doubles with some
- *  delimiter, return an Eigen::Vector populated with those
+*  delimiter, return an Eigen::Vector populated with those
- *  values, in the same order as they are given in the string.
+*  values, in the same order as they are given in the string.
- *
+*
- *  \param vec A double vector to be populated with the results
+*  \param vec A double vector to be populated with the results
- *  \param str A string to be parsed as a series of doubles.
+*  \param str A string to be parsed as a series of doubles.
- *  \param delim Delimiters of the text (a typical default is " ," for comma and
+*  \param delim Delimiters of the text (a typical default is " ," for comma and space-delimited text
- * space-delimited text
+*
- *
+*/
- */
 template <typename T, int size>
-void VectorxT_StringTo(Eigen::Matrix<T, size, 1> &vec, std::string str,
+void VectorxT_StringTo(Eigen::Matrix<T,size,1> &vec, std::string str, const char *delim = " ,;\t\n") {
-                       const char *delim = " ,;\t\n") {
+    std::vector<std::string> strvec;
-  std::vector<std::string> strvec;
 
-  boost::algorithm::trim_if(str, boost::algorithm::is_any_of(delim));
+    boost::algorithm::trim_if( str, boost::algorithm::is_any_of(delim));
-  boost::algorithm::split(strvec, str, boost::algorithm::is_any_of(delim),
+    boost::algorithm::split(strvec,str,boost::algorithm::is_any_of(delim), boost::algorithm::token_compress_on);
-                          boost::algorithm::token_compress_on);
 
-  for (unsigned int i = 0; i < size; i++) {
+    for( unsigned int i=0; i<size; i++) {
-    vec(i) = boost::lexical_cast<T>(strvec[i]);
+        vec(i) = boost::lexical_cast<T>(strvec[i]);
-  }
+    }
 }
 
 template <typename T, int size>
-std::string VectorxT_ToString(const Eigen::Matrix<T, size, 1> &vec) {
+std::string VectorxT_ToString(const Eigen::Matrix<T,size,1> &vec) {
-  std::stringstream sst;
+    std::stringstream sst;
-  sst << vec.transpose();
+    sst << vec.transpose();
-  return sst.str();
+    return sst.str();
 }
 
-// template <typename T, int size>
+
-// Eigen::Matrix<T,size,1> & operator >> (std::istream &is,
+//template <typename T, int size>
-// Eigen::Matrix<T,size,1> &vec) {
+//Eigen::Matrix<T,size,1> & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) {
-// }
+//}
 
 template <typename T, int size>
-void operator>>(std::string &str, Eigen::Matrix<T, size, 1> &vec) {
+void operator>> (std::string& str, Eigen::Matrix<T,size,1> &vec){
-  VectorxT_StringTo(vec, str);
+    VectorxT_StringTo(vec,str);
 }
 
+
 ////////////////////////////////////////////////////////////////////////////////
 //////   HOMOGENEOUS VECTORS  //////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-template <bool p> class _HPoint3f : public Eigen::Matrix<Scalarf, 4, 1> {
+template <bool p>
+class _HPoint3f : public Eigen::Matrix< Scalarf,4,1 > {
 public:
-  typedef Eigen::Matrix<Scalarf, 4, 1> BaseClass;
+    typedef Eigen::Matrix< Scalarf,4,1 > BaseClass;
 
-  _HPoint3f() : BaseClass(0, 0, 0, p) {}
+    _HPoint3f<p>() : BaseClass(0,0,0,p) {}
-  _HPoint3f(float x, float y, float z) : BaseClass(x, y, z, p) {}
+    _HPoint3f<p>(float x,float y,float z) : BaseClass(x,y,z,p) {}
-  _HPoint3f(Vector3f &in) : BaseClass(in.homogeneous()) {
+    _HPoint3f<p>(Vector3f &in) : BaseClass(in.homogeneous()) { this->operator()(3) = p; }
-    this->operator()(3) = p;
-  }
 
-  void operator delete(void *_p, size_t _s) {}
+    void operator delete(void* _p, size_t _s) {}
 
-  // This constructor allows to construct MyVectorType from Eigen expressions
+    // This constructor allows to construct MyVectorType from Eigen expressions
-  template <typename OtherDerived>
+    template<typename OtherDerived>
-  inline _HPoint3f(const Eigen::MatrixBase<OtherDerived> &other)
+    inline _HPoint3f<p>(const Eigen::MatrixBase<OtherDerived>& other)
-      : BaseClass(other) {}
+        : BaseClass(other)
+    { }
+
+    // This method allows to assign Eigen expressions to Vector3H
+    template<typename OtherDerived>
+    inline _HPoint3f<p> & operator= (const Eigen::MatrixBase <OtherDerived>& other)
+    {
+        this->BaseClass::operator=(other);
+        return *this;
+    }
 
-  // This method allows to assign Eigen expressions to Vector3H
-  template <typename OtherDerived>
-  inline _HPoint3f &operator=(const Eigen::MatrixBase<OtherDerived> &other) {
-    this->BaseClass::operator=(other);
-    return *this;
-  }
 };
 typedef _HPoint3f<false> HVector3f;
 typedef _HPoint3f<true> HPoint3f;
 
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 //////   HOMOGENEOUS LINE     //////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-struct _HLine3f {
+
-  HPoint3f origin;
+struct _HLine3f
-  HVector3f direction;
+{
+    HPoint3f origin;
+    HVector3f direction;
 };
 typedef struct _HLine3f HLine3f;
 
-inline std::ostream &operator<<(std::ostream &stream, const HLine3f &line) {
+inline std::ostream&
-  stream << "HLine3f(" << "pt[" << line.origin.transpose() << "] , dr["
+operator<< (std::ostream& stream, const HLine3f &line) {
-         << line.direction.transpose() << "]) ";
+    stream << "HLine3f(" << "pt[" << line.origin.transpose() <<"] , dr[" << line.direction.transpose() << "]) ";
-  return stream;
+    return stream;
 }
 
-struct _HError3f {
+
-  HVector3f position_error;
+
-  HVector3f direction_error;
+
+struct _HError3f
+{
+    HVector3f position_error;
+    HVector3f direction_error;
 };
 typedef struct _HError3f HError3f;
 
-inline std::ostream &operator<<(std::ostream &stream, const HError3f &err) {
+inline std::ostream&
-  stream << "HError3f(" << "ept[" << err.position_error.transpose()
+operator<< (std::ostream& stream, const HError3f &err) {
-         << "] , edr[" << err.direction_error.transpose() << "]) ";
+    stream << "HError3f(" << "ept[" << err.position_error.transpose() <<"] , edr[" << err.direction_error.transpose() << "]) ";
-  return stream;
+    return stream;
+}
+
+
 }
 
-} // namespace uLib
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -252,9 +269,13 @@ ULIB_SERIALIZABLE(uLib::HPoint3f)
 
 ULIB_SERIALIZABLE(uLib::HVector3f)
 
+
 ULIB_SERIALIZABLE(uLib::HLine3f)
 
 ULIB_SERIALIZABLE(uLib::HError3f)
 #endif // ULIB_SERIALIZATION_ON
 
-#endif // U_DENSEMATRIX_H
+
+
+
+#endif  // U_DENSEMATRIX_H

src/Math/Transform.h

@@ -110,17 +110,6 @@ public:
 
     inline void Rotate(const Matrix3f &m) { this->m_T.rotate(m); }
 
-    inline void Rotate(const float angle, Vector3f axis)
-    {
-        axis.normalize(); // prehaps not necessary ( see eigens )
-        Eigen::AngleAxisf ax(angle,axis);
-        this->m_T.rotate(Eigen::Quaternion<float>(ax));
-    }
-
-    inline void Rotate(const Vector3f euler_axis) {
-        float angle = euler_axis.norm();
-        Rotate(angle,euler_axis);
-    }
 
     inline void PreRotate(const Matrix3f &m) { this->m_T.prerotate(m); }
 

src/Math/VoxImage.cpp

@@ -30,13 +30,6 @@
 
 #include "VoxImage.h"
 
-#include <vtkSmartPointer.h>
-#include <vtkImageData.h>
-#include <vtkXMLImageDataReader.h>
-#include <vtkXMLImageDataWriter.h>
-#include <vtkStringArray.h>
-#include <vtkInformation.h>
-#include <vtkInformationStringKey.h>
 
 namespace uLib {
 
@@ -90,103 +83,7 @@ void Abstract::VoxImage::ExportToVtk (const char *file, bool density_type)
     printf("%s vtk file saved\n",file);
 }
 
-
+int Abstract::VoxImage::ImportFromVtk(const char *file)
-
-void Abstract::VoxImage::ExportToVti (const char *file, bool density_type, bool compressed)
-{
-    Abstract::VoxImage *voxels = this;
-
-    vtkSmartPointer<vtkImageData> image = vtkSmartPointer<vtkImageData>::New();
-    image->SetDimensions(voxels->GetDims()(0), voxels->GetDims()(1), voxels->GetDims()(2));
-    image->SetSpacing(voxels->GetSpacing()(0), voxels->GetSpacing()(1), voxels->GetSpacing()(2));
-    image->SetOrigin(voxels->GetPosition()(0), voxels->GetPosition()(1), voxels->GetPosition()(2));
-    image->AllocateScalars(VTK_FLOAT, 1);
-
-    float norm;
-    if (density_type) {
-        norm = 1;
-    } else norm = 1.E6;
-
-    int nx = voxels->GetDims()(0);
-    int ny = voxels->GetDims()(1);
-    int nz = voxels->GetDims()(2);
-
-    size_t npoints = nx*ny*nz;
-    float *scalar = static_cast<float*>(image->GetScalarPointer());
-
-    StructuredData unwrap(*voxels);
-    unwrap.SetDataOrder(StructuredData::XYZ); // move to XYZ order (VTK)
-    for (size_t i = 0; i < npoints; i++) {
-        Vector3i idx = unwrap.UnMap(i);
-        scalar[i] = static_cast<float>(voxels->GetValue(idx) * norm);
-    }
-
-    // Create a custom string key
-    static vtkInformationStringKey* ConfigNote =
-        vtkInformationStringKey::MakeKey("cmt.config", "Config");
-
-    // Attach metadata
-    vtkInformation *info = image->GetInformation();
-    info->Set(ConfigNote, 
-
-    "This image was generated with uLib\n"
-    "-----------------------------------\n"
-    "Author: Andrea Rigoni\n"
-    "Version: 0.1\n"
-    "Date: 2025\n"
-
-    );
-
-    // std::cout << info->Get(ConfigNote) << std::endl;
-    vtkSmartPointer<vtkXMLImageDataWriter> writer = vtkSmartPointer<vtkXMLImageDataWriter>::New();
-    writer->SetFileName(file);
-    writer->SetInputData(image);
-    if(compressed) {
-        writer->SetDataModeToBinary();
-        writer->SetCompressorTypeToZLib();
-    }
-    writer->Write();
-}
-
-
-int Abstract::VoxImage::ImportFromVti(const char *file, bool density_type) {
-    
-    vtkSmartPointer<vtkXMLImageDataReader> reader = vtkSmartPointer<vtkXMLImageDataReader>::New();
-    reader->SetFileName(file);
-    reader->Update();
-    vtkImageData *image = reader->GetOutput();
-    if(!image) return false;
-    
-    Abstract::VoxImage *voxels = this;
-    int nx = image->GetDimensions()[0];
-    int ny = image->GetDimensions()[1];
-    int nz = image->GetDimensions()[2];
-    
-    voxels->SetDims(Vector3i(nx,ny,nz));
-    voxels->SetSpacing(Vector3f(image->GetSpacing()[0],image->GetSpacing()[1],image->GetSpacing()[2]));
-    voxels->SetPosition(Vector3f(image->GetOrigin()[0],image->GetOrigin()[1],image->GetOrigin()[2]));
-
-    float norm;
-    if (density_type) {
-        norm = 1;
-    } else norm = 1.E6;
-
-    size_t npoints = nx*ny*nz;
-    float *scalar = static_cast<float*>(image->GetScalarPointer());
-
-    StructuredData wrap(*voxels);
-    wrap.SetDataOrder(StructuredData::XYZ);
-    for (size_t i = 0; i < npoints; i++) {
-        Vector3i idx = wrap.UnMap(i);
-        voxels->SetValue(idx, scalar[i] / norm);
-    }
-
-    return true;
-}
-
-
-
-int Abstract::VoxImage::ImportFromVtk(const char *file, bool density_type)
 {
     FILE * vtk_file = fopen(file, "r");
     if (!vtk_file) return false;
@@ -218,18 +115,14 @@ int Abstract::VoxImage::ImportFromVtk(const char *file, bool density_type)
     this->SetSpacing(Vector3f(sx,sy,sz));
     this->SetPosition(Vector3f(ox,oy,oz));
 
-    float norm;
-    if (density_type) {
-        norm = 1;
-    } else norm = 1.E6;
-
     for (int k = 0; k < dz; ++k) {
         for (int j = 0; j < dy; ++j) {
             for (int i = 0; i < dx; ++i) {
                 Vector3i idx(i, j, k);
                 float tmp_val;
                 fscanf(vtk_file, "%f", &tmp_val);
-                this->SetValue(idx,tmp_val / norm);
+                //this->SetValue(idx,fabs(tmp_val)*1E-6);
+                this->SetValue(idx,tmp_val*1E-6);
             }
         }
     }

src/Math/VoxImage.h

@@ -56,18 +56,8 @@ public:
     virtual void SetDims(const Vector3i &size) = 0;
 
     void ExportToVtk(const char *file, bool density_type = 0);
-
-    // use this function to export to VTK binary format
-    void ExportToVti (const char *file, bool density_type = 0, bool compressed = 0);
-    
-    // this function has been deprecated in favor of ExportToVti
-    // but it is kept for backward compatibility and because it 
-    // does not depend on vtk library
     void ExportToVtkXml(const char *file, bool density_type = 0);
-
+    int ImportFromVtk(const char *file);
-    int ImportFromVtk(const char *file, bool density_type = 0);
-
-    int ImportFromVti(const char *file, bool density_type = 0);
 
 protected:
 

src/Math/VoxRaytracer.cpp

@@ -23,12 +23,12 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+
 #include <iostream>
+#include <unordered_map>
 
-#include "Utils.h"
 #include "VoxRaytracer.h"
-
+#include "Utils.h"
-#define unlikely(expr) __builtin_expect(!!(expr), 0)
 
 inline float fast_sign(float f) { return 1 - 2 * (f < 0); }
 
@@ -38,206 +38,305 @@ namespace uLib {
 ///// RAY DATA /////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-void VoxRaytracer::RayData::AddElement(Id_t id, float L) {
+void VoxRaytracer::RayData::AddElement(Id_t id, float L)
-  Element el = {id, L};
+{
-  m_Data.push_back(el);
+    Element el = {id, L};
-  m_TotalLength += L;
+    m_Data.push_back(el);
+    m_TotalLength += L;
 }
 
-void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in) {
+
-  if (unlikely(!in.m_Data.size())) {
+void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in)
-    std::cout << "Warinig: PoCA on exit border!\n";
+{
-    return;
+    if (!in.m_Data.size())
-  } else if (unlikely(!m_Data.size())) {
+    {
-    m_Data = in.m_Data;
+        std::cout << "Warinig: PoCA on exit border!\n";
-    std::cout << "Warinig: PoCA on entrance border!\n";
+    }
-    return;
+    else if (!m_Data.size())
-  } else {
+    {
-    // Opzione 1) un voxel in piu' //
+        m_Data = in.m_Data;
-    if (in.m_Data.size() > 0) {
+        std::cout << "Warinig: PoCA on entrance border!\n";
-      m_Data.insert(m_Data.end(), in.m_Data.begin(), in.m_Data.end());
+    }
+    else
+    {
+        // Opzione 1) un voxel in piu' //
+        m_Data.reserve(m_Data.size() + in.m_Data.size());
+        m_Data.insert(m_Data.end(), in.m_Data.begin(), in.m_Data.end());
+        // Opzione 2) merge dei voxel nel poca.
+        //        RayData::Element &e1 = m_Data.back();
+        //        const RayData::Element &e2 = in.m_Data.front();
+        //        if(e1.vox_id == e2.vox_id)
+        //        {
+        //            m_Data.reserve(m_Data.size() + in.m_Data.size() - 1);
+        //            e1.L += e2.L; //fix//
+        //            m_Data.insert(m_Data.end(), in.m_Data.begin()+1, in.m_Data.end());
+        //        }
+        //        else {
+        //            m_Data.reserve(m_Data.size() + in.m_Data.size());
+        //            m_Data.insert(m_Data.end(), in.m_Data.begin(), in.m_Data.end());
+        //        }
+        m_TotalLength += in.m_TotalLength;
     }
-    // Opzione 2) merge dei voxel nel poca.
-    //        RayData::Element &e1 = m_Data.back();
-    //        const RayData::Element &e2 = in.m_Data.front();
-    //        if(e1.vox_id == e2.vox_id)
-    //        {
-    //            m_Data.reserve(m_Data.size() + in.m_Data.size() - 1);
-    //            e1.L += e2.L; //fix//
-    //            m_Data.insert(m_Data.end(), in.m_Data.begin()+1,
-    //            in.m_Data.end());
-    //        }
-    //        else {
-    //            m_Data.reserve(m_Data.size() + in.m_Data.size());
-    //            m_Data.insert(m_Data.end(), in.m_Data.begin(),
-    //            in.m_Data.end());
-    //        }
-    m_TotalLength += in.m_TotalLength;
-  }
 }
 
-void VoxRaytracer::RayData::PrintSelf(std::ostream &o) {
+void VoxRaytracer::RayData::PrintSelf(std::ostream &o)
-  o << "Ray: total lenght " << m_TotalLength << "\n";
+{
-  std::vector<Element>::iterator it;
+    o << "Ray: total lenght " << m_TotalLength << "\n";
-  for (it = m_Data.begin(); it < m_Data.end(); ++it)
+    for(std::vector<Element>::iterator it = m_Data.begin(); it < m_Data.end(); ++it)
-    o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
+    {
+        o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //// RAY TRACER ////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt) {
+VoxRaytracer::VoxRaytracer(StructuredGrid &image) : m_Image(&image)
-  Vector4f s = m_Image->GetLocalPoint(line.direction);
+{
-  pt = m_Image->GetLocalPoint(line.origin);
+    m_scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
+               (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
+               (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
+}
 
-  // Considers Structured grid dimensions //
+bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt)
-  Vector4f dims = m_Image->GetDims().homogeneous().cast<float>();
+{
-  pt = pt.cwiseQuotient(dims);
+    Vector4f s = m_Image->GetLocalPoint(line.direction);
-  s = s.cwiseQuotient(dims);
+    pt = m_Image->GetLocalPoint(line.origin);
 
-  float l = s.head(3).norm();
+    // Considers Structured grid dimensions //
-  Vector3f L(l / s(0), l / s(1), l / s(2));
+    Vector4f dims = m_Image->GetDims().homogeneous().cast<float>();
+    pt = pt.cwiseQuotient(dims);
+    s  = s.cwiseQuotient(dims);
 
-  Vector3f offset;
+    float l = s.head(3).norm();
-  for (int i = 0; i < 3; ++i)
+    Vector3f L(l/s(0), l/s(1), l/s(2));
-    offset(i) = (s(i) > 0) - (pt(i) - floor(pt(i)));
-  offset = offset.cwiseProduct(L).cwiseAbs();
 
-  int id;
+    Vector3f offset;
-  float d;
+    for(int i=0;i<3;++i)
-  for (int loop = 0; loop < 8; loop++) {
+        offset(i) = (s(i)>0) - (pt(i)-floor(pt(i))) ;
-    int check_border = 0;
+    offset = offset.cwiseProduct(L).cwiseAbs();
-    for (int i = 0; i < 3; ++i) {
+
-      check_border += pt(i) > 1;
+    int id; float d;
-      check_border += pt(i) < 0;
+    for(int loop=0; loop<8; loop++)
+    {
+        int check_border = 0;
+        for ( int i=0; i<3 ;++i) {
+            check_border += pt(i) > 1;
+            check_border += pt(i) < 0;
+        }
+        if(check_border == 0) {
+            for(int i=0;i<3;++i)
+                pt(i) *= (float)dims(i);
+            pt = m_Image->GetWorldPoint(pt);
+            return true;
+        }
+
+       d = offset.minCoeff(&id);
+       for(int i=0; i<3; ++i)
+           pt(i) += d / L(i);
+
+       pt(id) = rintf(pt(id));
+
+
+       offset.array() -= d;
+       offset(id) = fabs(L(id));
     }
-    if (check_border == 0) {
+    for(int i=0;i<3;++i)
-      for (int i = 0; i < 3; ++i)
         pt(i) *= (float)dims(i);
-      pt = m_Image->GetWorldPoint(pt);
+    pt = m_Image->GetWorldPoint(pt);
-      return true;
+    return false;
+}
+
+bool VoxRaytracer::GetExitPoint(const HLine3f &line, HPoint3f &pt)
+{
+    HLine3f out = line;
+    out.direction *= -1;
+    return GetEntryPoint(out,pt);
+}
+
+
+VoxRaytracer::RayData VoxRaytracer::TraceBetweenPoints(const HPoint3f &in, const HPoint3f &out) const
+{
+    RayData ray;
+    Vector4f pt1 = m_Image->GetLocalPoint(in);
+    Vector4f pt2 = m_Image->GetLocalPoint(out);
+    Vector4f s = pt2 - pt1;
+
+    float l = s.head(3).norm();
+    Vector3f L(l/s(0), l/s(1), l/s(2));
+
+    Vector3f offset;
+    for(int i=0;i<3;++i)
+    {
+        offset(i) = (s(i)>=0) - (pt1(i)-floor(pt1(i)));
+    }
+    offset = offset.cwiseProduct(L).cwiseAbs();
+    L = L.cwiseAbs();
+
+    //---- Check if the ray only crosses one voxel
+    Vector3i vid = m_Image->Find(in);
+    if (vid == m_Image->Find(out))
+    {
+        ray.AddElement(m_Image->Map(vid),s.norm());
+        return ray;
     }
 
-    d = offset.minCoeff(&id);
+    //---- Otherwise, loop until ray is finished
-    for (int i = 0; i < 3; ++i)
+    int id; float d;
-      pt(i) += d / L(i);
+    while (l>0)
+    {
+        d = offset.minCoeff(&id);
 
-    pt(id) = rintf(pt(id));
+        if (m_Image->IsInsideGrid(vid))
+        {
+            ray.AddElement(m_Image->Map(vid), d * m_scale(id));
+        }
 
-    offset.array() -= d;
+        vid(id) += (int)fast_sign(s(id));
-    offset(id) = fabs(L(id));
-  }
-  for (int i = 0; i < 3; ++i)
-    pt(i) *= (float)dims(i);
-  pt = m_Image->GetWorldPoint(pt);
-  return false;
-}
 
-bool VoxRaytracer::GetExitPoint(const HLine3f &line, HPoint3f &pt) {
+        l -= d;
-  HLine3f out = line;
+        offset.array() -= d;
-  out.direction *= -1;
+        offset(id) = fmin(L(id),l);
-  return GetEntryPoint(out, pt);
+    }
-}
-
-VoxRaytracer::RayData
-VoxRaytracer::TraceBetweenPoints(const HPoint3f &in,
-                                 const HPoint3f &out) const {
-  RayData ray;
-  Vector4f pt1 = m_Image->GetLocalPoint(in);
-  Vector4f pt2 = m_Image->GetLocalPoint(out);
-  Vector4f s = pt2 - pt1;
-
-  float l = s.head(3).norm();
-  Vector3f L(l / s(0), l / s(1), l / s(2));
-
-  // Vector3f scale; // FIXXX
-  // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
-  //          (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
-  //          (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
-
-  Vector3f offset;
-  for (int i = 0; i < 3; ++i)
-    offset(i) = (s(i) >= 0) - (pt1(i) - floor(pt1(i)));
-  offset = offset.cwiseProduct(L).cwiseAbs();
-  L = L.cwiseAbs();
-
-  //---- Check if the ray only crosses one voxel
-  Vector3i vid = m_Image->Find(in);
-  if (vid == m_Image->Find(out)) {
-    ray.AddElement(m_Image->Map(vid), s.norm());
     return ray;
-  }
+}
 
-  //---- Otherwise, loop until ray is finished
+static int encode_v(Vector3i in)
-  int id;
+{
-  float d;
+    return ((in[0] + 1) << 4) + ((in[1] + 1) << 2) + in[2] + 1;
-  while (l > 0) {
+}
 
-    d = offset.minCoeff(&id);
+static Vector3i decode_v(int in)
+{
+    Vector3i result {
+     ((in & 48) >> 4) - 1,
+     ((in & 12) >> 2) - 1,
+     (in & 3) - 1
+    };
+    return result;
+}
 
-    if (m_Image->IsInsideGrid(vid)) {
+VoxRaytracer::RayData VoxRaytracer::BeamBetweenPoints(const HPoint3f &in, const HPoint3f &out, Vector3i thickness) const
-      ray.AddElement(m_Image->Map(vid), d * m_scale(id));
+{
+    if (thickness[0] < 0) thickness[0] = 0;
+    if (thickness[1] < 0) thickness[1] = 0;
+    if (thickness[2] < 0) thickness[2] = 0;
+
+    Vector3i zero_v { 0, 0, 0 };
+
+    RayData ray = TraceBetweenPoints(in, out);
+    if (thickness == zero_v || ray.Data().size() == 0) return ray;
+
+    /*
+     * Calculate the forbidden relocations
+     */
+
+    std::unordered_map<int, int> ban_points(26);
+
+    Vector3i prevPos = m_Image->UnMap(ray.Data()[0].vox_id);
+    Vector3i currDir = zero_v;
+    int currLen = 1;
+
+    for (int k = 1; k < ray.Data().size(); k++)
+    {
+        Vector3i currPos = m_Image->UnMap(ray.Data()[k].vox_id);
+        Vector3i offset = currPos - prevPos;
+        prevPos = currPos;
+
+        if (k == 1) currDir = offset;
+
+        if (offset == currDir)
+        {
+            currLen++;
+            continue;
+        }
+
+        int enc_v = encode_v(currDir);
+        if (ban_points.find(enc_v) == ban_points.end())
+        {
+            ban_points.emplace(enc_v, currLen);
+        }
+        else if (currLen > ban_points[enc_v])
+        {
+            ban_points[enc_v] = currLen;
+        }
+
+        currDir = offset;
+        currLen = 2;
     }
 
-    // nan check //
+    /*
-    //        if(unlikely(!isFinite(d * scale(id)))) {
+     * Calculate the beam section
-    //            std:: cout << "NAN in raytracer\n";
+     */
-    //            exit(1);
+    std::vector<Vector3i> relocs;
-    //        }
+    relocs.push_back(zero_v);
 
-    vid(id) += (int)fast_sign(s(id));
+    /*
+     * Compose the beam
+     */
+    RayData beam;
+    for (auto iter : ray.Data())
+    {
+        Vector3i rPos = m_Image->UnMap(iter.vox_id);
 
-    l -= d;
+        for (Vector3i reloc : relocs)
-    offset.array() -= d;
+        {
-    offset(id) = fmin(L(id), l);
+            Vector3i cPos = rPos + reloc;
-  }
+            if (!m_Image->IsInsideGrid(cPos)) continue;
-  return ray;
+
+            beam.AddElement(m_Image->Map(cPos), iter.L);
+        }
+    }
+
+    return beam;
 }
 
+
+
 // 20150528 SV for absorbed muons
-VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const {
+VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
-  RayData ray;
+{
+    RayData ray;
+    Vector4f pt = m_Image->GetLocalPoint(line.origin);
+    Vector4f s = m_Image->GetLocalPoint(line.direction);
 
-  Vector4f pt = m_Image->GetLocalPoint(line.origin);
+    float l = s.head(3).norm();
-  Vector4f s = m_Image->GetLocalPoint(line.direction);
+    // intersection between track and grid when spacing is +1
+    Vector3f L(l/s(0), l/s(1), l/s(2));
 
-  float l = s.head(3).norm();
+    // RayTracer works with a grid of interspace +1
-  // intersection between track and grid when spacing is +1
+    // Vector3f scale; // FIXXX
-  Vector3f L(l / s(0), l / s(1), l / s(2));
+    // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
+    //          (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
+    //          (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
 
-  // RayTracer works with a grid of interspace +1
+    // offset is the fraction of the segment between grid lines when origin is insiede voxel
-  // Vector3f scale; // FIXXX
+    // cwiseAbs for having positive distances
-  // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
+    Vector3f offset;
-  //          (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
+    for(int i=0;i<3;++i)
-  //          (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
+        offset(i) = (s(i)>=0) - (pt(i)-floor(pt(i)));
+    offset = offset.cwiseProduct(L).cwiseAbs();
+    L = L.cwiseAbs();
 
-  // offset is the fraction of the segment between grid lines when origin is
+    int id; float d;
-  // insiede voxel cwiseAbs for having positive distances
+    Vector3i vid = m_Image->Find(line.origin);
-  Vector3f offset;
+    while(m_Image->IsInsideGrid(vid))
-  for (int i = 0; i < 3; ++i)
+    {
-    offset(i) = (s(i) >= 0) - (pt(i) - floor(pt(i)));
+        // minimun coefficient of offset: id is the coordinate, d is the value
-  offset = offset.cwiseProduct(L).cwiseAbs();
+        // dependig on which grid line horizontal or vertical it is first intercept
-  L = L.cwiseAbs();
+        d = offset.minCoeff(&id);
 
-  int id;
+        // add Lij to ray
-  float d;
+        ray.AddElement(m_Image->Map(vid), d * m_scale(id) );
-  Vector3i vid = m_Image->Find(line.origin);
-  while (m_Image->IsInsideGrid(vid)) {
-    // minimun coefficient of offset: id is the coordinate, d is the value
-    // dependig on which grid line horizontal or vertical it is first intercept
-    d = offset.minCoeff(&id);
 
-    // add Lij to ray
+        // move to the next voxel
-    ray.AddElement(m_Image->Map(vid), d * m_scale(id));
+        vid(id) += (int)fast_sign(s(id));
 
-    // move to the next voxel
+        offset.array() -= d;
-    vid(id) += (int)fast_sign(s(id));
+        offset(id) = L(id);
-
+    }
-    offset.array() -= d;
+    return ray;
-    offset(id) = L(id);
-  }
-  return ray;
 }
 
-} // namespace uLib
+} //end of namespace uLib

src/Math/VoxRaytracer.h

@@ -38,7 +38,8 @@ namespace uLib {
 class VoxRaytracer {
 
 public:
-    class RayData {
+    class RayData
+    {
     public:
         RayData() : m_TotalLength(0) {}
 
@@ -62,14 +63,8 @@ public:
         Scalarf              m_TotalLength;
     };
 
-
+public:
- public:
+    VoxRaytracer(StructuredGrid &image);
- VoxRaytracer(StructuredGrid &image) : m_Image(&image) {
-      m_scale <<
-	(m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
-	(m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
-	(m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
-    }
 
     bool GetEntryPoint(const HLine3f &line, HPoint3f &pt);
 
@@ -77,6 +72,8 @@ public:
 
     RayData TraceBetweenPoints(const HPoint3f &in, const HPoint3f &out) const;
 
+    RayData BeamBetweenPoints(const HPoint3f &in, const HPoint3f &out, Vector3i thickness) const;
+
     RayData TraceLine(const HLine3f &line) const;
 
     inline StructuredGrid* GetImage() const { return this->m_Image; }

src/Math/testing/CMakeLists.txt

@@ -19,4 +19,4 @@ set(LIBRARIES
        ${PACKAGE_LIBPREFIX}Math
 )
 
-uLib_add_tests(Math)
+uLib_add_tests(${uLib-module})

src/Math/testing/VoxImageTest.cpp

@@ -92,20 +92,6 @@ int main() {
         imgR.ExportToVtk("./read_and_saved.vtk");
     }
 
-    {
-        VoxImage<TestVoxel> img(Vector3i(4,4,4));
-        img.InitVoxels({0,0});
-        for (int i=0; i<4; i++) {
-            for (int j=0; j<4; j++) {
-                for (int k=0; k<4; k++) {
-                    img[Vector3i(i,j,k)] = {i+j+k,0};
-                }
-            }
-        }
-        img.ExportToVti("./vti_saved.vti",0,1);
-        // img.ImportFromVtkXml("./test_vox_image.vti");
-    }
-
 
     {
         VoxImage<TestVoxel> img1(Vector3i(5,5,5));

src/Root/CMakeLists.txt

@@ -1,49 +1,12 @@
 set(HEADERS RootMathDense.h
             RootMuonScatter.h
-            RootHitRaw.h
+            RootHitRaw.h)
-            muCastorMCTrack.h
-            muCastorHit.h
-            muCastorInfo.h
-            muCastorSkinHit.h
-            muCastorPrimaryVertex.h
-            muCastorMuDetDIGI.h
-            SkinDetectorWriter.h)
 
-set(SOURCES ${HEADERS} RootMuonScatter.cpp
+set(SOURCES ${HEADERS} RootMuonScatter.cpp)
-                       muCastorMCTrack.cpp
-                       muCastorHit.cpp
-                       muCastorInfo.cpp
-                       muCastorSkinHit.cpp
-                       muCastorPrimaryVertex.cpp
-                       muCastorMuDetDIGI.cpp
-                       SkinDetectorWriter.cpp)
-
-set(DICTIONARY_HEADERS muCastorMCTrack.h
-                       muCastorHit.h
-                       muCastorInfo.h
-                       muCastorSkinHit.h
-                       muCastorPrimaryVertex.h
-                       muCastorMuDetDIGI.h
-                       SkinDetectorWriter.h)
 
 set(LIBRARIES ${ROOT_LIBRARIES}
               ${PACKAGE_LIBPREFIX}Math)
 
-set(rDictName ${PACKAGE_LIBPREFIX}RootDict)
-root_generate_dictionary(${rDictName} ${DICTIONARY_HEADERS}
-                         LINKDEF Linkdef.h)
-set_source_files_properties(${rDictName}.cxx
-                            PROPERTIES GENERATED TRUE)
-set_source_files_properties(${rDictName}.h
-                            PROPERTIES GENERATED TRUE)
-list(APPEND SOURCES ${rDictName}.cxx)
-
-# TODO use a custom target linked to root_generate_dictionary
-set(R_ARTIFACTS ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}_rdict.pcm
-                ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}.rootmap)
-install(FILES ${R_ARTIFACTS}
-        DESTINATION ${INSTALL_LIB_DIR})
-
 set(libname ${PACKAGE_LIBPREFIX}Root)
 set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
 set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Root PARENT_SCOPE)
@@ -51,15 +14,14 @@ set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Root PARENT_SCOPE)
 add_library(${libname} SHARED ${SOURCES})
 set_target_properties(${libname} PROPERTIES
                       VERSION ${PROJECT_VERSION}
-                      SOVERSION ${PROJECT_SOVERSION}
+                      SOVERSION ${PROJECT_SOVERSION})
-                      CXX_STANDARD 17)
 target_link_libraries(${libname} ${LIBRARIES})
 
 install(TARGETS ${libname}
         EXPORT "${PROJECT_NAME}Targets"
-        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
 
-install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Root)
+install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Root)
 
 

src/Root/Linkdef.h

@@ -23,6 +23,8 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+
+
 #ifndef U_ROOT_LINKDEF_H
 #define U_ROOT_LINKDEF_H
 
@@ -33,21 +35,50 @@
 #pragma link off all functions;
 #pragma link C++ nestedclasses;
 
+#pragma link C++ class TestTObject+;
+
 using namespace ROOT::Mutom;
 
-#pragma link C++ class ROOT::Math::Cartesian3D < int> + ;
+#pragma link C++ class ROOT::Math::Cartesian2D<int>+;
-#pragma link C++ class ROOT::Math::Cartesian3D < float> + ;
+#pragma link C++ class ROOT::Math::Cartesian2D<float>+;
-#pragma link C++ class ROOT::Math::Cartesian3D < double> + ;
+#pragma link C++ class ROOT::Math::Cartesian2D<double>+;
+
+#pragma link C++ class ROOT::Math::Cartesian3D<int>+;
+#pragma link C++ class ROOT::Math::Cartesian3D<float>+;
+#pragma link C++ class ROOT::Math::Cartesian3D<double>+;
+
+#pragma link C++ class Vector2i+;
+#pragma link C++ class Vector2f+;
+#pragma link C++ class Vector2d+;
+
+#pragma link C++ class Vector3i+;
+#pragma link C++ class Vector3f+;
+#pragma link C++ class Vector3d+;
+
+#pragma link C++ typedef Matrix3i;
+#pragma link C++ typedef Matrix3f;
+#pragma link C++ typedef Matrix3d;
+
+#pragma link C++ class Line3f+;
+#pragma link C++ class Line3d+;
+
+#pragma link C++ class MuonTrack+;
+#pragma link C++ class MuonScatter+;
+#pragma link C++ function MuonScatter::p_mean() const;
 
 // #pragma link C++ class DetectorChamber+;
 
-#pragma link C++ class muCastorMCTrack + ;
+#pragma link C++ class HitRaw+;
-#pragma link C++ class muCastorHit + ;
+#pragma link C++ function HitRaw::Chm() const;
-#pragma link C++ class muCastorInfo + ;
+#pragma link C++ function HitRaw::Rob() const;
-#pragma link C++ class muCastorSkinHit + ;
+#pragma link C++ function HitRaw::Tdc() const;
-#pragma link C++ class muCastorPrimaryVertex + ;
+#pragma link C++ function HitRaw::Ch() const;
-#pragma link C++ class muCastorMuDetDIGI + ;
+
-#pragma link C++ class SkinDetectorWriter + ;
+#pragma link C++ class  muBlastMCTrack+;
+#pragma link C++ class  muBlastHit+;
+#pragma link C++ class  muCastorMCTrack+;
+#pragma link C++ class  muCastorHit+;
+#pragma link C++ class  muCastorInfo+;
 
 #endif // __CINT__
 

src/Root/SkinDetectorWriter.cpp

@@ -1,47 +0,0 @@
-#include "SkinDetectorWriter.h"
-#include "muCastorSkinHit.h"
-#include "TVector3.h"
-
-SkinDetectorWriter::SkinDetectorWriter(string filename) :
-    t_file(nullptr),
-    t_tree(nullptr),
-    t_buffer(nullptr),
-    i_status(0)
-{
-    t_file = new TFile(filename.c_str(), "RECREATE");
-    t_tree = new TTree("muCastorMC", "muCastorMC");
-    t_buffer = new TClonesArray("muCastorSkinHit");
-
-    t_tree->Branch("CastorSkinHits", "TClonesArray", t_buffer, 32000, 99);
-
-    if (t_file->IsZombie()) i_status = 1;
-}
-
-SkinDetectorWriter::~SkinDetectorWriter()
-{}
-
-void SkinDetectorWriter::add(int detID, float p_x, float p_y, float p_z,
-                             float m_x, float m_y, float m_z)
-{
-    TClonesArray& ref = *t_buffer;
-    int size = ref.GetEntriesFast();
-
-    muCastorSkinHit* new_hit = new(ref[size]) muCastorSkinHit();
-    new_hit->SetDetID(detID);
-    new_hit->SetPdgCode(13);
-    new_hit->SetMotherID(-1);
-    new_hit->SetPos (TVector3(p_x, p_y, p_z));
-    new_hit->SetMom (TVector3(m_x, m_y, m_z));
-}
-
-void SkinDetectorWriter::write()
-{
-    if (t_tree->Fill() < 0) i_status = 2;
-    t_buffer->Delete();   // or t_buffer->Clear() ??
-}
-
-void SkinDetectorWriter::close()
-{
-    if (t_tree->Write() == 0) i_status = 3;
-    t_file->Close();
-}

src/Root/SkinDetectorWriter.h

@@ -1,32 +0,0 @@
-#ifndef SkinDetectorWriter_h
-#define SkinDetectorWriter_h
-
-#include <string>
-
-#include "TFile.h"
-#include "TTree.h"
-#include "TClonesArray.h"
-
-using std::string;
-
-class SkinDetectorWriter
-{
-public:
-    SkinDetectorWriter(string filename);
-    virtual ~SkinDetectorWriter();
-
-    void add(int detID, float p_x, float p_y, float p_z, float m_x, float m_y, float m_z);
-    int status() { return i_status; }
-    void write();
-    void close();
-
-private:
-    TFile* t_file;
-    TTree* t_tree;
-    TClonesArray* t_buffer;
-    int i_status;
-};
-
-
-
-#endif //SkinDetectorWriter_h

src/Root/muCastorMuDetDIGI.cpp

@@ -1,41 +0,0 @@
-/// \file muCastorMuDetDIGI.cxx 
-/// \brief Implementation of the muCastorMuDetDIGI class 
-//  This class build the DIGI for the scintillator detectors 
-/// \author G. Bonomi, M. Subieta - INFN
-
-#include <iostream>
-
-#include "muCastorMuDetDIGI.h"
-
-/// \cond CLASSIMP
-ClassImp(muCastorMuDetDIGI)
-/// \endcond
-
-using namespace std;
-
-//_____________________________________________________________________________
-muCastorMuDetDIGI::muCastorMuDetDIGI() :
-    fDetID(-1),
-    fLayID(-1),
-    fTubID(-1),
-    fDistMC(0.),
-    fDriftMC(0.),
-    fDist(0.),
-    fDrift(0.),
-    fEnergy(0.)
-{}
-
-//_____________________________________________________________________________
-muCastorMuDetDIGI::~muCastorMuDetDIGI() 
-{}
-
-//_____________________________________________________________________________
-void muCastorMuDetDIGI::Print(const Option_t* /*opt*/) const
-{
-    cout << "  DetID: " << fDetID
-         << "  LayID: " << fLayID
-         << "  TubID: " << fTubID
-         << "  energy deposit (keV): " << fEnergy
-         << endl;
-}
-

src/Root/muCastorMuDetDIGI.h

@@ -1,75 +0,0 @@
-#ifndef muCastor_MuDetDIGI_H
-#define muCastor_MuDetDIGI_H
-
-/// \file muCastorMuDetDIGI.h
-/// \brief Definition of the muCastorMuDetDIGI class 
-///
-/// \authors G. Bonomi, M. Subieta - INFN
-
-#include <TObject.h>
-
-class muCastorMuDetDIGI : public TObject
-{
-public:
-    muCastorMuDetDIGI();
-    virtual ~muCastorMuDetDIGI();
-
-    // -------> PUBLIC FUNCTIONS
-    virtual void Print(const Option_t* option = "") const;
-
-    // -------> SET METHODS
-
-    /// Set Det ID (Detector module)
-    void SetDetID(Int_t id)  { fDetID = id; };  
-
-    /// Set Layer ID (Layer [0,5])
-    void SetLayID(Int_t id)  { fLayID = id; };  
-
-    /// Set Tube ID (Tube inside each layer)
-    void SetTubID(Int_t id)  { fTubID = id; };  
-
-    void SetDistMC      (Double_t v)  { fDistMC = v; };
-    void SetDriftMC     (Double_t v)  { fDriftMC= v; };
-    void SetDist        (Double_t v)  { fDist   = v; };
-    void SetDrift       (Double_t v)  { fDrift  = v; };
-
-    // Set energy 
-    void SetEnergy(Double_t e)  { fEnergy = e; };
-
-    // -------> GET METHODS
-
-    /// \return The Module number
-    Int_t GetDetID() { return fDetID; };
-
-    /// \return The Layer number
-    Int_t GetLayID() { return fLayID; };
-
-    /// \return The Tube number
-    Int_t GetTubID() { return fTubID; };
-
-    Double_t GetDistMC()    { return fDistMC;   };
-    Double_t GetDriftMC()   { return fDriftMC;  };
-    Double_t GetDist()      { return fDist;     };
-    Double_t GetDrift()     { return fDrift;    };
-
-    /// \return Get energy
-    Double_t GetEnergy()   { return fEnergy; };
-
-
-    // -------> PRIVATE VARIABLES
-private:
-    Int_t      fDetID;      // Detector module ID 
-    Int_t      fLayID;      // Detector layer ID
-    Int_t      fTubID;      // Layer tube ID
-    Double_t   fDistMC;     // Minimum distance of particle tracks to the wire
-    Double_t   fDriftMC;    // Minimum drift time to the wire
-    Double_t   fDist;       // Minimum distance of particle tracks to the wire (with smearing)
-    Double_t   fDrift;      // Minimum drift time to the wire (with smearing)
-    Double_t   fEnergy;     // Energy released in the element
-
-    ClassDef(muCastorMuDetDIGI,1) //muCastorMuDetDIGI  
-};
-
-#endif //muCastorMuDetDIGI_H
-
-

src/Root/muCastorPrimaryVertex.cpp

@@ -1,47 +0,0 @@
-#include <iostream>
-#include <limits>
-
-#include "muCastorPrimaryVertex.h"
-
-/// \cond CLASSIMP
-ClassImp(muCastorPrimaryVertex)
-/// \endcond
-
-using namespace std;
-
-//_____________________________________________________________________________
-muCastorPrimaryVertex::muCastorPrimaryVertex() {
-/// Default constructor
-    Reset();
-}
-
-//_____________________________________________________________________________
-muCastorPrimaryVertex::~muCastorPrimaryVertex()
-{
-/// Destructor
-}
-
-//_____________________________________________________________________________
-void muCastorPrimaryVertex::Reset()
-{
-    fPdgCode    = 0;
-    fVx         = std::numeric_limits<double>::quiet_NaN();
-    fVy         = std::numeric_limits<double>::quiet_NaN();
-    fVz         = std::numeric_limits<double>::quiet_NaN();
-    fPx         = std::numeric_limits<double>::quiet_NaN();
-    fPy         = std::numeric_limits<double>::quiet_NaN();
-    fPz         = std::numeric_limits<double>::quiet_NaN();
-    fE          = std::numeric_limits<double>::quiet_NaN();
-}
-
-//_____________________________________________________________________________
-void muCastorPrimaryVertex::Print(const Option_t* /*opt*/) const
-{
-/// Printing
-
-  	cout << "  Primary particle PDG Code " << fPdgCode << endl; 
-	cout << "  Vertex: (" << fVx << ", " << fVy << ", " << fVz << ") cm" << endl;
-	cout << "  Mom: (" << fPx << ", " << fPy << ", " << fPz << ")  MeV/c" << endl;
-
-}
-

src/Root/muCastorPrimaryVertex.h

@@ -1,53 +0,0 @@
-#ifndef muCastor_PVTX_H
-#define muCastor_PVTX_H
-
-/// \brief Definition of the muCastorPrimaryVertex class 
-///
-/// \authors G. Bonomi (04/02/2020)
-
-#include <TObject.h>
-
-class muCastorPrimaryVertex : public TObject
-{
-    public:
-        muCastorPrimaryVertex();
-        virtual ~muCastorPrimaryVertex();
-
-        // -------> PUBLIC FUNCTIONS
-        virtual void Print(const Option_t* option = "") const;
-
-        // -------> SET METHODS
-
-		void SetPdgCode(Int_t code) { fPdgCode = code; };
-
-        void SetVx(Double_t Vx)   { fVx = Vx; };  
-        void SetVy(Double_t Vy)   { fVy = Vy; };  
-        void SetVz(Double_t Vz)   { fVz = Vz; };  
-
-        void SetPx(Double_t Px)   { fPx = Px; };  
-        void SetPy(Double_t Py)   { fPy = Py; };  
-        void SetPz(Double_t Pz)   { fPz = Pz; };  
-
-        void SetE(Double_t E)  { fE = E; };
-
-        void Reset();
-    private:
-        // -------> PRIVATE VARIABLES
-		Int_t          fPdgCode;              // PDG code of the particle
-
-  		Double_t       fVx;                   // x of production vertex
-  		Double_t       fVy;                   // y of production vertex
-  		Double_t       fVz;                   // z of production vertex
-
- 		Double_t       fPx;                   // x component of momentum
-  		Double_t       fPy;                   // y component of momentum
-  		Double_t       fPz;                   // z component of momentum
-  		Double_t       fE;                    // Energy
-
-
-        ClassDef(muCastorPrimaryVertex,1) //muCastorPrimaryVertex  
-};
-
-#endif //muCastor_PVTX_H
-
-

src/Root/muCastorSkinHit.cpp

@@ -1,43 +0,0 @@
-//----------------------------------------------------------
-// Class : CastorSkinHit 
-// Date: October 2020
-// Author: Germano Bonomi   germano.bonomi@unibs.it
-//----------------------------------------------------------
-
-#include <iostream>
-
-#include "muCastorSkinHit.h"
-
-/// \cond CLASSIMP
-ClassImp(muCastorSkinHit)
-/// \endcond
-
-using namespace std;
-
-//_____________________________________________________________________________
-muCastorSkinHit::muCastorSkinHit() :
-    fDetID(-1),
-    fPdgCode(-1),
-    fMotherID(-1),
-    fMomX(0.),
-    fMomY(0.),
-    fMomZ(0.),
-    fPosX(0.),
-    fPosY(0.),
-    fPosZ(0.)
-{}
-
-//_____________________________________________________________________________
-muCastorSkinHit::~muCastorSkinHit() 
-{}
-//_____________________________________________________________________________
-void muCastorSkinHit::Print(const Option_t* /*opt*/) const
-{
-    cout << "  detID: " << fDetID 
-         << "  position (cm): (" 
-         << fPosX << ", " << fPosY << ", " << fPosZ << ")"
-         << "  momentum (MeV/c): (" 
-         << fMomX << ", " << fMomY << ", " << fMomZ << ")"
-         << endl;
-}
-

src/Root/muCastorSkinHit.h

@@ -1,52 +0,0 @@
-//----------------------------------------------------------
-// Class : CastorSkinHit 
-// Date: October 2020
-// Author: Germano Bonomi   germano.bonomi@unibs.it
-//----------------------------------------------------------
-
-#ifndef muCastor_SKINHIT_H
-#define muCastor_SKINHIT_H
-
-
-#include <TObject.h>
-#include <TVector3.h>
-
-class muCastorSkinHit : public TObject
-{
-public:
-    muCastorSkinHit();
-    virtual ~muCastorSkinHit();
-
-    // methods
-    virtual void Print(const Option_t* option = "") const;
-
-    // set methods
-    void SetDetID(Int_t id)         { fDetID = id; };  
-    void SetPdgCode(Int_t pdg)      { fPdgCode = pdg; };
-    void SetMotherID(Int_t mid)     { fMotherID = mid; };
-    void SetMom(TVector3 xyz)       { fMomX = xyz.X(); fMomY = xyz.Y(); fMomZ = xyz.Z(); };
-    void SetPos(TVector3 xyz)       { fPosX = xyz.X(); fPosY = xyz.Y(); fPosZ = xyz.Z(); };
-
-    Int_t GetDetID()    { return fDetID; }
-    Int_t GetPdgCode()  { return fPdgCode; }
-    Int_t GetMotherID() { return fMotherID; }
-    TVector3 GetMom()   { return TVector3(fMomX, fMomY, fMomZ); }
-    TVector3 GetPos()   { return TVector3(fPosX, fPosY, fPosZ); }
-      
-private:
-    Int_t      fDetID;      // Detector module ID 
-    Int_t      fPdgCode;    // Particle PDG Code
-    Int_t      fMotherID;   // Particle mother ID (-1 = primary, 0 = secondary, etc..)
-    Double_t   fMomX;       // Track momentum when releasing the hit (X)
-    Double_t   fMomY;       // Track momentum when releasing the hit (Y)
-    Double_t   fMomZ;       // Track momentum when releasing the hit (Z)
-    Double_t   fPosX;       // Hit coordinates (at the entrance of the detector) (X)
-    Double_t   fPosY;       // Hit coordinates (at the entrance of the detector) (Y)
-    Double_t   fPosZ;       // Hit coordinates (at the entrance of the detector) (Z)
-    
-    ClassDef(muCastorSkinHit,1) //muCastorSkinHit  
-};
-
-#endif //muCastort_SKINHIT_H
-
-

src/Vtk/CMakeLists.txt

@@ -14,7 +14,7 @@ set(SOURCES uLibVtkInterface.cxx
             vtkVoxRaytracerRepresentation.cpp
             vtkVoxImage.cpp)
 
-set(LIBRARIES Eigen3::Eigen
+set(LIBRARIES ${Eigen_LIBRARY}
               ${ROOT_LIBRARIES}
               ${VTK_LIBRARIES}
               ${PACKAGE_LIBPREFIX}Math)
@@ -31,8 +31,8 @@ target_link_libraries(${libname} ${LIBRARIES})
 
 install(TARGETS ${libname}
         EXPORT "${PROJECT_NAME}Targets"
-        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
 
-install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Vtk)
+install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Vtk)
 

src/Vtk/uLibVtkInterface.cxx

@@ -37,7 +37,7 @@
 #endif
 
 
-#include <vtkVersion.h>
+#include <vtkConfigure.h>
 #include <vtkProp.h>
 #include <vtkActor.h>
 #include <vtkSmartPointer.h>

src/Vtk/vtkContainerBox.cpp

@@ -65,7 +65,6 @@ vtkContainerBox::~vtkContainerBox()
 vtkPolyData *vtkContainerBox::GetPolyData() const
 {
     // TODO
-    return NULL;
 }
 
 void vtkContainerBox::InstallPipe()

src/Vtk/vtkMuonScatter.h

@@ -28,7 +28,7 @@
 #ifndef VTKMUONSCATTER_H
 #define VTKMUONSCATTER_H
 
-#include <vtkVersion.h>
+#include <vtkConfigure.h>
 #include <vtkSmartPointer.h>
 #include <vtkSphereSource.h>
 #include <vtkAppendPolyData.h>

src/Vtk/vtkVoxImage.h

@@ -28,11 +28,11 @@
 #ifndef U_VTKVOXIMAGE_H
 #define U_VTKVOXIMAGE_H
 
-#include <vtkVolume.h>
+#include "vtk/vtkVolume.h"
-#include <vtkImageData.h>
+#include "vtk/vtkImageData.h"
-#include <vtkXMLImageDataReader.h>
+#include "vtk/vtkXMLImageDataReader.h"
-#include <vtkXMLImageDataWriter.h>
+#include "vtk/vtkXMLImageDataWriter.h"
-#include <vtkCubeSource.h>
+#include "vtk/vtkCubeSource.h"
 
 #include <Math/VoxImage.h>
 

uLib.files

@@ -30,6 +30,7 @@ src/Core/testing/Flags.h
 src/Core/testing/ObjectCopyTest.cpp
 src/Core/testing/ObjectFlagsTest.cpp
 src/Core/testing/ObjectParametersTest.cpp
+src/Core/testing/ObjectPropableTest.cpp
 src/Core/testing/OptionsTest.cpp
 src/Core/testing/PropertiesTest.cpp
 src/Core/testing/SerializeDreadDiamondTest.cpp
@@ -58,6 +59,7 @@ src/Core/Macros.h
 src/Core/Mpl.h
 src/Core/Object.cpp
 src/Core/Object.h
+src/Core/ObjectProps.h
 src/Core/Options.cpp
 src/Core/Options.h
 src/Core/Serializable.cpp

uLibConfig.cmake.in

@@ -1,92 +1,15 @@
-# - Config file for the ULib package
+# - Config file for the FooBar package
 # It defines the following variables
-#  ULIB_INCLUDE_DIRS - include directories for ULib
+#  FOOBAR_INCLUDE_DIRS - include directories for FooBar
-#  ULIB_LIBRARIES    - libraries to link against
+#  FOOBAR_LIBRARIES    - libraries to link against
-#  ULIB_EXECUTABLE   - the bar executable
+#  FOOBAR_EXECUTABLE   - the bar executable
-
-
-set(ULIB_VERSION @PROJECT_VERSION@)
-
-@PACKAGE_INIT@
-
-# Defines the include directories for the header files
-# PACKAGE_INCLUDE_INSTALL_DIR is replaced by configure_package_config_file
-# with the correct path for the installation.
-set(ULIB_INCLUDE_DIRS "${PACKAGE_INCLUDE_INSTALL_DIR}")
 
+# Compute paths
 get_filename_component(ULIB_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+set(ULIB_INCLUDE_DIRS "@CONF_INCLUDE_DIRS@")
 
-# Search for the directory of exported build targets
+# Our library dependencies (contains definitions for IMPORTED targets)
-set(uLib_BUILD_TARGETS_FILE
+include("${ULIB_CMAKE_DIR}/uLibTargets.cmake")
-    "${ULIB_CMAKE_DIR}/uLibTargets-build.cmake"
-)
-
-# Search for the directory of installed targets
-set(uLib_INSTALL_TARGETS_FILE
-    "${ULIB_CMAKE_DIR}/uLibTargets.cmake"
-)
-
-# We use a logic based on the presence of the build target file
-# to determine if we are in a local build.
-if(EXISTS "${uLib_BUILD_TARGETS_FILE}")
-    message(STATUS " ++ Using uLib build targets")
-
-    include("${uLib_BUILD_TARGETS_FILE}")
-    set_and_check(ULIB_INCLUDE_DIRS "@ULIB_SOURCE_DIR@/src")
-    set_and_check(ULIB_LIBRARY_DIRS "${ULIB_CMAKE_DIR}")
-    set(ULIB_BUILD_DIR ${ULIB_CMAKE_DIR})
-
-    # Target that builds uLib inside its build directory
-    add_custom_target(uLib_dependency_target
-        COMMAND echo " --------------------------------- "
-        COMMAND echo " - Building uLib as a dependency - "
-        COMMAND echo " --------------------------------- "
-        COMMAND echo ""
-        COMMAND ${CMAKE_COMMAND} --build ${ULIB_BUILD_DIR}
-        COMMAND echo ""
-        WORKING_DIRECTORY ${ULIB_BUILD_DIR}
-    )
-
-    add_library(uLib_dependency INTERFACE)
-    add_dependencies(uLib_dependency uLib_dependency_target)
-    link_libraries(uLib_dependency)
-
-else()
-    message(STATUS " ++ Using uLib installed targets")
-
-    include("${uLib_INSTALL_TARGETS_FILE}")
-    set_and_check(ULIB_INCLUDE_DIRS "@PACKAGE_INSTALL_INC_DIR@")
-    set(ULIB_SYSCONFIG_DIR "@PACKAGE_INSTALL_ETC_DIR@")
-    set_and_check(ULIB_CMAKE_DIR "@PACKAGE_INSTALL_CMAKE_DIR@")
-    set_and_check(ULIB_LIBRARY_DIRS "@PACKAGE_INSTALL_LIB_DIR@")
-endif()
-
-# --- Add required packages from uLib ---
-# TODO: this should be selected if components are active
-#
-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 filesystem REQUIRED)
-include_directories(${Boost_INCLUDE_DIRS})
-link_libraries(${Boost_LIBRARIES})
-
-find_package(Eigen3 CONFIG REQUIRED)
-include(${EIGEN3_USE_FILE})
-
-find_package(ROOT CONFIG REQUIRED)
-include(${ROOT_USE_FILE})
-
-find_package(VTK REQUIRED)
-# include(${VTK_USE_FILE})
-
-
-
-link_directories("${ULIB_LIBRARY_DIRS}")
-set(ULIB_LIBRARIES "@ULIB_SHARED_LIBRARIES@")
-check_required_components(uLib)
-
-# Set the variable to indicate that the package has been found.
-set(uLib_FOUND TRUE)
-
 
+# These are IMPORTED targets created by FooBarTargets.cmake
+set(ULIB_LIBRARIES @ULIB_SHARED_LIBRARIES@)