refactor: Update CMake build system and streamline Core object serialization and property handling.

fix mismatch Origin - Position

.gitignore

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

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "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/cmt-ulib.spec.in

@@ -1,116 +0,0 @@
-Summary: Cosmic Muon Tomography core libraries
-Name: cmt-ulib
-Version: @PKGVERSION@
-Release: @PKGRELEASE@%{?dist}
-License: EUROPEAN UNION PUBLIC LICENCE v. 1.2
-Vendor: INFN
-URL: https://github.com/OpenCMT/uLib
-Group: Development/Libraries
-BuildArch: %{_arch}
-%if %{?rhel}%{!?rhel:0} >= 8
-BuildRequires: cmake
-%else
-BuildRequires: cmake3
-%endif
-BuildRequires: doxygen
-BuildRequires: boost-devel
-BuildRequires: eigen3-devel
-BuildRequires: vtk-devel
-BuildRequires: readline-devel
-BuildRequires: pcl-devel
-BuildRequires: root-geom
-BuildRequires: root-genvector
-BuildRequires: root-smatrix
-BuildRequires: root-montecarlo-eg
-BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
-AutoReqProv: yes
-Source: %{name}-%{version}.tar.gz
-
-%description
-This package contains the base toolkit library for Cosmic Muon Tomography reconstruction,
-analysis and imaging software Developed by University of Padova and INFN Sezione di Padova  Italy
-
-%global _ulibpkgname mutom
-%global _ulibcmakedir %{_libdir}/cmake/%{_ulibpkgname}
-
-%prep
-%setup -c
-rm -rf %{buildroot}
-mkdir -p %{buildroot}
-
-%build
-mkdir %{_builddir}/%{name}-%{version}/build
-cd %{_builddir}/%{name}-%{version}/build
-%cmake -DCMAKE_INSTALL_PREFIX=%{buildroot}%{_prefix} \
-       -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-       -DPACKAGE_NAME=%{_ulibpkgname} \
-       -DPACKAGE_INSTALL_LIB_DIR=%{buildroot}%{_libdir} \
-       -DPACKAGE_INSTALL_INC_DIR=%{buildroot}%{_includedir}/%{_ulibpkgname} \
-       -DPACKAGE_INSTALL_CMAKE_DIR=%{buildroot}%{_ulibcmakedir} \
-       -DNODOXYGEN=ON \
-       %{_builddir}/%{name}-%{version}
-make %{?_smp_mflags}
-
-%install
-cd %{_builddir}/%{name}-%{version}/build
-make install
-sed -i 's|%{buildroot}/usr|%{_prefix}|g' %{buildroot}%{_ulibcmakedir}/uLibTargets.cmake
-sed -i 's|%{buildroot}/usr|%{_prefix}|g' %{buildroot}%{_ulibcmakedir}/uLibTargets-relwithdebinfo.cmake
-
-%clean
-rm -rf %{buildroot}
-
-%files
-%defattr(-,root,root)
-%{_libdir}/libmutom*.so.0.2
-%{_libdir}/uLibRootDict_rdict.pcm
-
-%package devel
-Summary: Cosmic Muon Tomography core libraries, development files
-Requires: %{name}
-Requires: boost-devel
-Requires: eigen3-devel
-Requires: vtk-devel
-Requires: readline-devel
-Requires: pcl-devel
-Requires: root-geom
-Requires: root-genvector
-Requires: root-smatrix
-Requires: root-montecarlo-eg
-
-
-%description devel
-This package contains the base toolkit library for Cosmic Muon Tomography reconstruction,
-analysis and imaging software Developed by University of Padova and INFN Sezione di Padova  Italy
-
-%files devel
-%defattr(-,root,root)
-%dir %{_ulibcmakedir}
-/usr/bin/uLib_config
-%{_libdir}/libmutom*.so
-%{_ulibcmakedir}/*.cmake
-%dir %{_includedir}/%{_ulibpkgname}
-%dir %{_includedir}/%{_ulibpkgname}/Core
-%dir %{_includedir}/%{_ulibpkgname}/Math
-%dir %{_includedir}/%{_ulibpkgname}/Root
-%dir %{_includedir}/%{_ulibpkgname}/Detectors
-%dir %{_includedir}/%{_ulibpkgname}/Vtk
-%{_includedir}/%{_ulibpkgname}/*.h
-%{_includedir}/%{_ulibpkgname}/Core/*.h
-%{_includedir}/%{_ulibpkgname}/Math/*.h
-%{_includedir}/%{_ulibpkgname}/Math/*.hpp
-%{_includedir}/%{_ulibpkgname}/Root/*.h
-%{_includedir}/%{_ulibpkgname}/Detectors/*.h
-%{_includedir}/%{_ulibpkgname}/Vtk/*.h
-
-
-
-
-
-
-
-
-%changelog
-* Tue Dec 04 2018 Paolo Andreetto <paolo.andreetto@pd.infn.it> - 0.2.1-1
-- Repackaging for CentOS 7
-

CMake/uLibCommon.cmake

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

CMake/uLibFindDependencies.cmake

@@ -13,7 +13,7 @@ set(Boost_USE_STATIC_LIBS OFF)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
 
-find_package(Boost 1.45.0 COMPONENTS serialization signals program_options REQUIRED)
+find_package(Boost 1.45.0 COMPONENTS program_options REQUIRED)
 if(Boost_FOUND)
  set(HAVE_BOOST true)
 endif(Boost_FOUND)

CMake/uLibGenerateRPMS.cmake

@@ -1,34 +0,0 @@
-# Target for RPMs creation
-
-set(PKGREL 1 CACHE STRING "Package build number")
-set(ITEMS_FOR_SOURCE AUTHORS
-                     CMakeConfig.in.h
-                     CMakePkgConfig.pc.in
-                     test.cpp
-                     uLibConfig.cmake.in
-                     uLib.creator
-                     ulib.h
-                     vtk_test.cpp
-                     CMake
-                     CMakeLists.txt
-                     Jenkinsfile
-                     src
-                     uLib.config
-                     uLibConfigVersion.cmake.in
-                     uLib.files
-                     uLib.includes)
-
-add_custom_target(rpm
-                  COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/rpmbuild/BUILD
-                                   ${CMAKE_CURRENT_BINARY_DIR}/rpmbuild/RPMS
-                                   ${CMAKE_CURRENT_BINARY_DIR}/rpmbuild/SOURCES
-                                   ${CMAKE_CURRENT_BINARY_DIR}/rpmbuild/SPECS
-                                   ${CMAKE_CURRENT_BINARY_DIR}/rpmbuild/SRPMS
-                  COMMAND tar -zcf ${CMAKE_CURRENT_BINARY_DIR}/rpmbuild/SOURCES/cmt-ulib-${PACKAGE_VERSION}.tar.gz ${ITEMS_FOR_SOURCE}
-                  COMMAND sed -e 's|@PKGVERSION@|${PACKAGE_VERSION}|g'
-                              -e 's|@PKGRELEASE@|${PKGREL}|g'
-                              CMake/cmt-ulib.spec.in > ${CMAKE_CURRENT_BINARY_DIR}/rpmbuild/SPECS/cmt-ulib.spec
-                  COMMAND QA_SKIP_BUILD_ROOT=1 rpmbuild -ba --define '_topdir ${CMAKE_CURRENT_BINARY_DIR}/rpmbuild'
-                          ${CMAKE_CURRENT_BINARY_DIR}/rpmbuild/SPECS/cmt-ulib.spec
-                  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-

CMake/uLibTargetMacros.cmake

@@ -41,15 +41,15 @@ macro(uLib_add_shared_library name)
 
   install(TARGETS ${mname}
          EXPORT "${PROJECT_NAME}Targets"
-         RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
+         RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
-         LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib
+         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib
-  #         PUBLIC_HEADER DESTINATION ${PACKAGE_INSTALL_INC_DIR} COMPONENT dev
+  #         PUBLIC_HEADER DESTINATION ${INSTALL_INC_DIR} COMPONENT dev
   )
  endif(SOURCES)
 
  if(HEADERS)
   foreach(header ${HEADERS})
-   install(FILES ${header} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/${name})
+   install(FILES ${header} DESTINATION ${INSTALL_INC_DIR}/${name})
   endforeach(header)
   endif(HEADERS)
 
@@ -70,7 +70,7 @@ macro(uLib_add_target name)
 
     install(TARGETS ${name}
             EXPORT "${PROJECT_NAME}Targets"
-            RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
+            RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
            )
 ENDMACRO(uLib_add_target)
 
@@ -82,7 +82,7 @@ ENDMACRO(uLib_add_target)
 # TESTS and LIBRARIES must be defined
 macro(uLib_add_tests name)
     foreach(tn ${TESTS})
-        add_executable(${tn} EXCLUDE_FROM_ALL ${tn}.cpp)
+        add_executable(${tn} ${tn}.cpp)
         add_test(NAME ${tn} COMMAND ${tn})
 
         target_link_libraries(${tn} ${LIBRARIES})

CMakeLists.txt

@@ -3,7 +3,7 @@
 ##### CMAKE LISTS ##############################################################
 ################################################################################
 
-cmake_minimum_required (VERSION 2.6)
+cmake_minimum_required (VERSION 3.26)
 
 ## -------------------------------------------------------------------------- ##
 
@@ -11,7 +11,7 @@ project(uLib)
 
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 2)
+set(PROJECT_VERSION_MINOR 6)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
@@ -26,130 +26,246 @@ set(PACKAGE_AUTHOR "Andrea Rigoni Garola <andrea.rigoni@pd.infn.it>")
 
 set(ULIB_CMAKE_DIR "${PROJECT_SOURCE_DIR}/CMake")
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMake" ${CMAKE_MODULE_PATH})
-message(STATUS "Module path: ${CMAKE_MODULE_PATH}")
+message(STATUS "Project name = ${PROJECT_NAME}")
-
+message(STATUS "Package name = ${PACKAGE_NAME}")
-include(uLibMacros)
+message(STATUS "Package version = ${PACKAGE_VERSION}")
-include(uLibDebugMacro)
+message(STATUS "Module path = ${CMAKE_MODULE_PATH}")
-include(uLibTargetMacros)
-#include(uLibGenerateRMake)
-
 
 ## GLOBALS ------------------------------------------------------------------ ##
 
-include(uLibCommon)
+# -- move to GnuInstallDirs
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ") ## Add flags here ##
+# ref: https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+include(GNUInstallDirs)
+set(INSTALL_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of header files (.../include)" )
+set(INSTALL_ETC_DIR ${CMAKE_INSTALL_SYSCONFDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of configuration files (.../etc)" )
+set(INSTALL_BIN_DIR ${CMAKE_INSTALL_BINDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of executable files (.../bin)" )
+set(INSTALL_LIB_DIR ${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "Location of library files (.../lib)" )
+set(INSTALL_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PACKAGE_NAME}
+    CACHE PATH "Location of cmake files (.../lib/cmake)" )   
+set(INSTALL_DATA_DIR ${CMAKE_INSTALL_DATADIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of data files (.../share)" )
 
+
+
+
+set(SRC_DIR ${PROJECT_SOURCE_DIR}/src)
+
+# this is used to be exported in build target 
+# ( to compile against build directory instead of install )
+set(ULIB_SOURCE_DIR ${PROJECT_SOURCE_DIR})
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    message(STATUS "Setting build type to 'Release' as none was specified.")
+    set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
+    set(CMAKE_EXE_LINKER_FLAGS "-Wl,--no-as-needed")
+    # Set the possible values of build type for cmake-gui
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY 
+               STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+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} ${CMAKE_CXX_WARNING_OPTION}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
+
+# CTEST framework
+include(CTest)
 enable_testing()
 
+
 ## FIND PACKAGES ------------------------------------------------------------ ##
 
-include(uLibFindDependencies)
+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 serialization unit_test_framework REQUIRED)
+include_directories(${Boost_INCLUDE_DIRS})
 
+find_package(Eigen3 CONFIG REQUIRED)
+get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+include_directories(${EIGEN3_INCLUDE_DIRS})
+
+find_package(ROOT CONFIG REQUIRED)
+include(${ROOT_USE_FILE})
+
+find_package(VTK REQUIRED)
+# 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)
 
 ## CONFIG ------------------------------------------------------------------- ##
 
-include(uLibConfigHeader)
+set(BOOST_PP_VARIADICS ON)
+
+include(CheckIncludeFiles)
+include(CheckFunctionExists)
+include(CheckSymbolExists)
+
+CHECK_INCLUDE_FILES(inittypes.h HAVE_INITTYPES_H)
+CHECK_INCLUDE_FILES(stdbool.h HAVE_STDBOOL_H)
+CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H)
+CHECK_INCLUDE_FILES(stdlib.h HAVE_STDLIB_H)
+CHECK_INCLUDE_FILES(dlfcn.h HAVE_DLFCN_H)
+CHECK_INCLUDE_FILES(malloc.h HAVE_MALLOC_H)
+CHECK_FUNCTION_EXISTS(malloc HAVE_MALLOC)
+CHECK_INCLUDE_FILES(memory.h HAVE_MEMORY_H)
+CHECK_INCLUDE_FILES(math.h HAVE_MATH_H)
+CHECK_FUNCTION_EXISTS(fsetround HAVE_FSETROUND)
+CHECK_FUNCTION_EXISTS(floor HAVE_FLOOR)
+CHECK_FUNCTION_EXISTS(pow HAVE_POW)
+CHECK_FUNCTION_EXISTS(sqrt HAVE_SQRT)
+CHECK_FUNCTION_EXISTS(strdup HAVE_STRDUP)
+CHECK_FUNCTION_EXISTS(strstr HAVE_STRSTR)
+CHECK_INCLUDE_FILES(strings.h HAVE_STRINGS_H)
+CHECK_INCLUDE_FILES(string.h HAVE_STRING_H)
+CHECK_INCLUDE_FILES(sys/stat.h HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILES(sys/types.h HAVE_SYS_TYPES_H)
+CHECK_INCLUDE_FILES(unistd.h HAVE_UNISTD_H)
+CHECK_INCLUDE_FILES(assert.h HAVE_ASSERT_H)
+
+configure_file("${PROJECT_SOURCE_DIR}/CMakeConfig.in.h"
+               "${PROJECT_BINARY_DIR}/config.h")
+
+install(FILES "${PROJECT_BINARY_DIR}/config.h"
+        DESTINATION ${INSTALL_INC_DIR})
 
 ## ADD LIBRARIES SUBDIRECTORIES --------------------------------------------- ##
 
-## select modules ##
+include_directories(${PROJECT_BINARY_DIR})
-set(ULIB_SELECTED_MODULES
+include_directories(${SRC_DIR})
-      Core
-      Math
-      Detectors
-      Root
-)
 
 ## uLib_add_shared_library puts names there
 set(ULIB_SHARED_LIBRARIES)
+## select modules ##
+set(ULIB_SELECTED_MODULES)
 
-if(ULIB_USE_VTK)
+include_directories(${SRC_DIR}/Core)
- LIST(APPEND ULIB_SELECTED_MODULES Vtk)
+add_subdirectory(${SRC_DIR}/Core)
-endif(ULIB_USE_VTK)
+
+include_directories(${SRC_DIR}/Math)
+add_subdirectory(${SRC_DIR}/Math)
+
+include_directories(${SRC_DIR}/Detectors)
+add_subdirectory(${SRC_DIR}/Detectors)
+
+include_directories(${SRC_DIR}/Root)
+add_subdirectory(${SRC_DIR}/Root)
+
+include_directories(${SRC_DIR}/Vtk)
+add_subdirectory(${SRC_DIR}/Vtk)
+
+#add_subdirectory("${SRC_DIR}/utils/make_recipe")
 
 ## Documentation and packages
 
-include(uLibGenerateRPMS)
+#include(uLibGenerateDoc)
-include(uLibGenerateDoc)
-
-## this gets ulib modules into a variable ##
-function(uLib_modules result)
- set(out)
- foreach(module ${ULIB_SELECTED_MODULES})
-  list(APPEND out ${PACKAGE_LIBPREFIX}${module})
- endforeach(module)
- set(${result} "${out}" PARENT_SCOPE)
-endfunction()
-
-
-## ENTERING MODULES SUBDIRECTORIES ##
-message("/////////// SELECTED MODULES //////////////")
-foreach(module ${ULIB_SELECTED_MODULES})
- message(STATUS "adding module: ${module}")
- set( uLib-module ${module})
- include_directories(${SRC_DIR}/${module})
- add_subdirectory(${SRC_DIR}/${module})
-endforeach(module)
 
 ## UTILITIES ##
-add_subdirectory("${SRC_DIR}/utils/make_recipe")
+#add_subdirectory("${SRC_DIR}/utils/make_recipe")
 
 
 ## INSTALLS AND EXPORTS ----------------------------------------------------- ##
 
-#export(PACKAGE uLib)
+#export(PACKAGE ULIB)
-export(PACKAGE ULIB)
+#export(TARGETS ${ULIB_SHARED_LIBRARIES} ${ULIB_EXPORTED_TARGETS}
-export(TARGETS ${ULIB_SHARED_LIBRARIES} ${ULIB_EXPORTED_TARGETS}
+#       FILE "${PROJECT_BINARY_DIR}/uLibTargets.cmake"    )
-       FILE "${PROJECT_BINARY_DIR}/uLibTargets.cmake"    )
-#export(TARGETS ${ULIB_EXPORTED_TARGETS}
-#       FILE "${PROJECT_BINARY_DIR}/uLibExeTargets.cmake" )
 
 
 # Create the FooBarConfig.cmake and FooBarConfigVersion files
-file(RELATIVE_PATH REL_INCLUDE_DIR "${PACKAGE_INSTALL_CMAKE_DIR}"
+# file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}"
-   "${PACKAGE_INSTALL_INC_DIR}")
+#    "${INSTALL_INC_DIR}")
+
 # ... for the build tree
-set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}")
+#set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}")
-configure_file(uLibConfig.cmake.in
+#configure_file(uLibConfig.cmake.in 
-  "${PROJECT_BINARY_DIR}/uLibConfig.cmake" @ONLY)
+#               "${PROJECT_BINARY_DIR}/uLibConfig.cmake" @ONLY)
+
 # ... for the install tree
 set(CONF_INCLUDE_DIRS "\${ULIB_CMAKE_DIR}/${REL_INCLUDE_DIR}")
-configure_file(uLibConfig.cmake.in
+# [ removed for the configure_config_file ]
-  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake" @ONLY)
+# configure_file(uLibConfig.cmake.in
+#                "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+#                @ONLY)
+
 # ... for both
 configure_file(uLibConfigVersion.cmake.in
                 "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake" @ONLY)
 
-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"
-              "${PROJECT_SOURCE_DIR}/CMake/FindReadLine.cmake"
+        DESTINATION "${INSTALL_CMAKE_DIR}"
-              "${PROJECT_SOURCE_DIR}/CMake/FindROOT.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/FindROOTv6.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/uLibCommon.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/uLibConfigHeader.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/uLibDebugMacro.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/uLibFindDependencies.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/uLibGenerateDoc.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/uLibGenerateRMake.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/uLibGenerateRPMS.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/uLibMacros.cmake"
-              "${PROJECT_SOURCE_DIR}/CMake/uLibTargetMacros.cmake"
-        DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}"
         COMPONENT dev)
 
-# Install the export set for use with the install-tree
-install(EXPORT "${PROJECT_NAME}Targets" DESTINATION
-  "${PACKAGE_INSTALL_CMAKE_DIR}" COMPONENT dev)
 
-install(FILES ${PROJECT_SOURCE_DIR}/ulib.h DESTINATION ${PACKAGE_INSTALL_INC_DIR})
+# 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 )
-# TODO clean also subdirectories
+export (TARGETS ${ULIB_SHARED_LIBRARIES}
-add_custom_target(clean-cmake-files
+        FILE "${PROJECT_BINARY_DIR}/uLibTargets-build.cmake"
-   COMMAND ${CMAKE_COMMAND} -P ${ULIB_CMAKE_DIR}/clean-all.cmake
+        # NAMESPACE "uLib::"
 )        
 
-
+# Install the export set for use with the install-tree
-
+install(EXPORT "uLibTargets"
-
+        FILE "uLibTargets.cmake"
+        DESTINATION "${INSTALL_CMAKE_DIR}"
+        COMPONENT dev)
 

CMakeUserPresets.json

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

README.md

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

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

conanfile.txt

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

condaenv.yml

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

src/Core/Archives.h

@@ -23,14 +23,12 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_ARCHIVES_H
 #define U_CORE_ARCHIVES_H
 
-
 #include <boost/archive/detail/basic_pointer_iserializer.hpp>
 #include <boost/archive/detail/basic_pointer_oserializer.hpp>
+#include <iostream>
 
 #include <boost/archive/text_iarchive.hpp>
 #include <boost/archive/text_oarchive.hpp>
@@ -40,25 +38,20 @@
 
 #include <boost/archive/detail/register_archive.hpp>
 
-#include <boost/archive/polymorphic_iarchive.hpp>
-#include <boost/archive/polymorphic_oarchive.hpp>
 #include <boost/archive/detail/polymorphic_iarchive_route.hpp>
 #include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+#include <boost/archive/polymorphic_iarchive.hpp>
+#include <boost/archive/polymorphic_oarchive.hpp>
 
 #include <boost/archive/polymorphic_text_oarchive.hpp>
 
 #include "StringReader.h"
 
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // FWD DECLARATIONS OF ARCHIVES //
 
-
-
-
 namespace uLib {
 namespace Archive {
 
@@ -68,40 +61,36 @@ class text_iarchive;
 class text_oarchive;
 class log_archive;
 
-
+} // namespace Archive
-}
+} // namespace uLib
-}
-
 
 namespace boost {
 namespace archive {
 namespace detail {
-template<class ArchiveImplementation> class polymorphic_oarchive_route;
+template <class ArchiveImplementation> class polymorphic_oarchive_route;
-template<class ArchiveImplementation> class polymorphic_iarchive_route;
+template <class ArchiveImplementation> class polymorphic_iarchive_route;
-}
+} // namespace detail
-}
+} // namespace archive
-}
+} // namespace boost
 
 namespace boost {
 namespace serialization {
-    template <typename T> struct hrp;
+template <typename T> struct hrp;
 }
-}
+} // namespace boost
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // ARCHIVES REGISTRATION //
 
-
 namespace uLib {
 namespace Archive {
 namespace detail {
 struct adl_tag {};
-}
+} // namespace detail
-}
+} // namespace Archive
-}
+} // namespace uLib
 
 namespace boost {
 namespace archive {
@@ -110,34 +99,36 @@ namespace detail {
 // in overload resolution with the functions declared by
 // BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
 template <class Serializable>
-void instantiate_ptr_serialization(Serializable*, int, uLib::Archive::detail::adl_tag ) {}
+void instantiate_ptr_serialization(Serializable *, int,
-}
+                                   uLib::Archive::detail::adl_tag) {}
-}
+} // namespace detail
-}
+} // namespace archive
+} // namespace boost
 
 // The function declaration generated by this macro never actually
 // gets called, but its return type gets instantiated, and that's
 // enough to cause registration of serialization functions between
 // Archive and any exported Serializable type.  See also:
 // boost/serialization/export.hpp
-# define ULIB_SERIALIZATION_REGISTER_ARCHIVE(_Archive)                  \
+#define ULIB_SERIALIZATION_REGISTER_ARCHIVE(_Archive)                          \
-namespace boost { namespace archive { namespace detail {                \
+  namespace boost {                                                            \
+  namespace archive {                                                          \
+  namespace detail {                                                           \
                                                                                \
-template <class Serializable>                                           \
+  template <class Serializable>                                                \
-BOOST_DEDUCED_TYPENAME _ptr_serialization_support<_Archive, Serializable>::type  \
+  BOOST_DEDUCED_TYPENAME                                                       \
-instantiate_ptr_serialization( Serializable*, _Archive*, uLib::Archive::detail::adl_tag ); }}}
+      _ptr_serialization_support<_Archive, Serializable>::type                 \
-
+      instantiate_ptr_serialization(Serializable *, _Archive *,                \
-
+                                    uLib::Archive::detail::adl_tag);           \
-
+  }                                                                            \
-
+  }                                                                            \
-
+  }
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // ARCHIVES IO INTERFACES //
 
-
 namespace boost {
 namespace archive {
 namespace detail {
@@ -145,11 +136,10 @@ namespace detail {
 /**
  * Custom implementation of boost interface_iarchive to add new operators
  */
-template<class Archive>
+template <class Archive> class uLib_interface_iarchive {
-class uLib_interface_iarchive
-{
 protected:
-    uLib_interface_iarchive(){};
+  uLib_interface_iarchive() {};
+
 public:
   /////////////////////////////////////////////////////////
   // archive public interface
@@ -157,54 +147,40 @@ public:
   typedef mpl::bool_<false> is_saving;
 
   // return a pointer to the most derived class
-    Archive * This(){
+  Archive *This() { return static_cast<Archive *>(this); }
-        return static_cast<Archive *>(this);
-    }
 
-    template<class T>
+  template <class T>
-    const basic_pointer_iserializer *
+  const basic_pointer_iserializer *register_type(T * = NULL) {
-    register_type(T * = NULL){
+    const basic_pointer_iserializer &bpis = boost::serialization::singleton<
-        const basic_pointer_iserializer & bpis =
+        pointer_iserializer<Archive, T>>::get_const_instance();
-            boost::serialization::singleton<
-                pointer_iserializer<Archive, T>
-            >::get_const_instance();
     this->This()->register_basic_serializer(bpis.get_basic_serializer());
-        return & bpis;
+    return &bpis;
   }
-    template<class T>
+  template <class T> Archive &operator>>(T &t) {
-    Archive & operator>>(T & t){
+    this->This()->load_override(t);
-        this->This()->load_override(t, 0);
+    return *this->This();
-        return * this->This();
   }
 
   // the & operator
-    template<class T>
+  template <class T> Archive &operator&(T &t) { return *(this->This()) >> t; }
-    Archive & operator&(T & t){
-        return *(this->This()) >> t;
-    }
 
   // the == operator
-    template <class T>
+  template <class T> Archive &operator==(T &t) { return this->operator&(t); }
-    Archive & operator == (T & t) {
-        return this->operator &(t);
-    }
 
   // the != operator for human readable access
-    template <class T>
+  template <class T> Archive &operator!=(T &t) {
-    Archive & operator != (T & t) {
     std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
-        return * this->This();
+    return *this->This();
   }
 };
 
-
 /**
  * Custom implementation of boost interface_oarchive to add new operators
  */
-template <class Archive>
+template <class Archive> class uLib_interface_oarchive {
-class uLib_interface_oarchive {
 protected:
-    uLib_interface_oarchive(){};
+  uLib_interface_oarchive() {};
+
 public:
   /////////////////////////////////////////////////////////
   // archive public interface
@@ -212,109 +188,82 @@ public:
   typedef mpl::bool_<true> is_saving;
 
   // return a pointer to the most derived class
-    Archive * This(){
+  Archive *This() { return static_cast<Archive *>(this); }
-        return static_cast<Archive *>(this);
-    }
 
-    template<class T>
+  template <class T>
-    const basic_pointer_oserializer *
+  const basic_pointer_oserializer *register_type(const T * = NULL) {
-    register_type(const T * = NULL){
+    const basic_pointer_oserializer &bpos = boost::serialization::singleton<
-        const basic_pointer_oserializer & bpos =
+        pointer_oserializer<Archive, T>>::get_const_instance();
-            boost::serialization::singleton<
-                pointer_oserializer<Archive, T>
-            >::get_const_instance();
     this->This()->register_basic_serializer(bpos.get_basic_serializer());
-        return & bpos;
+    return &bpos;
   }
 
-    template<class T>
+  template <class T> Archive &operator<<(T &t) {
-    Archive & operator<<(T & t){
     // to get access you must redefine save_override by typing
     // "using save_override" in archive impl
-        this->This()->save_override(t, 0);
+    this->This()->save_override(t);
-        return * this->This();
+    return *this->This();
   }
 
   // the & operator
-    template<class T>
+  template <class T> Archive &operator&(T &t) {
-    Archive & operator&(T & t){
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    return *this->This() << const_cast<const T &>(t);
-            return * this->This() << const_cast<const T &>(t);
+#else
-        #else
+    return *this->This() << t;
-            return * this->This() << t;
+#endif
-        #endif
   }
 
   // the == operator
-    template <class T>
+  template <class T> Archive &operator==(T &t) { return this->operator&(t); }
-    Archive & operator == (T & t) {
-        return this->operator &(t);
-    }
 
   // the != operator for human readable access
-    template <class T>
+  template <class T> Archive &operator!=(T &t) {
-    Archive & operator != (T & t) {
     std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
-        return * this->This();
+    return *this->This();
   }
 };
 
-
-
 // DECLARE INTERFACE SPECIALIZATIONS ///////////////////////////////////////////
 // With this declarations all uLib archive Implementation will use their own
 // extended interface //
 
 template <>
-class interface_iarchive        <uLib::Archive::xml_iarchive> : public
+class interface_iarchive<uLib::Archive::xml_iarchive>
-        uLib_interface_iarchive <uLib::Archive::xml_iarchive> {};
+    : public uLib_interface_iarchive<uLib::Archive::xml_iarchive> {};
 
 template <>
-class interface_oarchive        <uLib::Archive::xml_oarchive> : public
+class interface_oarchive<uLib::Archive::xml_oarchive>
-        uLib_interface_oarchive <uLib::Archive::xml_oarchive> {};
+    : public uLib_interface_oarchive<uLib::Archive::xml_oarchive> {};
 
 template <>
-class interface_iarchive        <uLib::Archive::text_iarchive> : public
+class interface_iarchive<uLib::Archive::text_iarchive>
-        uLib_interface_iarchive <uLib::Archive::text_iarchive> {};
+    : public uLib_interface_iarchive<uLib::Archive::text_iarchive> {};
 
 template <>
-class interface_oarchive        <uLib::Archive::text_oarchive> : public
+class interface_oarchive<uLib::Archive::text_oarchive>
-        uLib_interface_oarchive <uLib::Archive::text_oarchive> {};
+    : public uLib_interface_oarchive<uLib::Archive::text_oarchive> {};
 
 template <>
-class interface_oarchive        <uLib::Archive::log_archive> : public
+class interface_oarchive<uLib::Archive::log_archive>
-        uLib_interface_oarchive <uLib::Archive::log_archive> {};
+    : public uLib_interface_oarchive<uLib::Archive::log_archive> {};
-
 
 //// Veritical repetition macro // FINIRE !!!!!!!!!!!!!!!!!!!!!!!!!
-//#define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata)           \
+// #define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata)           \
 //     template <class TypeSeq>                             \
 //     struct inherit_nofold<TypeSeq,BOOST_PP_INC(vn)> :    \
 //     BOOST_PP_REPEAT(BOOST_PP_INC(vn),_INERIT_NOFOLD_H,~) \
 //     {};
 
 //// Multiple size declaration //
-//BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)
+// BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)
-
-//#undef  _INERIT_NOFOLD_H
-//#undef  _INERIT_NOFOLD_V
-
-
-} // detail
-} // archive
-} // boost
-
-
-
-
-
-
-
-
-
-
 
+// #undef  _INERIT_NOFOLD_H
+// #undef  _INERIT_NOFOLD_V
 
+} // namespace detail
+} // namespace archive
+} // namespace boost
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -330,14 +279,14 @@ class interface_oarchive        <uLib::Archive::log_archive> : public
 namespace boost {
 namespace archive {
 
-//template<class Archive>
+// template<class Archive>
-//inline void load_const_override(Archive & ar, const char *t ){
+// inline void load_const_override(Archive & ar, const char *t ){
-//    typedef typename mpl::identity<detail::load_non_pointer_type<Archive> >::type typex;
+//     typedef typename mpl::identity<detail::load_non_pointer_type<Archive>
-//    typex::invoke(ar, t);
+//     >::type typex; typex::invoke(ar, t);
-//}
+// }
 
-//template<class Archive, class T>
+// template<class Archive, class T>
-//inline void load(Archive & ar, T &t){
+// inline void load(Archive & ar, T &t){
 //     // if this assertion trips. It means we're trying to load a
 //     // const object with a compiler that doesn't have correct
 //     // funtion template ordering.  On other compilers, this is
@@ -358,47 +307,38 @@ namespace archive {
 //         >
 //         >::type typex;
 //     typex::invoke(ar, t);
-//}
+// }
-
-
-
-}
-}
-
-
 
+} // namespace archive
+} // namespace boost
 
 namespace uLib {
 
 namespace Archive {
 
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // POLYMORPHIC //
 
-
+// class polymorphic_iarchive :
-//class polymorphic_iarchive :
 //         public boost::archive::polymorphic_iarchive {
 
-//public:
+// public:
 //     void load_override(const char *t, BOOST_PFTO int)
 //     {
-//        boost::archive::load_const_override(* this->This(), const_cast<char*>(t));
+//         boost::archive::load_const_override(* this->This(),
+//         const_cast<char*>(t));
 //     }
 
 //};
 
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // XML //
 
-class xml_iarchive :
+class xml_iarchive : public boost::archive::xml_iarchive_impl<xml_iarchive> {
-    public boost::archive::xml_iarchive_impl<xml_iarchive>
-{
   typedef xml_iarchive Archive;
   typedef boost::archive::xml_iarchive_impl<Archive> base;
 
@@ -406,75 +346,63 @@ class xml_iarchive :
   friend class boost::archive::detail::interface_iarchive<Archive>;
   friend class boost::archive::basic_xml_iarchive<Archive>;
   friend class boost::archive::load_access;
+
 public:
-    xml_iarchive(std::istream & is, unsigned int flags = 0) :
+  xml_iarchive(std::istream &is, unsigned int flags = 0)
-        xml_iarchive_impl<xml_iarchive>(is, flags)
+      : xml_iarchive_impl<xml_iarchive>(is, flags) {}
-    {}
 
   using basic_xml_iarchive::load_override;
 
   // Anything not an attribute should be a name value pair as nvp or hrp
-    typedef boost::archive::detail::common_iarchive<Archive> detail_common_iarchive;
+  typedef boost::archive::detail::common_iarchive<Archive>
-    template<class T>
+      detail_common_iarchive;
+  template <class T>
   void load_override(
-        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
       const
-        #endif
+#endif
-        boost::serialization::hrp< T > & t,
+      boost::serialization::hrp<T> &t) {
-        int v
-    ){
     this->This()->load_start(t.name());
-        this->detail_common_iarchive::load_override(t.value(), 0);
+    this->detail_common_iarchive::load_override(t.value());
-//        t.stov();
+    //        t.stov();
     this->This()->load_end(t.name());
   }
 
-
   // class_name_type can't be handled here as it depends upon the
   // char type used by the stream.  So require the derived implementation.
   // derived in this case is xml_iarchive_impl or base ..
   using base::load_override;
 
-    void load_override(const char *str, int v) {
+  void load_override(const char *str) {
     //        StringReader sr(basic_text_iprimitive::is);
     //        sr >> str;
   }
 
-    ~xml_iarchive(){};
+  ~xml_iarchive() {};
 };
 
-//typedef boost::archive::detail::polymorphic_iarchive_route<
+// typedef boost::archive::detail::polymorphic_iarchive_route<
-//boost::archive::xml_iarchive_impl<xml_iarchive>
+// boost::archive::xml_iarchive_impl<xml_iarchive>
 //> polymorphic_xml_iarchive;
 
 template <class ArchiveImpl>
-struct polymorphic_iarchive_route :
+struct polymorphic_iarchive_route
-        boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl>
+    : boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl> {
-{
+  virtual void load(const char *t) { ArchiveImpl::load(t); }
-    virtual void load(const char * t){
-        ArchiveImpl::load(t);
-    }
 };
 
-
+class polymorphic_xml_iarchive
-class polymorphic_xml_iarchive :
+    : public polymorphic_iarchive_route<
-        public  polymorphic_iarchive_route< boost::archive::xml_iarchive_impl<xml_iarchive> >
+          boost::archive::xml_iarchive_impl<xml_iarchive>> {
-{
   // give serialization implementation access to this class
-//    friend class boost::archive::detail::interface_iarchive<Archive>;
+  //    friend class boost::archive::detail::interface_iarchive<Archive>;
-//    friend class boost::archive::basic_xml_iarchive<Archive>;
+  //    friend class boost::archive::basic_xml_iarchive<Archive>;
-//    friend class boost::archive::load_access;
+  //    friend class boost::archive::load_access;
 public:
-    virtual void load_override(const char *str, int v) {
+  virtual void load_override(const char *str) { ; }
-        ;
-    }
 };
 
-
+class xml_oarchive : public boost::archive::xml_oarchive_impl<xml_oarchive> {
-
-class xml_oarchive :
-    public boost::archive::xml_oarchive_impl<xml_oarchive>
-{
   typedef xml_oarchive Archive;
   typedef boost::archive::xml_oarchive_impl<Archive> base;
 
@@ -482,10 +410,10 @@ class xml_oarchive :
   friend class boost::archive::detail::interface_oarchive<Archive>;
   friend class boost::archive::basic_xml_oarchive<Archive>;
   friend class boost::archive::save_access;
+
 public:
-    xml_oarchive(std::ostream & os, unsigned int flags = 0) :
+  xml_oarchive(std::ostream &os, unsigned int flags = 0)
-        boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags)
+      : boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags) {}
-    {}
 
   // example of implementing save_override for const char* //
   //    void save_override(const char *t, int) {
@@ -495,31 +423,30 @@ public:
   using basic_xml_oarchive::save_override;
 
   // special treatment for name-value pairs.
-    typedef boost::archive::detail::common_oarchive<Archive> detail_common_oarchive;
+  typedef boost::archive::detail::common_oarchive<Archive>
-    template<class T>
+      detail_common_oarchive;
+  template <class T>
   void save_override(
-        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
       const
-        #endif
+#endif
-        ::boost::serialization::hrp< T > & t,
+      ::boost::serialization::hrp<T> &t) {
-        int v
-    ){
     this->This()->save_start(t.name());
-//        t.vtos();
+    //        t.vtos();
-//        this->detail_common_oarchive::save_override(t.const_value(), 0);
+    //        this->detail_common_oarchive::save_override(t.const_value());
     this->This()->save_end(t.name());
   }
 
-    void save_override(const char *str, int v) {
+  void save_override(const char *str) {
     // Do not save any human decoration string //
     //        basic_text_oprimitive::save(str);
   }
 
-    ~xml_oarchive(){}
+  ~xml_oarchive() {}
 };
 
-//typedef boost::archive::detail::polymorphic_oarchive_route<
+// typedef boost::archive::detail::polymorphic_oarchive_route<
-//boost::archive::xml_oarchive_impl<xml_oarchive>
+// boost::archive::xml_oarchive_impl<xml_oarchive>
 //> polymorphic_xml_oarchive;
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -527,9 +454,7 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 // TEXT //
 
-class text_iarchive :
+class text_iarchive : public boost::archive::text_iarchive_impl<text_iarchive> {
-    public boost::archive::text_iarchive_impl<text_iarchive>
-{
   typedef text_iarchive Archive;
   typedef boost::archive::text_iarchive_impl<Archive> base;
 
@@ -537,21 +462,21 @@ class text_iarchive :
   friend class boost::archive::detail::interface_iarchive<Archive>;
   friend class boost::archive::basic_text_iarchive<Archive>;
   friend class boost::archive::load_access;
+
 public:
-    text_iarchive(std::istream & is, unsigned int flags = 0) :
+  text_iarchive(std::istream &is, unsigned int flags = 0)
-        text_iarchive_impl<Archive>(is, flags)
+      : text_iarchive_impl<Archive>(is, flags) {}
-    {}
 
   using basic_text_iarchive::load_override;
 
-    void load_override(boost::archive::object_id_type & t, int)               {}
+  void load_override(boost::archive::object_id_type &t) {}
 
   // class_name_type can't be handled here as it depends upon the
   // char type used by the stream.  So require the derived implementation.
   // derived in this case is xml_iarchive_impl or base ..
   using base::load_override;
 
-    void load_override(const char *str, int v) {
+  void load_override(const char *str) {
     StringReader sr(basic_text_iprimitive::is);
     sr >> str;
   }
@@ -561,15 +486,11 @@ public:
 
 typedef text_iarchive naked_text_iarchive;
 
-//typedef boost::archive::detail::polymorphic_iarchive_route<
+// typedef boost::archive::detail::polymorphic_iarchive_route<
-//naked_text_iarchive
+// naked_text_iarchive
 //> polymorphic_text_iarchive;
 
-
+class text_oarchive : public boost::archive::text_oarchive_impl<text_oarchive> {
-
-class text_oarchive :
-    public boost::archive::text_oarchive_impl<text_oarchive>
-{
   typedef text_oarchive Archive;
   typedef boost::archive::text_oarchive_impl<Archive> base;
 
@@ -577,33 +498,28 @@ class text_oarchive :
   friend class boost::archive::detail::interface_oarchive<Archive>;
   friend class boost::archive::basic_text_oarchive<Archive>;
   friend class boost::archive::save_access;
+
 public:
-    text_oarchive(std::ostream & os, unsigned int flags = 0) :
+  text_oarchive(std::ostream &os, unsigned int flags = 0)
-        boost::archive::text_oarchive_impl<Archive>(os, flags)
+      : boost::archive::text_oarchive_impl<Archive>(os, flags) {}
-    {}
 
   using basic_text_oarchive::save_override;
 
-    void save_override(const char *str, int v) {
+  void save_override(const char *str) { basic_text_oprimitive::save(str); }
-        basic_text_oprimitive::save(str);
-    }
 
-    ~text_oarchive(){}
+  ~text_oarchive() {}
 };
 
-//typedef boost::archive::detail::polymorphic_oarchive_route<
+// typedef boost::archive::detail::polymorphic_oarchive_route<
-//boost::archive::text_oarchive_impl<text_oarchive>
+// boost::archive::text_oarchive_impl<text_oarchive>
 //> polymorphic_text_oarchive;
 
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // SIMPLE HUMAN READABLE TEXT //
 
-class hrt_iarchive :
+class hrt_iarchive : public boost::archive::text_iarchive_impl<hrt_iarchive> {
-    public boost::archive::text_iarchive_impl<hrt_iarchive>
-{
   typedef hrt_iarchive Archive;
   typedef boost::archive::text_iarchive_impl<Archive> base;
 
@@ -611,29 +527,29 @@ class hrt_iarchive :
   friend class boost::archive::detail::interface_iarchive<Archive>;
   friend class boost::archive::basic_text_iarchive<Archive>;
   friend class boost::archive::load_access;
+
 public:
-    hrt_iarchive(std::istream & is, unsigned int flags = 0) :
+  hrt_iarchive(std::istream &is, unsigned int flags = 0)
-        base(is, flags | boost::archive::no_header )
+      : base(is, flags | boost::archive::no_header) {}
-    {}
 
   using basic_text_iarchive::load_override;
 
   // hide all archive props //
-    void load_override( boost::archive::object_id_type & t, int)         {}
+  void load_override(boost::archive::object_id_type &t) {}
-    void load_override( boost::archive::object_reference_type & t, int)  {}
+  void load_override(boost::archive::object_reference_type &t) {}
-    void load_override( boost::archive::version_type & t, int)           {}
+  void load_override(boost::archive::version_type &t) {}
-    void load_override( boost::archive::class_id_type & t, int)          {}
+  void load_override(boost::archive::class_id_type &t) {}
-    void load_override( boost::archive::class_id_optional_type & t, int) {}
+  void load_override(boost::archive::class_id_optional_type &t) {}
-    void load_override( boost::archive::class_id_reference_type & t, int){}
+  void load_override(boost::archive::class_id_reference_type &t) {}
-    void load_override( boost::archive::class_name_type & t, int)        {}
+  void load_override(boost::archive::class_name_type &t) {}
-    void load_override( boost::archive::tracking_type & t, int)          {}
+  void load_override(boost::archive::tracking_type &t) {}
 
   // class_name_type can't be handled here as it depends upon the
   // char type used by the stream.  So require the derived implementation.
   // derived in this case is xml_iarchive_impl or base ..
   using base::load_override;
 
-    void load_override(const char *str, int v) {
+  void load_override(const char *str) {
     StringReader sr(basic_text_iprimitive::is);
     sr >> str;
   }
@@ -641,10 +557,7 @@ public:
   ~hrt_iarchive() {};
 };
 
-
+class hrt_oarchive : public boost::archive::text_oarchive_impl<hrt_oarchive> {
-class hrt_oarchive :
-        public boost::archive::text_oarchive_impl<hrt_oarchive>
-    {
   typedef hrt_oarchive Archive;
   typedef boost::archive::text_oarchive_impl<Archive> base;
 
@@ -652,32 +565,26 @@ class hrt_oarchive :
   friend class boost::archive::detail::interface_oarchive<Archive>;
   friend class boost::archive::basic_text_oarchive<Archive>;
   friend class boost::archive::save_access;
-    public:
+
-        hrt_oarchive(std::ostream & os, unsigned int flags = 0) :
+public:
-            base(os, flags | boost::archive::no_header )
+  hrt_oarchive(std::ostream &os, unsigned int flags = 0)
-        {}
+      : base(os, flags | boost::archive::no_header) {}
 
   using basic_text_oarchive::save_override;
 
-        void save_override(const boost::archive::object_id_type & t, int)         {}
+  void save_override(const boost::archive::object_id_type &t) {}
-        void save_override(const boost::archive::object_reference_type & t, int)  {}
+  void save_override(const boost::archive::object_reference_type &t) {}
-        void save_override(const boost::archive::version_type & t, int)           {}
+  void save_override(const boost::archive::version_type &t) {}
-        void save_override(const boost::archive::class_id_type & t, int)          {}
+  void save_override(const boost::archive::class_id_type &t) {}
-        void save_override(const boost::archive::class_id_optional_type & t, int) {}
+  void save_override(const boost::archive::class_id_optional_type &t) {}
-        void save_override(const boost::archive::class_id_reference_type & t, int){}
+  void save_override(const boost::archive::class_id_reference_type &t) {}
-        void save_override(const boost::archive::class_name_type & t, int)        {}
+  void save_override(const boost::archive::class_name_type &t) {}
-        void save_override(const boost::archive::tracking_type & t, int)          {}
+  void save_override(const boost::archive::tracking_type &t) {}
-
-
-        void save_override(const char *str, int v) {
-            basic_text_oprimitive::save(str);
-        }
-
-        ~hrt_oarchive(){}
-    };
-
 
+  void save_override(const char *str) { basic_text_oprimitive::save(str); }
 
+  ~hrt_oarchive() {}
+};
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -690,8 +597,7 @@ class hrt_oarchive :
 // any serializable class.  Intended to be useful as a debugging aid.
 class log_archive :
     /* protected ? */
-    public boost::archive::xml_oarchive_impl<log_archive>
+    public boost::archive::xml_oarchive_impl<log_archive> {
-{
   typedef boost::archive::xml_oarchive_impl<log_archive> base;
   typedef log_archive Archive;
   // give serialization implementation access to this clas
@@ -700,66 +606,52 @@ class log_archive :
   friend class boost::archive::save_access;
 
 public:
-
+  void save_override(const char *str) {
-    void save_override(const char *str, int v) {
     // Do not save any human decoration string //
     //        basic_text_oprimitive::save(str);
   }
 
-    template<class T>
+  template <class T> void save_override(T &t) {
-    void save_override(T & t, BOOST_PFTO int){
+    base::save_override(boost::serialization::make_nvp(NULL, t));
-        base::save_override(boost::serialization::make_nvp(NULL, t), 0);
   }
 
   // activate this if you want to trap non nvp objects //
   //    template<class T>
-    //    void save_override(T & t, BOOST_PFTO int)
+  //    void save_override(T & t)
   //    {
   //        BOOST_MPL_ASSERT((boost::serialization::is_wrapper< T >));
-    //        //        this->detail_common_oarchive::save_override(t, 0);
+  //        //        this->detail_common_oarchive::save_override(t);
   //    }
 
-    template<class T>
+  template <class T> void save_override(const boost::serialization::nvp<T> &t) {
-    void save_override(const boost::serialization::nvp<T> & t, int){
+    base::save_override(t);
-        base::save_override(t, 0);
   }
 
-
   // specific overrides for attributes - not name value pairs so we
   // want to trap them before the above "fall through"
   // since we don't want to see these in the output - make them no-ops.
-    void save_override(const boost::archive::object_id_type & t, int)         {}
+  void save_override(const boost::archive::object_id_type &t) {}
-    void save_override(const boost::archive::object_reference_type & t, int)  {}
+  void save_override(const boost::archive::object_reference_type &t) {}
-    void save_override(const boost::archive::version_type & t, int)           {}
+  void save_override(const boost::archive::version_type &t) {}
-    void save_override(const boost::archive::class_id_type & t, int)          {}
+  void save_override(const boost::archive::class_id_type &t) {}
-    void save_override(const boost::archive::class_id_optional_type & t, int) {}
+  void save_override(const boost::archive::class_id_optional_type &t) {}
-    void save_override(const boost::archive::class_id_reference_type & t, int){}
+  void save_override(const boost::archive::class_id_reference_type &t) {}
-    void save_override(const boost::archive::class_name_type & t, int)        {}
+  void save_override(const boost::archive::class_name_type &t) {}
-    void save_override(const boost::archive::tracking_type & t, int)          {}
+  void save_override(const boost::archive::tracking_type &t) {}
-
 
 public:
-    log_archive(std::ostream & os, unsigned int flags = 0) :
+  log_archive(std::ostream &os, unsigned int flags = 0)
-        boost::archive::xml_oarchive_impl<log_archive>(
+      : boost::archive::xml_oarchive_impl<log_archive>(
-            os,
+            os, flags | boost::archive::no_header) {}
-            flags | boost::archive::no_header
-        )
-    {}
 };
 
-//typedef boost::archive::detail::polymorphic_oarchive_route<
+// typedef boost::archive::detail::polymorphic_oarchive_route<
-//boost::archive::xml_oarchive_impl<log_archive>
+// boost::archive::xml_oarchive_impl<log_archive>
 //> polymorphic_log_archive;
 
+} // namespace Archive
 
-
+} // namespace uLib
-
-} // Archive
-
-
-
-} // uLib
-
 
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::xml_iarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::xml_oarchive)
@@ -769,13 +661,10 @@ ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_iarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_oarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::log_archive)
 
-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)
-
-
-
 
 #endif // U_CORE_ARCHIVES_H

src/Core/CMakeLists.txt

@@ -1,41 +1,28 @@
 
-set(HEADERS
+set(HEADERS Archives.h Array.h Collection.h Debug.h Export.h Function.h Macros.h Mpl.h Object.h Options.h Serializable.h Signal.h Singleton.h SmartPointer.h StaticInterface.h StringReader.h Types.h Uuid.h Vector.h)
-                                Archives.h
-                                Array.h
-                                Debug.h
-                                Export.h
-                                Function.h
-                                Macros.h
-                                Mpl.h
-                                Object.h
-                                ObjectProps.h
-                                Options.h
-                                Serializable.h
-                                Signal.h
-                                Singleton.h
-                                SmartPointer.h
-                                StaticInterface.h
-                                StringReader.h
-                                Types.h
-                                Uuid.h
-                                Timer.h
-)
 
-SET(SOURCES
+set(SOURCES Archives.cpp Debug.cpp Object.cpp Options.cpp Serializable.cpp Signal.cpp Uuid.cpp)
-                Archives.cpp
-                Object.cpp
-                Options.cpp
-                Serializable.cpp
-                Signal.cpp
-                Uuid.cpp
-)
 
-set(LIBRARIES
+set(LIBRARIES Boost::program_options)
-       ${Boost_SERIALIZATION_LIBRARY}
-       ${Boost_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-       ${ROOT_LIBRARIES}
-)
 
-uLib_add_shared_library(${uLib-module})
+set(libname ${PACKAGE_LIBPREFIX}Core)
-add_subdirectory(testing)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Core PARENT_SCOPE)
+
+add_library(${libname} SHARED ${SOURCES})
+set_target_properties(${libname} PROPERTIES
+                      VERSION ${PROJECT_VERSION}
+                      SOVERSION ${PROJECT_SOVERSION})
+target_link_libraries(${libname} ${LIBRARIES})
+
+install(TARGETS ${libname}
+        EXPORT "${PROJECT_NAME}Targets"
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Core)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Core/Export.h

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

src/Core/Makefile.am

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

src/Core/Object.cpp

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

src/Core/Object.h

@@ -23,38 +23,33 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #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/Types.h"
 #include "Core/Debug.h"
+#include "Core/Types.h"
 
 #include "Core/Function.h"
 #include "Core/Signal.h"
 
 #include "Core/Mpl.h"
 #include "Core/Serializable.h"
-#include "Core/ObjectProps.h"
 #include "Core/Uuid.h"
 
 namespace boost {
 namespace archive {
 class polymorphic_iarchive;
 class polymorphic_oarchive;
-} // archive
+} // namespace archive
-} // boost
+} // namespace boost
-
 
 namespace uLib {
 
-
 class Version {
 public:
   static const char *PackageName;
@@ -62,23 +57,14 @@ public:
   static const char *Release;
 };
 
-
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 //// OBJECT ////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
-
 /**
  * @brief Object class is the object base implementation for uLib Framework.
  */
-class Object : public ObjectPropable
+class Object {
-{
-
 
 public:
   //    std::string name;
@@ -94,14 +80,13 @@ public:
   // FIXX !!!
   virtual void DeepCopy(const Object &copy);
 
-
   ////////////////////////////////////////////////////////////////////////////
   // SERIALIZATION //
 
-    template <class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version)    {
+  template <class ArchiveT>
-                ObjectPropable::serialize(ar,version);
+  void serialize(ArchiveT &ar, const unsigned int version) {}
-    }
+  template <class ArchiveT>
-    template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version) {}
+  void save_override(ArchiveT &ar, const unsigned int version) {}
 
   void SaveConfig(std::ostream &os, int version = 0);
   void LoadConfig(std::istream &is, int version = 0);
@@ -109,13 +94,12 @@ public:
   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) {
+  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);
@@ -123,78 +107,83 @@ public:
     //        if(sig && slo)
     //            return Object::connect(sig,slo->operator ()(),receiver);
     //        else return false;
+    return false;
   }
 
   // Qt5 style connector //
   template <typename Func1, typename Func2>
-    static bool connect( typename FunctionPointer<Func1>::Object *sender,   Func1 sigf,
+  static bool
-                         typename FunctionPointer<Func2>::Object *receiver, Func2 slof)
+  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;
+    typedef boost::signals2::signal<
-        ConnectSignal(sigb,slof,receiver);
+        typename FunctionPointer<Func2>::SignalSignature>
+        SigT;
+    ConnectSignal(sigb, slof, receiver);
+    return true;
   }
 
   template <typename FuncT>
   static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
-        ConnectSignal(sigb,slof,receiver);
+    ConnectSignal(sigb, slof, receiver);
+    return true;
   }
 
-
+  template <typename FuncT>
-    template< typename FuncT >
+  inline
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
       addSignal(FuncT fun, const char *name) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
     SignalBase *sig = NewSignal(fun);
-        addSignalImpl(sig,fun,name);
+    addSignalImpl(sig, fun, name);
     return (SigT *)sig;
   }
 
-    template< typename FuncT>
+  template <typename FuncT> inline bool addSlot(FuncT fun, const char *name) {
-    inline bool addSlot(FuncT fun, const char *name) {
+    return this->addSlotImpl(GenericMFPtr(fun), name);
-        this->addSlotImpl(GenericMFPtr(fun),name);
   }
 
-    template < typename FuncT >
+  template <typename FuncT>
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+  inline
-    findSignal(FuncT fptr)
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    {
+      findSignal(FuncT fptr) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
     return (SigT *)findSignalImpl(GenericMFPtr(fptr));
   }
 
-    template < typename FuncT >
+  template <typename FuncT>
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+  inline
-    findOrAddSignal(FuncT fptr)
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    {
+      findOrAddSignal(FuncT fptr) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
     SignalBase *sig = findSignalImpl(GenericMFPtr(fptr));
-        if(!sig) {
+    if (!sig) {
       sig = NewSignal(fptr);
-            addSignalImpl(sig,fptr,"signal_name_to_be_implemented");
+      addSignalImpl(sig, fptr, "signal_name_to_be_implemented");
     }
     return (SigT *)sig;
   }
 
-
+  inline SignalBase *findSignal(const char *name) const {
-    inline SignalBase *
-    findSignal(const char *name) const
-    {
     return findSignalImpl(name);
   }
 
-    inline GenericMFPtr *
+  inline GenericMFPtr *findSlot(const char *name) const {
-    findSlot(const char *name) const
-    {
     return findSlotImpl(name);
   }
 
-
   void PrintSelf(std::ostream &o) const;
 
-    inline const Object& operator = (const Object &copy)
+  inline const Object &operator=(const Object &copy) {
-    { this->DeepCopy(copy); return *this; }
+    this->DeepCopy(copy);
-
+    return *this;
+  }
 
 private:
   bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
@@ -208,15 +197,12 @@ private:
   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

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

src/Core/Options.cpp

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

src/Core/Options.h

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

src/Core/Serializable.h

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

src/Core/Signal.h

@@ -23,21 +23,19 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_SIGNAL_H
 #define U_CORE_SIGNAL_H
 
 #include <boost/typeof/typeof.hpp>
 
 #include <boost/signals2/signal.hpp>
-#include <boost/signals2/slot.hpp>
 #include <boost/signals2/signal_type.hpp>
+#include <boost/signals2/slot.hpp>
 
 #include "Function.h"
+#include <boost/bind/bind.hpp>
 
-
+using namespace boost::placeholders;
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -51,8 +49,8 @@
 #define SLOT(a) BOOST_STRINGIZE(a)
 #define SIGNAL(a) BOOST_STRINGIZE(a)
 
-#define _ULIB_DETAIL_SIGNAL_EMIT(_name,...)                       \
+#define _ULIB_DETAIL_SIGNAL_EMIT(_name, ...)                                   \
-        static BOOST_AUTO(sig,this->findOrAddSignal(&_name));     \
+  static BOOST_AUTO(sig, this->findOrAddSignal(&_name));                       \
   sig->operator()(__VA_ARGS__);
 
 /**
@@ -66,103 +64,105 @@
  * // cast automatico //
  * static BOOST_AUTO(sig,this->findOrAddSignal(&Ob1::V0));
  *   sig->operator()();
-*/
+ */
-#define ULIB_SIGNAL_EMIT(_name,...) _ULIB_DETAIL_SIGNAL_EMIT(_name,__VA_ARGS__)
+#define ULIB_SIGNAL_EMIT(_name, ...)                                           \
-
+  _ULIB_DETAIL_SIGNAL_EMIT(_name, __VA_ARGS__)
 
 namespace uLib {
 
-
 // A boost::signal wrapper structure ///////////////////////////////////////////
 
 // TODO ...
 
 typedef boost::signals2::signal_base SignalBase;
 
-template <typename T>
+template <typename T> struct Signal {
-struct Signal {
   typedef boost::signals2::signal<T> type;
 };
 
-
-
 ////////////////////////////////////////////////////////////////////////////////
 
-
 namespace detail {
 
+template <typename FuncT, int arity> struct ConnectSignal {};
 
-template <typename FuncT, int arity>
+template <typename FuncT> struct ConnectSignal<FuncT, 0> {
-struct ConnectSignal {};
+  static void connect(SignalBase *sigb, FuncT slof,
-
+                      typename FunctionPointer<FuncT>::Object *receiver) {
-template <typename FuncT>
+    typedef
-struct ConnectSignal< FuncT, 0 > {
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
+            SigT;
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(slof);
-        reinterpret_cast<SigT*>(sigb)->connect(slof);
   }
 };
 
-template <typename FuncT>
+template <typename FuncT> struct ConnectSignal<FuncT, 1> {
-struct ConnectSignal< FuncT, 1 > {
+  static void connect(SignalBase *sigb, FuncT slof,
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
+                      typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    typedef
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver));
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
   }
 };
 
-template <typename FuncT>
+template <typename FuncT> struct ConnectSignal<FuncT, 2> {
-struct ConnectSignal< FuncT, 2 > {
+  static void connect(SignalBase *sigb, FuncT slof,
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
+                      typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    typedef
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1));
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
   }
 };
 
-template <typename FuncT>
+template <typename FuncT> struct ConnectSignal<FuncT, 3> {
-struct ConnectSignal< FuncT, 3 > {
+  static void connect(SignalBase *sigb, FuncT slof,
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
+                      typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    typedef
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2));
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2));
   }
 };
 
-template <typename FuncT>
+template <typename FuncT> struct ConnectSignal<FuncT, 4> {
-struct ConnectSignal< FuncT, 4 > {
+  static void connect(SignalBase *sigb, FuncT slof,
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
+                      typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    typedef
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3));
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2, _3));
   }
 };
 
-template <typename FuncT>
+template <typename FuncT> struct ConnectSignal<FuncT, 5> {
-struct ConnectSignal< FuncT, 5 > {
+  static void connect(SignalBase *sigb, FuncT slof,
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
+                      typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    typedef
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3,_4));
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2, _3, _4));
   }
 };
 
+} // namespace detail
 
-} // detail
+template <typename FuncT> SignalBase *NewSignal(FuncT f) {
-
-
-
-template <typename FuncT>
-SignalBase *NewSignal(FuncT f) {
   // seems to work wow !
   return new Signal<void()>::type;
 }
 
 template <typename FuncT>
-void ConnectSignal(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver)
+void ConnectSignal(SignalBase *sigb, FuncT slof,
-{
+                   typename FunctionPointer<FuncT>::Object *receiver) {
-    detail::ConnectSignal< FuncT, FunctionPointer<FuncT>::arity >::connect(sigb,slof,receiver);
+  detail::ConnectSignal<FuncT, FunctionPointer<FuncT>::arity>::connect(
+      sigb, slof, receiver);
 }
 
-
+} // namespace uLib
-
-
-} // uLib
 
 #endif // SIGNAL_H

src/Core/Types.h

@@ -23,8 +23,6 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_TYPES_H
 #define U_CORE_TYPES_H
 
@@ -33,20 +31,13 @@
 
 #include <boost/preprocessor.hpp>
 
-//#include <ltk/ltktypes.h>
+// #include <ltk/ltktypes.h>
 
 #include "Core/Macros.h"
 #include "Core/Mpl.h"
 
-
-
-
-
-
-
 namespace uLib {
 
-
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace detail {
@@ -72,23 +63,19 @@ struct TypeIntrospection {
   */
 
   /** IsA Introspectable Object Implementation Template */
-    template <class T>
+  template <class T> struct IsIntrospectable : has_type_info<T> {};
-    struct IsIntrospectable : has_type_info<T> {};
 
   template <typename T> struct access {
     typedef typename T::type_info type_info;
   };
 
-    template <typename T>
+  template <typename T> struct child_first_impl {
-    struct child_first_impl {
 
-        template <class T1, bool cond>
+    template <class T1, bool cond> struct lambda_CFList_f {
-        struct lambda_CFList_f {
       typedef mpl::vector<T1> type;
     };
 
-        template <class T1>
+    template <class T1> struct lambda_CFList_f<T1, true> {
-        struct lambda_CFList_f<T1,true> {
       //            typedef typename T1::type_info::CFList type;
       typedef typename access<T1>::type_info::CFList type;
     };
@@ -97,84 +84,60 @@ struct TypeIntrospection {
     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
+    typedef
-                                             , lambda_CFList<mpl::_>
+        typename mpl::transform_view<typename access<T>::type_info::BaseList,
-                                             >::type CFListSeq;
+                                     lambda_CFList<mpl::_>>::type CFListSeq;
 
     /** Folds each CFList into a new sequence */
-        typedef typename mpl::fold< CFListSeq
+    typedef typename mpl::fold<
-                                  , mpl::vector<>
+        CFListSeq, mpl::vector<>,
-                                  , mpl::copy< mpl::_1
+        mpl::copy<mpl::_1, mpl::back_inserter<mpl::_2>>>::type Childs;
-                                             , mpl::back_inserter<mpl::_2>
-                                             >
-                                  >::type Childs;
 
     /** Add This Class to final CFList sequence */
-        typedef typename mpl::copy< Childs
+    typedef typename mpl::copy<Childs, mpl::back_inserter<mpl::vector<T>>>::type
-                                  , mpl::back_inserter< mpl::vector<T> >
+        type;
-                                  >::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>
+  struct child_first
-                                 , child_first_impl<T>
+      : mpl::if_<has_type_info<T>, child_first_impl<T>, mpl::vector<>>::type {};
-                                 , mpl::vector<>
-                                 >::type {};
-
-
 };
 
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // TYPE ADAPTERS // FINIRE !!!
 
-//#define _REPETITION_V(vz,vn,vdata)
+// #define _REPETITION_V(vz,vn,vdata)
 
-
+// template < class TypeList >
-//template < class TypeList >
+// class TypeAdapterInputInterface {
-//class TypeAdapterInputInterface {
 //     virtual ~TypeAdapterInputInterface() {}
-//public:
+// 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;
 #else
 typedef double Real_t;
 #endif
-//typedef ltk::Id_t        Id_t;
+// typedef ltk::Id_t        Id_t;
 typedef id_t Id_t;
 ////typedef ltk::Size_t      Size_t;
-//typedef ltk::Pointer_t   Pointer_t;
+// typedef 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
@@ -182,104 +145,68 @@ typedef bool             Bool_t;      //Boolean (0=false, 1=true) (bool)
 #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, ...)                                          \
-
-#define uLibTypeMacro(thisClass,...) \
                                                                                \
   /* Friendship detail for accessing introspection */                          \
   template <typename> friend class uLib::detail::TypeIntrospection::access;    \
                                                                                \
-    /* type info structure*/ public: \
+/* type info structure*/ public:                                               \
   /* in GCC 4.8 must be public or dynamic_cast wont work */                    \
   struct type_info {                                                           \
     /*WARNING: -std=c++0x required for this! */                                \
     constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass);         \
-      typedef BOOST_PP_VARIADIC_ELEM(0,__VA_ARGS__) BaseClass;                      \
+    typedef BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) BaseClass;                  \
     typedef thisClass ThisClass;                                               \
-      typedef uLib::mpl::vector<__VA_ARGS__,thisClass> TypeList;                    \
+    typedef uLib::mpl::vector<__VA_ARGS__, thisClass> TypeList;                \
     typedef uLib::mpl::vector<__VA_ARGS__> BaseList;                           \
-      typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type CFList; \
+    typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type      \
+        CFList;                                                                \
   };                                                                           \
                                                                                \
-    public: \
+public:                                                                        \
   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>
   struct child_first : detail::TypeIntrospection::child_first<T> {};
-
 };
 
-
-
-
-
-
 // SISTEMARE //
 struct PrintTypeId {
-    template <class T>
+  template <class T> void operator()(T) const {
-    void operator()(T) const
+    std::cout << typeid(T).name() << std::endl;
-    { std::cout << typeid(T).name() << std::endl; }
+  }
 
-    template <typename SeqT>
+  template <typename SeqT> static void PrintMplSeq(SeqT *p = NULL) {
-    static void PrintMplSeq(SeqT *p = NULL) { boost::mpl::for_each<SeqT>(PrintTypeId()); }
+    boost::mpl::for_each<SeqT>(PrintTypeId());
+  }
 
-    template <typename Class>
+  template <typename Class> static void PrintType(Class *p = NULL) {
-    static void PrintType(Class *p = NULL) { std::cout << typeid(Class).name() << std::endl; }
+    std::cout << typeid(Class).name() << std::endl;
+  }
 };
 
-
+} // namespace uLib
-
-
-
-
-
-} // uLib
 
 #endif // U_CORE_TYPES_H
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

src/Core/testing/CMakeLists.txt

@@ -16,7 +16,6 @@ set( TESTS
         SerializeTest
         SerializeDreadDiamondTest
         DreadDiamondParameters
-        ObjectPropableTest
         UuidTest
         TypeIntrospectionTraversal
         OptionsTest
@@ -25,9 +24,8 @@ set( TESTS
 set(LIBRARIES
        ${PACKAGE_LIBPREFIX}Core
        ${PACKAGE_LIBPREFIX}Math
-       ${Boost_SERIALIZATION_LIBRARY}
+       Boost::serialization
-       ${Boost_SIGNALS_LIBRARY}
+       Boost::program_options
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
        ${ROOT_LIBRARIES}
 )
-uLib_add_tests(${uLib-module})
+uLib_add_tests(Core)

src/Core/testing/Makefile.am

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

src/Core/testing/ObjectPropableTest.cpp

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

src/Core/testing/SerializeDreadDiamondTest.cpp

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

src/Core/testing/SerializeTest.cpp

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

src/Core/testing/StaticInterfaceTest.cpp

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

src/Detectors/CMakeLists.txt

@@ -1,37 +1,12 @@
-#set(HEADERS
-#                                DetectorChamber.h
-#                                ExperimentFitEvent.h
-#                                GeantEvent.h
-#                                HitMC.h
-#                                MuonScatter.h
-#                                MuonEvent.h
-#                                MuonError.h
-#                                ChamberHitEvent.h
-#                                Hit.h
-#                                LinearFit.h
-#                                Solid.h
-#                                Matter.h
-#                                Scene.h
-#)
-
-
-#set(SOURCES
-#                Solid.cpp
-#                Scene.cpp
-#)
-
-#set(LIBRARIES
-#       ${Boost_SERIALIZATION_LIBRARY}
-#       ${Boost_SIGNALS_LIBRARY}
-#       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-#       ${Eigen_LIBRARY}
-#       ${Geant4_LIBRARIES}
-#       ${ROOT_LIBRARIES}
-#       ${PACKAGE_LIBPREFIX}Core
-#       ${PACKAGE_LIBPREFIX}Math
-#)
-
 set(HEADERS MuonScatter.h MuonError.h MuonEvent.h)
 
-uLib_add_shared_library(${uLib-module})
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
-add_subdirectory(testing)
+
+
+install(FILES ${HEADERS}
+        DESTINATION ${INSTALL_INC_DIR}/Detectors)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Detectors/testing/CMakeLists.txt

@@ -1,18 +1,15 @@
 # TESTS
 set( TESTS
-            GDMLSolidTest
+#            GDMLSolidTest
             HierarchicalEncodingTest
 )
 
-#set(LIBRARIES
+set(LIBRARIES
-#       ${PACKAGE_LIBPREFIX}Core
+       ${PACKAGE_LIBPREFIX}Core
-#       ${PACKAGE_LIBPREFIX}Math
+       ${PACKAGE_LIBPREFIX}Math
-#       ${PACKAGE_LIBPREFIX}Detectors
+       Boost::serialization
-#       ${Boost_SERIALIZATION_LIBRARY}
+       Boost::program_options
-#       ${Boost_SIGNALS_LIBRARY}
+       Eigen3::Eigen
-#       ${Boost_PROGRAM_OPTIONS_LIBRARY}
+       ${ROOT_LIBRARIES}
-#       ${Eigen_LIBRARY}
+)
-#       ${Geant4_LIBRARIES}
+uLib_add_tests(Detectors)
-#       ${ROOT_LIBRARIES}
-#)
-uLib_add_tests(${uLib-module})

src/Gui/Qt/QVTKViewport2/Makefile.am

@@ -1,35 +0,0 @@
-# SUBDIRS = .
-
-include $(top_srcdir)/Common.am
-
-DISTSOURCES        = vtkviewport.cpp main.cpp
-DISTHEADERS_MOC    =
-DISTHEADERS_NO_MOC = 
-FORMS              = vtkviewport.ui 
-
-FORMHEADERS = $(FORMS:.ui=.h)
-MOC_CC = $(FORMS:.ui=.moc.cpp) $(DISTHEADERS_MOC:.h=.moc.cpp)
-
-bin_PROGRAMS    = QTVtkViewport
-
-BUILT_SOURCES = $(FORMHEADERS) $(MOC_CC)
-CLEANFILES    = $(BUILT_SOURCES)
-
-EXTRA_DIST                   = $(FORMS)
-QTVtkViewport_SOURCES        = $(DISTSOURCES) $(DISTHEADERS_MOC) $(DISTHEADERS_NO_MOC)
-nodist_QTVtkViewport_SOURCES = $(MOC_CC)
-
-QTVtkViewport_LDADD = $(top_srcdir)/libmutom.la
-
-
-.ui.h: $(FORMS)
-	$(UIC) -o ui_$@ $<
-
-.ui.hpp: $(FORMS_HPP)
-	$(UIC) -o $@ $<
-
-.h.moc.cpp:
-	$(MOC) -o $@ $<
-
-
-SUFFIXES = .h .ui .moc.cpp

src/Gui/Qt/QVTKViewport2/QVTKViewport2.pro

@@ -1,18 +0,0 @@
-#-------------------------------------------------
-#
-# Project created by QtCreator 2012-08-30T18:59:53
-#
-#-------------------------------------------------
-
-QT       += core gui
-
-TARGET = QVTKViewport2
-TEMPLATE = app
-
-
-SOURCES += main.cpp\
-        vtkviewport.cpp
-
-HEADERS  += vtkviewport.h
-
-FORMS    += vtkviewport.ui

src/Gui/Qt/QVTKViewport2/QVTKViewport2.pro.user

@@ -1,453 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE QtCreatorProject>
-<!-- Written by Qt Creator 2.4.1, 2012-09-03T09:43:56. -->
-<qtcreator>
- <data>
-  <variable>ProjectExplorer.Project.ActiveTarget</variable>
-  <value type="int">0</value>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.EditorSettings</variable>
-  <valuemap type="QVariantMap">
-   <value type="bool" key="EditorConfiguration.AutoIndent">true</value>
-   <value type="bool" key="EditorConfiguration.AutoSpacesForTabs">false</value>
-   <valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
-    <value type="QString" key="language">Cpp</value>
-    <valuemap type="QVariantMap" key="value">
-     <value type="QString" key="CurrentPreferences">CppGlobal</value>
-    </valuemap>
-   </valuemap>
-   <valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
-    <value type="QString" key="language">QmlJS</value>
-    <valuemap type="QVariantMap" key="value">
-     <value type="QString" key="CurrentPreferences">QmlJSGlobal</value>
-    </valuemap>
-   </valuemap>
-   <value type="int" key="EditorConfiguration.CodeStyle.Count">2</value>
-   <value type="QByteArray" key="EditorConfiguration.Codec">System</value>
-   <value type="bool" key="EditorConfiguration.ConstrainTooltips">false</value>
-   <value type="int" key="EditorConfiguration.IndentSize">4</value>
-   <value type="bool" key="EditorConfiguration.MouseNavigation">true</value>
-   <value type="int" key="EditorConfiguration.PaddingMode">1</value>
-   <value type="bool" key="EditorConfiguration.ScrollWheelZooming">true</value>
-   <value type="int" key="EditorConfiguration.SmartBackspaceBehavior">0</value>
-   <value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
-   <value type="int" key="EditorConfiguration.TabKeyBehavior">1</value>
-   <value type="int" key="EditorConfiguration.TabSize">8</value>
-   <value type="bool" key="EditorConfiguration.UseGlobal">true</value>
-   <value type="int" key="EditorConfiguration.Utf8BomBehavior">1</value>
-   <value type="bool" key="EditorConfiguration.addFinalNewLine">true</value>
-   <value type="bool" key="EditorConfiguration.cleanIndentation">true</value>
-   <value type="bool" key="EditorConfiguration.cleanWhitespace">true</value>
-   <value type="bool" key="EditorConfiguration.inEntireDocument">false</value>
-  </valuemap>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.PluginSettings</variable>
-  <valuemap type="QVariantMap"/>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.Target.0</variable>
-  <valuemap type="QVariantMap">
-   <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value>
-   <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value>
-   <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Target.DesktopTarget</value>
-   <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
-   <value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
-   <value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 4.7.4 for GCC (Qt SDK) Release</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">3</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 4.7.4 for GCC (Qt SDK) Debug</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">3</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.2">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 in PATH (System) Release</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">4</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.3">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 in PATH (System) Debug</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">4</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.4">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 (System) Release</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">5</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.5">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 (System) Debug</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">5</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">6</value>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Deploy</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">No deployment</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
-   </valuemap>
-   <value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
-    <value type="bool" key="Analyzer.Project.UseGlobal">true</value>
-    <value type="bool" key="Analyzer.Project.UseGlobal">true</value>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
-    <value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
-    <value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
-    <value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
-    <value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
-    <value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">false</value>
-    <value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">false</value>
-    <value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
-    <value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
-    <value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
-    <value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
-    <value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
-    <value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
-     <value type="int">2</value>
-     <value type="int">3</value>
-     <value type="int">4</value>
-     <value type="int">5</value>
-     <value type="int">6</value>
-     <value type="int">7</value>
-     <value type="int">8</value>
-     <value type="int">9</value>
-     <value type="int">10</value>
-    </valuelist>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
-     <value type="int">2</value>
-     <value type="int">3</value>
-     <value type="int">4</value>
-     <value type="int">5</value>
-     <value type="int">6</value>
-     <value type="int">7</value>
-     <value type="int">8</value>
-     <value type="int">9</value>
-     <value type="int">10</value>
-    </valuelist>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">QVTKViewport2</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4RunConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4RunConfiguration.BaseEnvironmentBase">2</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.CommandLineArguments"></value>
-    <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.ProFile">QVTKViewport2.pro</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseDyldImageSuffix">false</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseTerminal">false</value>
-    <valuelist type="QVariantList" key="Qt4ProjectManager.Qt4RunConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory"></value>
-    <value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
-    <value type="bool" key="RunConfiguration.UseCppDebugger">true</value>
-    <value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
-    <value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">false</value>
-   </valuemap>
-   <value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
-  </valuemap>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.TargetCount</variable>
-  <value type="int">1</value>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.Updater.EnvironmentId</variable>
-  <value type="QString">{f8bb0047-7f6e-45df-9cc8-e746abebf883}</value>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.Updater.FileVersion</variable>
-  <value type="int">10</value>
- </data>
-</qtcreator>

src/Gui/Qt/QVTKViewport2/main.cpp

@@ -1,38 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#include <QtGui/QApplication>
-#include "vtkviewport.h"
-
-int main(int argc, char *argv[])
-{
-    QApplication a(argc, argv);
-    VtkViewport w;
-    w.show();
-    
-    return a.exec();
-}

src/Gui/Qt/QVTKViewport2/vtkviewport.cpp

@@ -1,41 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#include "vtkviewport.h"
-#include "ui_vtkviewport.h"
-
-VtkViewport::VtkViewport(QWidget *parent) :
-    QWidget(parent),
-    ui(new Ui::VtkViewport)
-{
-    ui->setupUi(this);
-}
-
-VtkViewport::~VtkViewport()
-{
-    delete ui;
-}

src/Gui/Qt/QVTKViewport2/vtkviewport.h

@@ -1,49 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#ifndef VTKVIEWPORT_H
-#define VTKVIEWPORT_H
-
-#include <QWidget>
-
-namespace Ui {
-class VtkViewport;
-}
-
-class VtkViewport : public QWidget
-{
-    Q_OBJECT
-    
-public:
-    explicit VtkViewport(QWidget *parent = 0);
-    ~VtkViewport();
-    
-private:
-    Ui::VtkViewport *ui;
-};
-
-#endif // VTKVIEWPORT_H

src/Gui/Qt/QVTKViewport2/vtkviewport.ui

@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>VtkViewport</class>
- <widget class="QWidget" name="VtkViewport">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>580</width>
-    <height>536</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
-  <widget class="QLabel" name="label">
-   <property name="geometry">
-    <rect>
-     <x>140</x>
-     <y>170</y>
-     <width>161</width>
-     <height>41</height>
-    </rect>
-   </property>
-   <property name="text">
-    <string>Hello World !</string>
-   </property>
-  </widget>
- </widget>
- <resources/>
- <connections/>
-</ui>

src/Math/BitCode.h

@@ -27,6 +27,8 @@
 #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>
@@ -34,6 +36,7 @@
 
 #include <Math/Dense.h>
 
+
 namespace uLib {
 
 

src/Math/CMakeLists.txt

@@ -1,7 +1,5 @@
 
-# HEADERS
+set(HEADERS ContainerBox.h
-set(HEADERS
-                                ContainerBox.h
             Dense.h
             Geometry.h
             Transform.h
@@ -23,31 +21,41 @@ set(HEADERS
             TriangleMesh.h
             BitCode.h
             Structured2DGrid.h
-                                Structured4DGrid.h
+            Structured4DGrid.h)
-)
 
-
+set(SOURCES VoxRaytracer.cpp
-# SOURCES
-set(SOURCES
-                VoxRaytracer.cpp
             StructuredData.cpp
             StructuredGrid.cpp
             VoxImage.cpp
             TriangleMesh.cpp
             Dense.cpp
             Structured2DGrid.cpp
-                Structured4DGrid.cpp
+            Structured4DGrid.cpp)
-)
 
-set(LIBRARIES
+set(LIBRARIES Eigen3::Eigen
-       ${Boost_SERIALIZATION_LIBRARY}
-       ${Boost_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-       ${Eigen_LIBRARY}
               ${ROOT_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
+              ${VTK_LIBRARIES})
-)
+
+set(libname ${PACKAGE_LIBPREFIX}Math)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Math PARENT_SCOPE)
+
+add_library(${libname} SHARED ${SOURCES})
+set_target_properties(${libname} PROPERTIES
+                      VERSION ${PROJECT_VERSION}
+                      SOVERSION ${PROJECT_SOVERSION})
+target_link_libraries(${libname} ${LIBRARIES})
 
 
-uLib_add_shared_library(${uLib-module})
+install(TARGETS ${libname}
-add_subdirectory(testing)
+        EXPORT "${PROJECT_NAME}Targets"
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Math)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()
+

src/Math/Dense.h

@@ -23,9 +23,6 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright (C) 2012  Andrea Rigoni Garola <andrea@pcimg05>
@@ -47,7 +44,6 @@
  *
  */
 
-
 #ifndef ULIB_DENSEMATRIX_H
 #define ULIB_DENSEMATRIX_H
 
@@ -55,27 +51,29 @@
 
 #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/string.hpp>
 #include <boost/serialization/array.hpp>
-
+#include <boost/serialization/string.hpp>
 
 namespace boost {
 namespace serialization {
 
-template<class Archive, class Scalar, int RowsAtCompileTime, int ColsAtCompileTime>
+template <class Archive, class Scalar, int RowsAtCompileTime,
-void serialize(Archive & ar, ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> & m, const unsigned int /*version*/) {
+          int ColsAtCompileTime>
-    ar & boost::serialization::make_array(m.data(), RowsAtCompileTime * ColsAtCompileTime);
+void serialize(Archive &ar,
+               ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> &m,
+               const unsigned int /*version*/) {
+  ar &boost::serialization::make_array(m.data(),
+                                       RowsAtCompileTime * ColsAtCompileTime);
 }
 
-} //  serialization
+} // namespace serialization
-} //  boost
+} // namespace boost
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -84,26 +82,27 @@ void serialize(Archive & ar, ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCo
 // 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;
-    for( unsigned int i=0; i<size; i++) {
+  for (unsigned int i = 0; i < size; i++) {
     is >> std::skipws;
     is >> str;
-        if(is.fail()) vec(i) = 0;
+    if (is.fail())
-        else vec(i) = boost::lexical_cast<T>(str);
+      vec(i) = 0;
+    else
+      vec(i) = boost::lexical_cast<T>(str);
   }
   return is;
 }
 template <typename T, int size>
-std::ostream & operator << (std::ostream &os, const Eigen::Matrix<T,size,1> &vec) {
+std::ostream &operator<<(std::ostream &os,
+                         const Eigen::Matrix<T, size, 1> &vec) {
   os << vec.transpose();
   return os;
 }
-} // Eigen
+} // namespace Eigen
 ////////////////////////////////////////////////////////////////////////////////
 
-
-
 namespace uLib {
 
 typedef id_t Id_t;
@@ -115,147 +114,131 @@ typedef unsigned long Scalarul;
 typedef float Scalarf;
 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 space-delimited text
+ *  \param delim Delimiters of the text (a typical default is " ," for comma and
-*
+ * space-delimited text
-*/
+ *
+ */
 template <typename T, int size>
-void VectorxT_StringTo(Eigen::Matrix<T,size,1> &vec, std::string str, const char *delim = " ,;\t\n") {
+void VectorxT_StringTo(Eigen::Matrix<T, size, 1> &vec, std::string str,
+                       const char *delim = " ,;\t\n") {
   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::token_compress_on);
+  boost::algorithm::split(strvec, str, boost::algorithm::is_any_of(delim),
+                          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]);
   }
 }
 
 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;
   sst << vec.transpose();
   return sst.str();
 }
 
-
+// template <typename T, int size>
-//template <typename T, int size>
+// Eigen::Matrix<T,size,1> & operator >> (std::istream &is,
-//Eigen::Matrix<T,size,1> & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) {
+// 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>
+template <bool p> class _HPoint3f : public Eigen::Matrix<Scalarf, 4, 1> {
-class _HPoint3f : public Eigen::Matrix< Scalarf,4,1 > {
 public:
-    typedef Eigen::Matrix< Scalarf,4,1 > BaseClass;
+  typedef Eigen::Matrix<Scalarf, 4, 1> BaseClass;
 
-    _HPoint3f<p>() : BaseClass(0,0,0,p) {}
+  _HPoint3f() : BaseClass(0, 0, 0, p) {}
-    _HPoint3f<p>(float x,float y,float z) : BaseClass(x,y,z,p) {}
+  _HPoint3f(float x, float y, float z) : BaseClass(x, y, z, p) {}
-    _HPoint3f<p>(Vector3f &in) : BaseClass(in.homogeneous()) { this->operator()(3) = p; }
+  _HPoint3f(Vector3f &in) : BaseClass(in.homogeneous()) {
+    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
-    template<typename OtherDerived>
+  template <typename OtherDerived>
-    inline _HPoint3f<p>(const Eigen::MatrixBase<OtherDerived>& other)
+  inline _HPoint3f(const Eigen::MatrixBase<OtherDerived> &other)
-        : BaseClass(other)
+      : BaseClass(other) {}
-    { }
 
   // This method allows to assign Eigen expressions to Vector3H
-    template<typename OtherDerived>
+  template <typename OtherDerived>
-    inline _HPoint3f<p> & operator= (const Eigen::MatrixBase <OtherDerived>& other)
+  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 {
-struct _HLine3f
-{
   HPoint3f origin;
   HVector3f direction;
 };
 typedef struct _HLine3f HLine3f;
 
-inline std::ostream&
+inline std::ostream &operator<<(std::ostream &stream, const HLine3f &line) {
-operator<< (std::ostream& stream, const HLine3f &line) {
+  stream << "HLine3f(" << "pt[" << line.origin.transpose() << "] , dr["
-    stream << "HLine3f(" << "pt[" << line.origin.transpose() <<"] , dr[" << line.direction.transpose() << "]) ";
+         << line.direction.transpose() << "]) ";
   return stream;
 }
 
-
+struct _HError3f {
-
-
-struct _HError3f
-{
   HVector3f position_error;
   HVector3f direction_error;
 };
 typedef struct _HError3f HError3f;
 
-inline std::ostream&
+inline std::ostream &operator<<(std::ostream &stream, const HError3f &err) {
-operator<< (std::ostream& stream, const HError3f &err) {
+  stream << "HError3f(" << "ept[" << err.position_error.transpose()
-    stream << "HError3f(" << "ept[" << err.position_error.transpose() <<"] , edr[" << err.direction_error.transpose() << "]) ";
+         << "] , edr[" << err.direction_error.transpose() << "]) ";
   return stream;
 }
 
-
+} // namespace uLib
-}
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -269,13 +252,9 @@ ULIB_SERIALIZABLE(uLib::HPoint3f)
 
 ULIB_SERIALIZABLE(uLib::HVector3f)
 
-
 ULIB_SERIALIZABLE(uLib::HLine3f)
 
 ULIB_SERIALIZABLE(uLib::HError3f)
 #endif // ULIB_SERIALIZATION_ON
 
-
-
-
 #endif // U_DENSEMATRIX_H

src/Math/Transform.h

@@ -110,6 +110,17 @@ 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,6 +30,13 @@
 
 #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 {
 
@@ -83,7 +90,103 @@ 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;
@@ -115,14 +218,18 @@ int Abstract::VoxImage::ImportFromVtk(const char *file)
     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,fabs(tmp_val)*1E-6);
+                this->SetValue(idx,tmp_val / norm);
-                this->SetValue(idx,tmp_val*1E-6);
             }
         }
     }

src/Math/VoxImage.h

@@ -56,8 +56,18 @@ 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/VoxImageFilterCustom.hpp

@@ -28,11 +28,12 @@
 #ifndef VOXIMAGEFILTERCUSTOM_HPP
 #define VOXIMAGEFILTERCUSTOM_HPP
 
-#include "Core/Macros.h"
 #include <Math/Dense.h>
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
 
+#define likely(expr) __builtin_expect(!!(expr), 1)
+
 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER CUSTOM  /////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

src/Math/VoxRaytracer.cpp

@@ -23,13 +23,12 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+#include <iostream>
 
-
-
-#include "VoxRaytracer.h"
 #include "Utils.h"
+#include "VoxRaytracer.h"
 
-#include "Core/Macros.h"
+#define unlikely(expr) __builtin_expect(!!(expr), 0)
 
 inline float fast_sign(float f) { return 1 - 2 * (f < 0); }
 
@@ -39,29 +38,25 @@ 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);
   m_TotalLength += L;
 }
 
-
+void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in) {
-void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in)
-{
   if (unlikely(!in.m_Data.size())) {
     std::cout << "Warinig: PoCA on exit border!\n";
     return;
-    }
+  } else if (unlikely(!m_Data.size())) {
-    else if (unlikely(!m_Data.size())) {
     m_Data = in.m_Data;
     std::cout << "Warinig: PoCA on entrance border!\n";
     return;
-    }
+  } else {
-    else {
     // Opzione 1) un voxel in piu' //
-        m_Data.reserve(m_Data.size() + in.m_Data.size());
+    if (in.m_Data.size() > 0) {
       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();
@@ -69,32 +64,30 @@ void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in)
     //        {
     //            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());
+    //            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_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;
-    for(it = m_Data.begin(); it < m_Data.end(); ++it)
+  for (it = m_Data.begin(); it < m_Data.end(); ++it)
     o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 //// RAY TRACER ////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
+bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt) {
-bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt)
-{
   Vector4f s = m_Image->GetLocalPoint(line.direction);
   pt = m_Image->GetLocalPoint(line.origin);
 
@@ -104,63 +97,59 @@ bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt)
   s = s.cwiseQuotient(dims);
 
   float l = s.head(3).norm();
-    Vector3f L(l/s(0), l/s(1), l/s(2));
+  Vector3f L(l / s(0), l / s(1), l / s(2));
 
   Vector3f offset;
-    for(int i=0;i<3;++i)
+  for (int i = 0; i < 3; ++i)
-        offset(i) = (s(i)>0) - (pt(i)-floor(pt(i))) ;
+    offset(i) = (s(i) > 0) - (pt(i) - floor(pt(i)));
   offset = offset.cwiseProduct(L).cwiseAbs();
 
-    int id; float d;
+  int id;
-    for(int loop=0; loop<8; loop++)
+  float d;
-    {
+  for (int loop = 0; loop < 8; loop++) {
     int check_border = 0;
-        for ( int i=0; i<3 ;++i) {
+    for (int i = 0; i < 3; ++i) {
       check_border += pt(i) > 1;
       check_border += pt(i) < 0;
     }
-        if(check_border == 0) {
+    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);
       return true;
     }
 
     d = offset.minCoeff(&id);
-       for(int i=0; i<3; ++i)
+    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));
   }
-    for(int i=0;i<3;++i)
+  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)
+bool VoxRaytracer::GetExitPoint(const HLine3f &line, HPoint3f &pt) {
-{
   HLine3f out = line;
   out.direction *= -1;
-    return GetEntryPoint(out,pt);
+  return GetEntryPoint(out, pt);
 }
 
-
+VoxRaytracer::RayData
-VoxRaytracer::RayData VoxRaytracer::TraceBetweenPoints(const HPoint3f &in,
+VoxRaytracer::TraceBetweenPoints(const HPoint3f &in,
-                                                       const HPoint3f &out)
+                                 const HPoint3f &out) const {
-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 L(l / s(0), l / s(1), l / s(2));
 
   // Vector3f scale; // FIXXX
   // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
@@ -168,25 +157,27 @@ const
   //          (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))) ;
+  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)){
+  if (vid == m_Image->Find(out)) {
-      ray.AddElement(m_Image->Map(vid),s.norm());
+    ray.AddElement(m_Image->Map(vid), s.norm());
     return ray;
   }
 
   //---- Otherwise, loop until ray is finished
-    int id; float d;
+  int id;
-    while(l>0){
+  float d;
+  while (l > 0) {
 
     d = offset.minCoeff(&id);
 
-      if(m_Image->IsInsideGrid(vid)){
+    if (m_Image->IsInsideGrid(vid)) {
-	ray.AddElement(m_Image->Map(vid), d * m_scale(id) );
+      ray.AddElement(m_Image->Map(vid), d * m_scale(id));
     }
 
     // nan check //
@@ -199,14 +190,13 @@ const
 
     l -= d;
     offset.array() -= d;
-      offset(id) = fmin(L(id),l);
+    offset(id) = fmin(L(id), l);
   }
   return ray;
 }
 
 // 20150528 SV for absorbed muons
-VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
+VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const {
-{
   RayData ray;
 
   Vector4f pt = m_Image->GetLocalPoint(line.origin);
@@ -214,7 +204,7 @@ VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
 
   float l = s.head(3).norm();
   // intersection between track and grid when spacing is +1
-    Vector3f L(l/s(0), l/s(1), l/s(2));
+  Vector3f L(l / s(0), l / s(1), l / s(2));
 
   // RayTracer works with a grid of interspace +1
   // Vector3f scale; // FIXXX
@@ -222,24 +212,24 @@ VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
   //          (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
   //          (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
 
-    // offset is the fraction of the segment between grid lines when origin is insiede voxel
+  // offset is the fraction of the segment between grid lines when origin is
-    // cwiseAbs for having positive distances
+  // insiede voxel cwiseAbs for having positive distances
   Vector3f offset;
-    for(int i=0;i<3;++i)
+  for (int i = 0; i < 3; ++i)
-        offset(i) = (s(i)>=0) - (pt(i)-floor(pt(i)));
+    offset(i) = (s(i) >= 0) - (pt(i) - floor(pt(i)));
   offset = offset.cwiseProduct(L).cwiseAbs();
   L = L.cwiseAbs();
 
-    int id; float d;
+  int id;
+  float d;
   Vector3i vid = m_Image->Find(line.origin);
-    while(m_Image->IsInsideGrid(vid))
+  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
-        ray.AddElement(m_Image->Map(vid), d * m_scale(id) );
+    ray.AddElement(m_Image->Map(vid), d * m_scale(id));
 
     // move to the next voxel
     vid(id) += (int)fast_sign(s(id));
@@ -250,4 +240,4 @@ VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
   return ray;
 }
 
-}
+} // namespace uLib

src/Math/testing/AccumulatorTest.cpp

@@ -23,18 +23,16 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
 #include "Math/Accumulator.h"
 #include "testing-prototype.h"
 
 #include <TRandom.h>
+#include <iostream>
+#include <vector>
 
-
+// #include <boost/accumulators/framework/accumulator_set.hpp>
-//#include <boost/accumulators/framework/accumulator_set.hpp>
+// #include <boost/accumulators/statistics/count.hpp>
-//#include <boost/accumulators/statistics/count.hpp>
+// #include <boost/accumulators/accumulators.hpp>
-//#include <boost/accumulators/accumulators.hpp>
 
 using namespace uLib;
 
@@ -42,68 +40,72 @@ int test_ABTrim() {
 
   Accumulator_ABTrim<float> acc;
 
-    acc.SetABTrim(1,1);
+  acc.SetABTrim(1, 1);
 
   std::vector<float> v;
-    for(float tmpf : {1,5,5,5,300}) v.push_back(tmpf);
+  for (float tmpf : {1, 5, 5, 5, 300})
-    //v << 1,5,5,5,300;
+    v.push_back(tmpf);
+  // v << 1,5,5,5,300;
 
-    for(std::vector<float>::iterator itr=v.begin(); itr<v.end(); itr++)
+  for (std::vector<float>::iterator itr = v.begin(); itr < v.end(); itr++)
     acc += *itr;
 
   // TODO missing operator <<
-    //std::cout << "Accumulating  Trim(1,1) vector: "
+  // std::cout << "Accumulating  Trim(1,1) vector: "
   //          << v << " ... out = " << acc() << "\n";
 
-    return( acc() == 15.0 );
+  return (acc() == 15.0);
-
 }
 
-
 int test_Mean() {
   Accumulator_Mean<float> mean;
   TRandom rnd;
   const int c = 10000000;
   std::vector<float> v;
   v.reserve(c);
-    for(int i=0;i<c;++i) v.push_back( rnd.Gaus(2000,5) );
+  for (int i = 0; i < c; ++i)
+    v.push_back(rnd.Gaus(2000, 5));
 
   float m = 0;
-    for(int i=0;i<c;++i) m += v[i];
+  for (int i = 0; i < c; ++i)
+    m += v[i];
   m /= c;
   std::cout << "simple mean: " << m << "\n";
 
-    for(int i=0;i<c;++i) mean(v[i]);
+  for (int i = 0; i < c; ++i)
+    mean(v[i]);
   std::cout << "mean pass: " << mean() << "\n";
   mean.AddPass();
-    for(int i=0;i<c;++i) mean(v[i]);
+  for (int i = 0; i < c; ++i)
+    mean(v[i]);
   std::cout << "mean pass: " << mean() << "\n";
   mean.AddPass();
-    for(int i=0;i<c;++i) mean(v[i]);
+  for (int i = 0; i < c; ++i)
+    mean(v[i]);
   std::cout << "mean pass: " << mean() << "\n";
   mean.AddPass();
-    for(int i=0;i<c;++i) mean(v[i]);
+  for (int i = 0; i < c; ++i)
+    mean(v[i]);
   std::cout << "mean pass: " << mean() << "\n";
   mean.AddPass();
-    for(int i=0;i<c;++i) mean(v[i]);
+  for (int i = 0; i < c; ++i)
+    mean(v[i]);
   std::cout << "mean pass: " << mean() << "\n";
   mean.AddPass();
-    for(int i=0;i<c;++i) mean(v[i]);
+  for (int i = 0; i < c; ++i)
+    mean(v[i]);
   std::cout << "mean pass: " << mean() << "\n";
   mean.AddPass();
-    for(int i=0;i<c;++i) mean(v[i]);
+  for (int i = 0; i < c; ++i)
+    mean(v[i]);
   std::cout << "mean pass: " << mean() << "\n";
-
+  return 1;
-
 }
 
-
-
-
 int main(void) {
   BEGIN_TESTING(Accumulator);
 
-    //TEST1( test_ABTrim() );
+  // TEST1( test_ABTrim() );
   test_Mean();
 
   END_TESTING;

src/Math/testing/CMakeLists.txt

@@ -17,6 +17,8 @@ set(TESTS
 set(LIBRARIES
        ${PACKAGE_LIBPREFIX}Core
        ${PACKAGE_LIBPREFIX}Math
+       Boost::serialization
+       Eigen3::Eigen
 )
 
-uLib_add_tests(${uLib-module})
+uLib_add_tests(Math)

src/Math/testing/TriangleMeshTest.cpp

@@ -23,28 +23,23 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
 #include "testing-prototype.h"
 
 #include "Math/TriangleMesh.h"
-
+#include <iostream>
 
 using namespace uLib;
 
-int main()
+int main() {
-{
   BEGIN_TESTING(Triangle Mesh);
 
   TriangleMesh mesh;
 
-    mesh.AddPoint(Vector3f(0,0,0));
+  mesh.AddPoint(Vector3f(0, 0, 0));
-    mesh.AddPoint(Vector3f(0,1,0));
+  mesh.AddPoint(Vector3f(0, 1, 0));
-    mesh.AddPoint(Vector3f(1,0,0));
+  mesh.AddPoint(Vector3f(1, 0, 0));
-
-    mesh.AddTriangle(Vector3i(0,1,2));
 
+  mesh.AddTriangle(Vector3i(0, 1, 2));
 
   mesh.PrintSelf(std::cout);
 

src/Math/testing/VoxImageTest.cpp

@@ -92,6 +92,20 @@ 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/Math/testing/VoxRaytracerTest.cpp

@@ -23,129 +23,114 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
-#include "Math/StructuredGrid.h"
 #include "Math/VoxRaytracer.h"
+#include "Math/StructuredGrid.h"
 #include "testing-prototype.h"
+#include <iostream>
 
 using namespace uLib;
 
-
+int Vector4f0(Vector4f c) {
-int Vector4f0(Vector4f c)
-{
   c(3) = 0;
-  if ( fabs(c(0)) < 0.001 && fabs(c(1)) < 0.001 && fabs(c(2)) < 0.001 )
+  if (fabs(c(0)) < 0.001 && fabs(c(1)) < 0.001 && fabs(c(2)) < 0.001)
     return 0;
   else
     return 1;
 }
 
-//bool Comapare(const  &t1, const T2 &t2)
+// bool Comapare(const  &t1, const T2 &t2)
 //{
 //     int out = 0;
 //     out += t1.vox_id != t2.vox_id;
 //     out += (fabs(t1.L) - fabs(t2.L)) > 0.001;
 //     return out == 0;
-//}
+// }
-
 
 typedef VoxRaytracer Raytracer;
 
-int main()
+int main() {
-{
   BEGIN_TESTING(Math VoxRaytracer);
 
-    StructuredGrid img(Vector3i(2,2,2));
+  StructuredGrid img(Vector3i(2, 2, 2));
-    img.SetSpacing(Vector3f(2,2,2));
+  img.SetSpacing(Vector3f(2, 2, 2));
-    img.SetPosition(Vector3f(-2,0,-2));
+  img.SetPosition(Vector3f(-2, 0, -2));
 
   {
     HLine3f line;
     line.origin << 0.1, 4.1, 0.1, 1;
-        line.direction << 0.1, -0.1, 0.1,0;
+    line.direction << 0.1, -0.1, 0.1, 0;
     Raytracer rt(img);
     HPoint3f pt;
-        TEST1( rt.GetEntryPoint(line,pt) );
+    TEST1(rt.GetEntryPoint(line, pt));
-        TEST0( Vector4f0( pt - HPoint3f(0.2,4,0.2)  ) );
+    TEST0(Vector4f0(pt - HPoint3f(0.2, 4, 0.2)));
   }
 
   {
     HLine3f line;
-        line.origin << 4,0,4, 1;
+    line.origin << 4, 0, 4, 1;
     line.direction << -0.1, 0.1, -0.1, 0;
     Raytracer rt(img);
     HPoint3f pt;
-        TEST1( rt.GetEntryPoint(line,pt) );
+    TEST1(rt.GetEntryPoint(line, pt));
-        TEST0( Vector4f0( pt - HPoint3f(2,2,2)  ) );
+    TEST0(Vector4f0(pt - HPoint3f(2, 2, 2)));
   }
 
   { // Test a point inside image //
-        StructuredGrid img(Vector3i(4,4,4));
+    StructuredGrid img(Vector3i(4, 4, 4));
-        img.SetSpacing(Vector3f(2,2,2));
+    img.SetSpacing(Vector3f(2, 2, 2));
-        img.SetPosition(Vector3f(-4,-4,-4));
+    img.SetPosition(Vector3f(-4, -4, -4));
     Raytracer ray(img);
     HPoint3f pt;
     HLine3f line;
-        line.origin = HPoint3f(-3,-3,-3);
+    line.origin = HPoint3f(-3, -3, -3);
     //        line.direction = HVector3f(1,1,1); //
-        TEST1( ray.GetEntryPoint(line,pt) );
+    TEST1(ray.GetEntryPoint(line, pt));
-        TEST1( pt == HPoint3f(-3,-3,-3) );
+    TEST1(pt == HPoint3f(-3, -3, -3));
 
-        Raytracer::RayData rdata = ray.TraceBetweenPoints(HPoint3f(-3,-3,-3), HPoint3f(3,3,3));
+    Raytracer::RayData rdata =
-        for(const Raytracer::RayData::Element &el : rdata.Data())
+        ray.TraceBetweenPoints(HPoint3f(-3, -3, -3), HPoint3f(3, 3, 3));
-        {
+    for (const Raytracer::RayData::Element &el : rdata.Data()) {
       std::cout << " " << el.vox_id << " , " << el.L << "\n";
     }
   }
 
-
   {
-        HPoint3f pt1(1,-0.5,1);
+    HPoint3f pt1(1, -0.5, 1);
-        HPoint3f pt2(1,4.5,1);
+    HPoint3f pt2(1, 4.5, 1);
     Raytracer rt(img);
 
-        Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
+    Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
-        TEST1( ray.Data().size() == 2 );
+    TEST1(ray.Data().size() == 2);
-        TEST1( ray.Data().at(0).vox_id == 6 );
+    TEST1(ray.Data().at(0).vox_id == 6);
-        TEST1( ray.Data().at(1).vox_id == 7 );
+    TEST1(ray.Data().at(1).vox_id == 7);
     ray.PrintSelf(std::cout);
   }
 
   {
-        HPoint3f pt1(5,1,1);
+    HPoint3f pt1(5, 1, 1);
-        HPoint3f pt2(-3,1,1);
+    HPoint3f pt2(-3, 1, 1);
     Raytracer rt(img);
 
-        Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
+    Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
-        TEST1( ray.Data().size() == 2 );
+    TEST1(ray.Data().size() == 2);
-        TEST1( ray.Data().at(0).vox_id == 6 );
+    TEST1(ray.Data().at(0).vox_id == 6);
-        TEST1( ray.Data().at(1).vox_id == 4 );
+    TEST1(ray.Data().at(1).vox_id == 4);
     ray.PrintSelf(std::cout);
   }
 
   {
-        HPoint3f pt1(1,1,1);
+    HPoint3f pt1(1, 1, 1);
-        HPoint3f pt2(-1,3,-1);
+    HPoint3f pt2(-1, 3, -1);
     Raytracer rt(img);
 
-        Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
+    Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
-        TEST1( ray.Data().size() == 4 );
+    TEST1(ray.Data().size() == 4);
-        TEST1( ray.Data().at(0).vox_id == 6 );
+    TEST1(ray.Data().at(0).vox_id == 6);
-        TEST1( ray.Data().at(1).vox_id == 4 );
+    TEST1(ray.Data().at(1).vox_id == 4);
-        TEST1( ray.Data().at(2).vox_id == 5 );
+    TEST1(ray.Data().at(2).vox_id == 5);
-        TEST1( ray.Data().at(3).vox_id == 1 );
+    TEST1(ray.Data().at(3).vox_id == 1);
     ray.PrintSelf(std::cout);
   }
 
   END_TESTING
 }
-
-
-
-
-
-
-
-

src/Root/CMakeLists.txt

@@ -1,55 +1,68 @@
-set(HEADERS
+set(HEADERS RootMathDense.h
- TestTObject.h
- RootMathDense.h
             RootMuonScatter.h
             RootHitRaw.h
- muBlastHit.h
- muBlastMCTrack.h
             muCastorMCTrack.h
             muCastorHit.h
             muCastorInfo.h
-)
+            muCastorSkinHit.h
+            muCastorPrimaryVertex.h
+            muCastorMuDetDIGI.h
+            SkinDetectorWriter.h)
 
-set(DICTIONARY_HEADERS
+set(SOURCES ${HEADERS} RootMuonScatter.cpp
- TestTObject.h
- RootMathDense.h
- RootMuonScatter.h
- RootHitRaw.h
- muBlastHit.h
- muBlastMCTrack.h
- muCastorMCTrack.h
- muCastorHit.h
- muCastorInfo.h
-)
-
-SET(SOURCES
- TestTObject.cpp
- RootMuonScatter.cpp
- muBlastHit.cpp
- muBlastMCTrack.cpp
                        muCastorMCTrack.cpp
                        muCastorHit.cpp
                        muCastorInfo.cpp
-)
+                       muCastorSkinHit.cpp
+                       muCastorPrimaryVertex.cpp
+                       muCastorMuDetDIGI.cpp
+                       SkinDetectorWriter.cpp)
 
-set(LIBRARIES
+set(DICTIONARY_HEADERS muCastorMCTrack.h
-#       ${Boost_SERIALIZATION_LIBRARY}
+                       muCastorHit.h
-#       ${Boost_SIGNALS_LIBRARY}
+                       muCastorInfo.h
-#       ${Boost_PROGRAM_OPTIONS_LIBRARY}
+                       muCastorSkinHit.h
-       ${ROOT_LIBRARIES}
+                       muCastorPrimaryVertex.h
-       ${PACKAGE_LIBPREFIX}Core
+                       muCastorMuDetDIGI.h
-       ${PACKAGE_LIBPREFIX}Math
+                       SkinDetectorWriter.h)
-)
 
-include(FindROOTv6)
+set(LIBRARIES ${ROOT_LIBRARIES}
-root_generate_dictionary(uLibRootDict ${DICTIONARY_HEADERS} LINKDEF Linkdef.h)
+              ${PACKAGE_LIBPREFIX}Math)
-set_source_files_properties(uLibRootDict.cxx PROPERTIES GENERATED TRUE)
+
-set_source_files_properties(uLibRootDict.h PROPERTIES GENERATED TRUE)
+set(rDictName ${PACKAGE_LIBPREFIX}RootDict)
-list(APPEND SOURCES     uLibRootDict.cxx)
+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
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/uLibRootDict_rdict.pcm
+set(R_ARTIFACTS ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}_rdict.pcm
-        DESTINATION ${PACKAGE_INSTALL_LIB_DIR})
+                ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}.rootmap)
+install(FILES ${R_ARTIFACTS}
+        DESTINATION ${INSTALL_LIB_DIR})
 
-uLib_add_shared_library(${uLib-module})
+set(libname ${PACKAGE_LIBPREFIX}Root)
-add_subdirectory(testing)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+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}
+                      CXX_STANDARD 17)
+target_link_libraries(${libname} ${LIBRARIES})
+
+install(TARGETS ${libname}
+        EXPORT "${PROJECT_NAME}Targets"
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Root)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Root/Linkdef.h

@@ -23,8 +23,6 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_ROOT_LINKDEF_H
 #define U_ROOT_LINKDEF_H
 
@@ -35,50 +33,21 @@
 #pragma link off all functions;
 #pragma link C++ nestedclasses;
 
-#pragma link C++ class TestTObject+;
-
 using namespace ROOT::Mutom;
 
-#pragma link C++ class ROOT::Math::Cartesian2D<int>+;
+#pragma link C++ class ROOT::Math::Cartesian3D < int> + ;
-#pragma link C++ class ROOT::Math::Cartesian2D<float>+;
+#pragma link C++ class ROOT::Math::Cartesian3D < float> + ;
-#pragma link C++ class ROOT::Math::Cartesian2D<double>+;
+#pragma link C++ class ROOT::Math::Cartesian3D < 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 HitRaw+;
+#pragma link C++ class muCastorMCTrack + ;
-#pragma link C++ function HitRaw::Chm() const;
+#pragma link C++ class muCastorHit + ;
-#pragma link C++ function HitRaw::Rob() const;
+#pragma link C++ class muCastorInfo + ;
-#pragma link C++ function HitRaw::Tdc() const;
+#pragma link C++ class muCastorSkinHit + ;
-#pragma link C++ function HitRaw::Ch() const;
+#pragma link C++ class muCastorPrimaryVertex + ;
-
+#pragma link C++ class muCastorMuDetDIGI + ;
-#pragma link C++ class  muBlastMCTrack+;
+#pragma link C++ class SkinDetectorWriter + ;
-#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

@@ -0,0 +1,47 @@
+#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

@@ -0,0 +1,32 @@
+#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/muBlastMCTrack.h

@@ -9,6 +9,7 @@
 //         Martin Subieta   martin.subieta@ing.unibs.it
 //########################################
 
+#include <iostream>
 #include <vector>
 #include "TObject.h"
 #include "TParticle.h"

src/Root/muCastorMCTrack.h

@@ -9,6 +9,7 @@
 //         Martin Subieta   martin.subieta@ing.unibs.it
 //########################################
 
+#include <iostream>
 #include "vector"
 #include "TObject.h"
 #include "TParticle.h"

src/Root/muCastorMuDetDIGI.cpp

@@ -0,0 +1,41 @@
+/// \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

@@ -0,0 +1,75 @@
+#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

@@ -0,0 +1,47 @@
+#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

@@ -0,0 +1,53 @@
+#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

@@ -0,0 +1,43 @@
+//----------------------------------------------------------
+// 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

@@ -0,0 +1,52 @@
+//----------------------------------------------------------
+// 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/Root/testing/CMakeLists.txt

@@ -8,9 +8,8 @@ set(LIBRARIES
        ${PACKAGE_LIBPREFIX}Core
        ${PACKAGE_LIBPREFIX}Math
        ${PACKAGE_LIBPREFIX}Root
-       ${Boost_SERIALIZATION_LIBRARY}
+       Boost::serialization
-       ${Boost_SIGNALS_LIBRARY}
+       Boost::program_options
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
        ${ROOT_LIBRARIES}
 )
-uLib_add_tests(${uLib-module})
+uLib_add_tests(Root)

src/Vtk/CMakeLists.txt

@@ -1,37 +1,42 @@
-set(HEADERS
+set(HEADERS uLibVtkInterface.h
-                          uLibVtkInterface.h
             uLibVtkViewer.h
             vtkContainerBox.h
             vtkMuonScatter.h
             vtkStructuredGrid.h
             vtkVoxRaytracerRepresentation.h
-                          vtkVoxImage.h
+            vtkVoxImage.h)
-#                          vtkHLineRepresentation.h
-#			  vtkTriangleMesh.h
-)
 
-SET(SOURCES
+set(SOURCES uLibVtkInterface.cxx
-                uLibVtkInterface.cxx
             uLibVtkViewer.cpp
             vtkContainerBox.cpp
             vtkMuonScatter.cxx
             vtkStructuredGrid.cpp
             vtkVoxRaytracerRepresentation.cpp
-                vtkVoxImage.cpp
+            vtkVoxImage.cpp)
-)
 
-set(LIBRARIES
+set(LIBRARIES Eigen3::Eigen
-       ${Boost_SERIALIZATION_LIBRARY}
-       ${Boost_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-       ${Eigen_LIBRARY}
               ${ROOT_LIBRARIES}
-       ${Geant4_LIBRARIES}
               ${VTK_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
+              ${PACKAGE_LIBPREFIX}Math)
-       ${PACKAGE_LIBPREFIX}Math
-)
 
-uLib_add_shared_library(${uLib-module})
+set(libname ${PACKAGE_LIBPREFIX}Vtk)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Vtk PARENT_SCOPE)
 
-add_subdirectory(testing)
+add_library(${libname} SHARED ${SOURCES})
+set_target_properties(${libname} PROPERTIES
+                      VERSION ${PROJECT_VERSION}
+                      SOVERSION ${PROJECT_SOVERSION})
+target_link_libraries(${libname} ${LIBRARIES})
+
+install(TARGETS ${libname}
+        EXPORT "${PROJECT_NAME}Targets"
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Vtk)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Vtk/testing/CMakeLists.txt

@@ -14,5 +14,5 @@ set(LIBRARIES
        ${PACKAGE_LIBPREFIX}Vtk
 )
 
-include(${VTK_USE_FILE})
+# include(${VTK_USE_FILE})
-uLib_add_tests(${uLib-module})
+uLib_add_tests(Vtk)

src/Vtk/uLibVtkInterface.cxx

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

src/Vtk/vtkContainerBox.cpp

@@ -65,6 +65,7 @@ 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 <vtkConfigure.h>
+#include <vtkVersion.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 "vtk/vtkVolume.h"
+#include <vtkVolume.h>
-#include "vtk/vtkImageData.h"
+#include <vtkImageData.h>
-#include "vtk/vtkXMLImageDataReader.h"
+#include <vtkXMLImageDataReader.h>
-#include "vtk/vtkXMLImageDataWriter.h"
+#include <vtkXMLImageDataWriter.h>
-#include "vtk/vtkCubeSource.h"
+#include <vtkCubeSource.h>
 
 #include <Math/VoxImage.h>
 

src/ltk/CMakeLists.txt

@@ -1,12 +0,0 @@
-
-set(HEADERS
-    ltktypes.h
-    ltkmacros.h
-    ltkdebug.h
-)
-
-SET(SOURCES)
-
-set(LIBRARIES)
-
-uLib_add_shared_library(${uLib-module})

src/ltk/DenseMatrix.h

@@ -1,111 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-
-#ifndef DENSEMATRIX_H
-#define DENSEMATRIX_H
-
-#include "templates.h"
-#include "Vector.h"
-
-BEGIN_NAMESPACE(ltk)
-
-/* ////////////////////////////////////////////////////////////////////////// */
-/* //////////////////////////// MATRIX ////////////////////////////////////// */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-C_BEGIN_DECLS
-
-#define LTK_MATRIX_DECLARE_FUNC(Type,ltkType,Class_name,csize,rsize)	\
-  inline Type ltkType##_##Class_name##_get(ltkType m,			\
-					unsigned int c,			\
-					unsigned int r)			\
-  {									\
-    assert(c + r * csize < csize * rsize);				\
-    return *((ltkType)m + c + r * csize);				\
-  }									\
-  inline void ltkType##_##Class_name##_set(ltkType m,			\
-			       unsigned int c,				\
-			       unsigned int r,				\
-			       Type t)					\
-  { 									\
-    assert (c + r * csize < csize * rsize);				\
-    *((ltkType)m + c + r * csize) = t;					\
-  }									
-
-
-#define LTK_MATRIX_DECLARE(Type,Type_name,csize,rsize)	                \
-  typedef Type * Type_name;						\
-  LTK_SIMPLE_ALLOC_FUNC(Type, Type_name,ltk_matrix,csize * rsize)       \
-  LTK_MATRIX_DECLARE_FUNC(Type,Type_name,ltk_matrix,csize,rsize)
-
-C_END_DECLS
-
-#ifdef __cplusplus
-
-template <typename T, unsigned int csize, unsigned int rsize> class ltkDenseMatrix
-: public ltkAbstractBuffer< T, csize * rsize >
-{
-protected:
-    typedef ltkDenseMatrix<T, csize, rsize> ThisClass;
-    typedef ltkAbstractBuffer<T, csize * rsize> BaseClass;
-public:
-    ltkDenseMatrix() {}
-    ~ltkDenseMatrix() { }
-    
-    inline T* getBuffer() {
-	return (T*)m_buffer;
-    }
-    inline const T* getBuffer() const {
-	return (const T*)m_buffer;
-    }
-
-    ThisClass & operator =(const ThisClass &src) {
-	if (this != &src) {
-	    CType_ltk_matrix_copy(m_buffer, (const CType) src.getBuffer());
-	}
-    }
-
-    typedef struct BaseClass::CommaInit CommaInit;
-    inline CommaInit operator = (T scalar) {
-	return this->operator <<(scalar);
-    }
-
-
-private:
-    LTK_MATRIX_DECLARE(T,CType, csize, rsize);
-    T m_buffer [csize * rsize];
-};
-
-
-
-
-#endif // __cplusplus
-
-END_NAMESPACE
-
-#endif // DENSEMATRIX_H

src/ltk/Makefile.am

@@ -1,6 +0,0 @@
-include $(top_srcdir)/Common.am
-
-library_includedir = $(includedir)/libmutom-${PACKAGE_VERSION}/ltk
-library_include_HEADERS = 	ltktypes.h	\
-				ltkmacros.h     \
-				ltkdebug.h

src/ltk/Object.c

@@ -1,18 +0,0 @@
-#include "Object.h"
-
-
-static const struct _ltkObjectClass {
-  size_t class_size;
-  void (* constructor)(struct _Object *);
-  void (* destructor) (struct _Object *);
-  int  (* GetElement) (struct _Object *);
-} _ObjectClassInstance;
-
-const struct _ltkObjectClass *ltkObjectClass = &_ObjectClassInstance;
-
-ltkPointer Object_new(struct _ObjectClass klass)
-{
-  struct _Object *ob = (struct _Object)malloc(klass->class_size);
-  klass->constructor(ob);
-  return ob;
-}

src/ltk/Object.h

@@ -1,78 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#ifndef OBJECT_H
-#define OBJECT_H
-
-#include <stdlib.h>      // for std allocator   //
-#include <string.h>      // for memcpy //
-#include <assert.h>
-
-#include "templates.h"
-
-BEGIN_NAMESPACE(ltk) 
-
-
-C_BEGIN_DECLS
-
-struct _ltkObject
-{
-  int element;
-};
-
-struct _ltkObjectClass {
-  size_t class_size;
-  void (* constructor)(struct _ltkObject *);
-  void (* destructor) (struct _ltkObject *);
-  int  (* GetElement) (struct _ltkObject *);
-};
-
-struct _ltkObject *ltk_object_new() 
-{
-  return NULL;  
-}
-
-
-C_END_DECLS
-
-#ifdef __cplusplus
-
-class Object 
-{
-  struct _ltkObject *d;
-  typedef struct _ltkObject ObjectType;
- public:
- Object() : d(new ObjectType()) { d->element = 5552368; }
-  int GetElement() { return d->element; }
-};
-
-#endif
-
-
-END_NAMESPACE
-
-#endif //OBJECT_H

src/ltk/Vector.h

@@ -1,195 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-/* 
- * File:   denseVector.h
- * Author: andrea
- *
- * Created on July 6, 2012, 3:41 PM
- */
-
-#ifndef VECTOR_H
-#define	VECTOR_H
-
-#include <stdlib.h>      // for std allocator   //
-#include <string.h>      // for memcpy //
-#include <assert.h>
-
-#include "templates.h"
-
-BEGIN_NAMESPACE(ltk) 
-
-/* ////////////////////////////////////////////////////////////////////////// */
-/* //////////////////////////// VECTOR  ///////////////////////////////////// */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-C_BEGIN_DECLS
-
-#define LTK_VECTOR_DECLARE(Type,Type_name,size)				\
-    typedef Type *Type_name;						\
-    LTK_SIMPLE_ALLOC_FUNC(Type,Type_name,ltk_vector,size)                 \
-    inline unsigned int Type_name##_ltk_vector_size() { return size; }	\
-    inline Type Type_name##_ltk_vector_get(Type_name vector, unsigned int i)    \
-      { return *(vector+i); }						      \
-    inline void Type_name##_ltk_vector_set(Type_name vector, unsigned int i,    \
-      Type data) { *(vector+i) = data; }
-
-C_END_DECLS
-
-#ifdef __cplusplus
-
-template <typename T, unsigned int size> class ltkVector
-: public ltkAbstractBuffer< T, size >
-{
-    T m_vector [size];
-protected:
-    typedef ltkVector<T, size>          ThisClass;
-    typedef ltkAbstractBuffer<T, size>  BaseClass;
-public:
-    ltkVector() {}
-    ltkVector(const ltkVector<T, size> &copy) {
-	CType_ltk_vector_copy(m_vector, (const CType) copy.getBuffer());
-    }
-
-    virtual ~ltkVector() { }
-
-    inline unsigned int getSize() const {
-	return size;
-    }
-    inline T* getBuffer() {
-	return (T*)m_vector;
-    }
-    inline const T* getBuffer() const {
-	return (const T*)m_vector;
-    }
-
-
-
-    ThisClass & operator =(const ThisClass &src) {
-	if (this != &src) {
-	    CType_ltk_vector_copy(m_vector, (const CType) src.getBuffer());
-	}
-    }
-
-    typedef struct BaseClass::CommaInit CommaInit;
-    inline CommaInit operator = (T scalar) {
-	return this->operator <<(scalar);
-    }
-
-    // MATH //
-    inline bool operator ==(const ThisClass &in) {
-	int test = 0;
-	for (int i = 0; i < size; ++i) test += this->at(i) != in(i);
-	return test == 0;
-    }
-
-    inline bool operator !=(const ThisClass &in) {
-	return !this->operator ==(in);
-    }
-
-    inline void operator +=(const ThisClass &in) {
-	for (int i = 0; i < size; ++i) this->at(i) += in(i);
-    }
-    inline void operator -=(const ThisClass &in) {
-	for (int i = 0; i < size; ++i) this->at(i) -= in(i);
-    }
-    inline void operator *=(const ThisClass &in) {
-	for (int i = 0; i < size; ++i) this->at(i) *= in(i);
-    }
-    inline void operator /=(const ThisClass &in) {
-	for (int i = 0; i < size; ++i) this->at(i) /= in(i);
-    }
-
-    inline void operator +=(const T t) {
-	for (int i = 0; i < size; ++i) this->at(i) += t;
-    }
-    inline void operator -=(const T t) {
-	for (int i = 0; i < size; ++i) this->at(i) -= t;
-    }
-    inline void operator *=(const T t) {
-	for (int i = 0; i < size; ++i) this->at(i) *= t;
-    }
-    inline void operator /=(const T t) {
-	for (int i = 0; i < size; ++i) this->at(i) /= t;
-    }
-
-    inline ThisClass & operator + (const ThisClass &in) {
-	ThisClass *out = new ThisClass();
-	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) + in(i);
-	return *out;
-    }
-    inline ThisClass & operator - (const ThisClass &in) {
-	ThisClass *out = new ThisClass();
-	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) - in(i);
-	return *out;
-    }
-
-    // fix with constructor and product null element ------------- //
-    inline T operator * (const ThisClass &in) {
-	T out = 0;
-	for (int i = 0; i < size; ++i) out += this->at(i) * in(i);
-	return out;
-    }
-    inline T operator / (const ThisClass &in) {
-	T out = 0;
-	for (int i = 0; i < size; ++i) out += this->at(i) / in(i);
-	return out;
-    }
-    // ------------------------------------------------------------- //
-
-    inline ThisClass & operator +(const T t) {
-	ThisClass *out = new ThisClass();
-	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) + t;
-	return *out;
-    }
-    inline ThisClass & operator -(const T t) {
-	ThisClass *out = new ThisClass();
-	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) - t;
-	return *out;
-    }
-    inline ThisClass & operator *(const T t) {
-	ThisClass *out = new ThisClass();
-	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) * t;
-	return *out;
-    }
-    inline ThisClass & operator /(const T t) {
-      ThisClass *out = new ThisClass();
-      for (int i = 0; i < size; ++i) out->at(i) = this->at(i) / t;
-      return *out;
-    }
-private:
-    LTK_VECTOR_DECLARE(T,CType, size)
-};
-
-#endif // __cplusplus
-
-
-
-
-END_NAMESPACE // ltk
-#endif	/* DENSEVECTOR_H */
-

src/ltk/container.h

@@ -1,43 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-/* 
- * File:   comma_init.h
- * Author: andrea
- *
- * Created on May 24, 2012, 3:12 PM
- */
-
-#ifndef CONTAINER_H
-#define	CONTAINER_H
-
-#include <assert.h>
-
-
-
-#endif	/* CONTAINER_H */
-

src/ltk/ltk.h

@@ -1,32 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-
-
-#include "templates.h"
-#include "Vector.h"
-#include "DenseMatrix.h"

src/ltk/ltk_bridge/ltkb.c

@@ -1,339 +0,0 @@
-//#include <linux/config.h>
-#include <linux/version.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/fs.h>
-#include <linux/cdev.h>
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-#include <linux/mm.h>
-#include <linux/ioctl.h>
-#ifdef MODVERSIONS
-#  include <linux/modversions.h>
-#endif
-#include <asm/io.h>
-#include <asm/system.h>
-#include <asm/uaccess.h>
-
-
-
-/* methods of the character device */
-static int ltkb_open(struct inode *inode, struct file *filp);
-static int ltkb_release(struct inode *inode, struct file *filp);
-static int ltkb_mmap(struct file *filp, struct vm_area_struct *vma);
-static ssize_t ltkb_read(struct file *filp,
-			 char __user *buffer,
-			 size_t count,
-			 loff_t *offp);
-static ssize_t ltkb_write(struct file *filp,
-			  const char __user *buffer,
-			  size_t count,
-			  loff_t *offp);
-
-
-// internal data
-// length of the two memory areas
-#define NPAGES 16
-// pointer to the vmalloc'd area - alway page aligned
-static int *vmalloc_area;
-// pointer to the kmalloc'd area, rounded up to a page boundary
-static int *kmalloc_area;
-// original pointer for kmalloc'd area as returned by kmalloc
-static void *kmalloc_ptr;
-
-
-#define BUF_LEN 80
-static int Device_Open = 0;
-
-static char Message[BUF_LEN];
-/*
- * How far did the process reading the message get?
- * Useful if the message is larger than the size of the
- * buffer we get to fill in device_read.
- */
-static char *Message_Ptr;
-
-
-struct ltkb_dev {
-  struct cdev cdev;              // device structure
-  struct semaphore semaphore;    // lock semaphore for race control
-  char *message;                 // message passing from/to user
-  unsigned int size;             // size of data stored
-  unsigned int acl_key;          // user access control
-};
-
-struct ltkb_dev *_ltkb_devices;   // devices array //
-
-
-
-
-
-/////// OPEN AND RELEASE ///////////////////////////////////////////////////////
-static int ltkb_open(struct inode *inode, struct file *filp)
-{
-  // insert cdev data in dev structure and file->private_data //
-  struct ltkb_dev *dev;
-  dev = container_of (inode->i_cdev, struct ltkb_dev, cdev);
-
-  // this shares dev for all methods //
-  filp->private_data = dev;
-
-  pr_debug("ltk bridge opened");
-  return 0;
-}
-/* character device last close method */
-static int ltkb_release(struct inode *inode, struct file *filp)
-{
-  pr_debug("ltk bridge released");
-  return 0;
-}
-// -------------------------------------------------------------------------- //
-
-
-
-// kmalloc instancer //
-int ltkb_kmem(struct file *filp, struct vm_area_struct *vma)
-{
-  int ret;
-  long length = vma->vm_end - vma->vm_start;
-
-  /* check length - do not allow larger mappings than the number of
-     pages allocated */
-  if (length > NPAGES * PAGE_SIZE)
-    return -EIO;
-
-  /* map the whole physically contiguous area in one piece */
-  if ((ret = remap_pfn_range(vma,
-			     vma->vm_start,
-			     virt_to_phys((void *)kmalloc_area) >> PAGE_SHIFT,
-			     length,
-			     vma->vm_page_prot)) < 0) {
-    return ret;
-  }
-  return 0;
-}
-// vmalloc instancer //
-int ltkb_vmem(struct file *filp, struct vm_area_struct *vma)
-{
-  int ret;
-  long length = vma->vm_end - vma->vm_start;
-  unsigned long start = vma->vm_start;
-  char *vmalloc_area_ptr = (char *)vmalloc_area;
-  unsigned long pfn;
-
-  /* check length - do not allow larger mappings than the number of
-     pages allocated */
-  if (length > NPAGES * PAGE_SIZE)
-    return -EIO;
-
-  /* loop over all pages, map it page individually */
-  while (length > 0) {
-    pfn = vmalloc_to_pfn(vmalloc_area_ptr);
-    if ((ret = remap_pfn_range(vma, start, pfn, PAGE_SIZE,
-			       PAGE_SHARED)) < 0) {
-      return ret;
-    }
-    start += PAGE_SIZE;
-    vmalloc_area_ptr += PAGE_SIZE;
-    length -= PAGE_SIZE;
-  }
-  return 0;
-}
-
-
-
-// mmap function //
-static int ltkb_mmap(struct file *filp, struct vm_area_struct *vma)
-{
-  /* at offset 0 we map the vmalloc'd area */
-  if (vma->vm_pgoff == 0) {
-    return ltkb_vmem(filp, vma);
-  }
-  /* at offset NPAGES we map the kmalloc'd area */
-  if (vma->vm_pgoff == NPAGES) {
-    return ltkb_kmem(filp, vma);
-  }
-  /* at any other offset we return an error */
-  return -EIO;
-}
-
-
-
-
-////////////// CHAR DEVICE READ/WRITE  /////////////////////////////////////////
-static ssize_t ltkb_read(struct file *filp,	/* see include/linux/fs.h   */
-			 char __user *buffer,	/* buffer to fill with data */
-			 size_t length,	/* length of the buffer     */
-			 loff_t * offset)
-{
-
-#ifdef _DEBUG
-  printk(KERN_INFO "device_read(%p,%s,%d)", filp, buffer, (int)length);
-#endif
-  
-  return 0;
-}
-
-static ssize_t ltkb_write(struct file *filp,
-			  const char __user *buffer,
-			  size_t length,
-			  loff_t * offset)
-{
-#ifdef _DEBUG
-  printk(KERN_INFO "device_write(%p,%s,%d)", filp, buffer, (int)length);
-#endif
-  return 0;
-}
-// -------------------------------------------------------------------------  //
-
-
-#define LTKB_IOC_HEADER 'b'
-
-#define LTKB_IOC_RESET _IO(LTKB_IOC_HEADER, 0)
-#define LTKB_IOC_PING  _IOWR(LTKB_IOC_HEADER, 1, char)
-
-#define LTKB_IOC_MAXNR 1
-
-////////////// IOCTL ///////////////////////////////////////////////////////////
-int ltkb_ioctl(struct inode *inode, struct file *filp, 
-	       unsigned int cmd, unsigned long arg)
-{
-  char c = 0;
-  int retval = 0;
-
-  /*
-   * extract the type and number bitfields, and don't decode
-   * wrong cmds: return ENOTTY (inappropriate ioctl) before access_ok()
-   */
-  if (_IOC_TYPE(cmd) != LTKB_IOC_HEADER) return -ENOTTY;
-  if (_IOC_NR(cmd) > LTKB_IOC_MAXNR) return -ENOTTY;
-
-  // TODO user access control //
-
-
-  switch(cmd) {
-  case LTKB_IOC_RESET:
-    if(!capable(CAP_SYS_ADMIN))
-      return -EPERM;
-    // TODO free all memory mapping//
-    break;
-  case LTKB_IOC_PING:
-    retval = __get_user(c,(char __user *)arg);
-    c++;    
-    retval = __put_user(c,(char __user *)arg);
-    break;
-  default:
-    return -ENOTTY;
-  }
-  return retval;
-
-}
-// -------------------------------------------------------------------------  //
-
-
-
-
-
-#ifndef LTKB_MAJOR
-#define LTKB_MAJOR 0
-#endif
-
-#ifndef LTKB_NR_DEVS
-#define LTKB_NR_DEVS 4
-#endif
-
-#ifndef LTKB_DEVICE_NAME
-#define LTKB_DEVICE_NAME "ltkb"
-#endif
-
-
-
-/* the file operations, i.e. all character device methods */
-static struct file_operations ltkb_fops = {
-  .open = ltkb_open,
-  .release = ltkb_release,
-  .read = ltkb_read,
-  .write = ltkb_write,
-  .ioctl = ltkb_ioctl,
-  .mmap = ltkb_mmap,
-  .owner = THIS_MODULE,
-};
-
-static int _ltkb_major_number = LTKB_MAJOR;
-
-// Module init function ////////////////////////////////////////////////////////
-static int __init ltkb_init(void)
-{
-  int i,ret = 0;
-  dev_t dev = 0;
-
-  // REGISTER DEVICE //
-  if(_ltkb_major_number)
-    {
-      dev = MKDEV(_ltkb_major_number,0);
-      ret = register_chrdev_region(dev, LTKB_NR_DEVS, LTKB_DEVICE_NAME);
-    }
-  else {
-    ret = alloc_chrdev_region(&dev, 0, LTKB_NR_DEVS, LTKB_DEVICE_NAME );
-    _ltkb_major_number = MAJOR(dev);
-  }
-  if (ret < 0) {
-    printk(KERN_WARNING "could not allocate major number %d for ltkb\n",
-	   _ltkb_major_number);
-    return ret;
-  }
-
-  // ALLOCATE DEVICES //
-  _ltkb_devices = kmalloc( LTKB_NR_DEVS * sizeof(struct ltkb_dev), GFP_KERNEL );
-  if(!_ltkb_devices) {
-    printk(KERN_ERR "error allocating device structure in memory");
-    return -ENOMEM;
-  }
-  memset(_ltkb_devices, 0, LTKB_NR_DEVS * sizeof(struct ltkb_dev));
-
-  // SETUP DEVICES //
-  for (i = 0 ; i < LTKB_NR_DEVS ; i++ )
-    {
-      struct ltkb_dev *dev = &_ltkb_devices[i];
-      int devno = MKDEV(_ltkb_major_number, i);
-      cdev_init (&dev->cdev, &ltkb_fops);
-      dev->cdev.owner = THIS_MODULE;
-      dev->cdev.ops = &ltkb_fops;
-      ret = cdev_add(&dev->cdev,devno,1);
-      if(ret) printk(KERN_NOTICE "Error %d adding ltkb%d device", ret, i);
-      init_MUTEX(&dev->semaphore);
-    }
-  printk( KERN_NOTICE "ltk bridge module loaded");
-  return ret;
-}
-
-// module release //
-static void __exit ltkb_exit(void)
-{
-  // remove the character deivce //
-  int i;
-  dev_t devno = MKDEV(_ltkb_major_number,0);
-  if(_ltkb_devices)
-    {
-      for(i=0;i<LTKB_NR_DEVS;i++)
-	cdev_del(&_ltkb_devices[i].cdev);
-      kfree(_ltkb_devices);
-    }
-  unregister_chrdev_region(devno,LTKB_NR_DEVS);
-  printk( KERN_NOTICE "ltk bridge module unloaded");
-}
-//  ------------------------------------------------------------------------  //
-
-
-
-
-//////////////////// Main Module Init ///////////////////
-						       //
-module_init(ltkb_init);                                //
-module_exit(ltkb_exit);                                //
-						       //
-MODULE_DESCRIPTION("ltk bridge memory dispatcher");    //
-MODULE_AUTHOR("andrea");                               //
-MODULE_LICENSE("Not licenced yet");                    //
-						       //
-/////////////////////////////////////////////////////////

src/ltk/ltk_bridge/ltkb_test.c

@@ -1,40 +0,0 @@
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/ioctl.h>
-
-#define LTKB_IOC_HEADER 'b'
-
-#define LTKB_IOC_RESET _IO(LTKB_IOC_HEADER, 0)
-#define LTKB_IOC_PING  _IOWR(LTKB_IOC_HEADER, 1, char)
-
-#define LTKB_IOC_MAXNR 1
-
-
-int main(void)
-{
-  int fd;
-
-  if ((fd=open("ltkb0", O_RDWR|O_SYNC))<0)
-  {
-      perror("open");
-      exit(-1);
-  }
-
-  char buffer[200] = "hello";
-  write(fd, (void *)&buffer, 6);
-
-  char c = 'a';
-  printf("%c ",c);
-  ioctl(fd, LTKB_IOC_PING, &c);
-  printf("%c ",c);
-  ioctl(fd, LTKB_IOC_PING, &c);
-  printf("%c\n",c);
-  close(fd);
-  return(0);
-}
-

src/ltk/ltk_bridge/setup.sh

@@ -1,21 +0,0 @@
-#!/bin/sh
-module="ltkb"
-device="ltkb"
-mode="664"
-
-/sbin/insmod ./$module.ko $* || exit 1
-
-rm -f ./${device}[0-3]
-
-major=$(awk "\$2==\"$module\" {print \$1}" /proc/devices)
-
-mknod ./${device}0 c $major 0
-mknod ./${device}1 c $major 1
-mknod ./${device}2 c $major 2
-mknod ./${device}3 c $major 3
-
-group="mutom"
-grep -q '^mutom:' /etc/group || group="adm"
-
-chgrp $group ./${device}[0-3]
-chmod $mode ./${device}[0-3]

src/ltk/ltkdebug.c

@@ -1,4 +0,0 @@
-
-#include "ltkdebug.h"
-
-

src/ltk/ltkdebug.h

@@ -1,105 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#ifndef LTKDEBUG_H
-#define LTKDEBUG_H
-
-
-#include "ltkmacros.h"
-#include "ltktypes.h"
-
-//! Provide a string for current function, non-concatenatable
-#if defined (__GNUC__) || (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 19901L)
-#  define __func_to_string__     ((const char*) (__func__))
-#else
-#  define __func_to_string__  ((const char*) ("???"))
-#endif
-
-//! Provide a string for current function in pretty format, non-concatenatable
-#if defined (__GNUC__)
-#  define __pfunc_to_string__     ((const char*) (__PRETTY_FUNCTION__))
-#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 19901L
-#  define __pfunc_to_string__  ((const char*) (__func__))
-#else
-#  define __pfunc_to_string__  ((const char*) ("???"))
-#endif
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-//// Pragma Messages for debug allerts during compilation  /////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-#ifdef PRAGMA_MESSAGES
-#define DEBUG_DO_PRAGMA(x) _Pragma (#x)
-#else
-#define DEBUG_DO_PRAGMA(x) ;
-#endif
-
-#define TODO(x) DEBUG_DO_PRAGMA(message ("\n\n [TODO] >> " #x " <<\n"))
-#define OPTIMIZE(x) DEBUG_DO_PRAGMA(message ("\n\n [OPTIMIZE]  > " #x " <\n"))
-#define DUMP(x) DEBUG_DO_PRAGMA(message ("\n\n [DUMP]  > " #x " <\n"))
-
-//  ------------------------------------------------------------------------  //
-
-
-
-C_BEGIN_DECLS
-
-
-typedef enum
-{
-    LOG_FLAG_ACTIVE = 1 << 0,
-            LOG_FLAG_FATAL = 1 << 1,
-            LOG_LEVEL_ERROR = 1 << 2,
-            LOG_LEVEL_CRITICAL = 1 << 3,
-            LOG_LEVEL_WARNING = 1 << 4,
-            LOG_LEVEL_MESSAGE = 1 << 5,
-            LOG_LEVEL_INFO = 1 << 6,
-            LOG_LEVEL_DEBUG = 1 << 7,
-            LOG_LEVEL_ANNOING = 1 << 8,
-            LOG_LEVEL_PARANOID = 1 << 9
-} LogLevelFlags;
-
-
-
-
-void debug_log(
-            void *handler,
-            LogLevelFlags flags,
-            const char *function_name,
-            const char *message,
-            ...);
-
-
-
-C_END_DECLS
-
-
-
-
-#endif // LTKDEBUG_H

src/ltk/ltkmacros.h

@@ -1,61 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-/* 
- * File:   macros.h
- * Author: andrea
- *
- * Created on May 23, 2012, 9:01 AM
- */
-
-#ifndef LTK_MACROS_H
-#define	LTK_MACROS_H
-
-// C code in headers, while including them from C++
-#ifdef  __cplusplus
-
-# define C_BEGIN_DECLS  extern "C" {
-# define C_END_DECLS    }
-
-#define BEGIN_NAMESPACE(name) namespace name {
-#define END_NAMESPACE         }
-
-#else
-
-# define C_BEGIN_DECLS
-# define C_END_DECLS
-
-#define BEGIN_NAMESPACE(name)
-#define END_NAMESPACE
-
-#endif
-
-
-
-
-#endif	/* MACROS_H */
-

src/ltk/ltktypes.h

@@ -1,127 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#ifndef LTK_TYPE_H
-#define LTK_TYPE_H
-
-#include <assert.h>
-#include <sys/types.h>
-
-//#include "templates.h"
-#include "ltkmacros.h"
-
-#ifdef __cplusplus
-# define LTK_TYPECAST(T, Type) static_cast< T >(Type)
-#else
-# define LTK_TYPECAST(T, Type) ((T)(Type))
-#endif
-
-
-BEGIN_NAMESPACE(ltk) 
-
-C_BEGIN_DECLS
-
-/* ////////////////////////////////////////////////////////////////////////// */
-/* //////////////////////////// TYPE DEFINITIONS   ////////////////////////// */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-
-typedef void *     Pointer_t;
-typedef id_t       Id_t;
-typedef size_t     Size_t;
-
-#ifndef LTK_DOUBLE_PRECISION
-typedef float      Real_t;
-#else
-typedef double     Real_t;
-#endif
-
-#define LTK_SIGNED_CHAR_MIN        LTK_TYPECAST(signed char, 0x80)
-#define LTK_SIGNED_CHAR_MAX        LTK_TYPECAST(signed char, 0x7f)
-
-#define LTK_UNSIGNED_CHAR_MIN      LTK_TYPECAST(unsigned char, 0u)
-#define LTK_UNSIGNED_CHAR_MAX      LTK_TYPECAST(unsigned char, 0xffu) 
-
-#define LTK_SHORT_MIN              LTK_TYPECAST(short, 0x8000)
-#define LTK_SHORT_MAX              LTK_TYPECAST(short, 0x7fff)
-
-#define LTK_UNSIGNED_SHORT_MIN     LTK_TYPECAST(unsigned short, 0u)
-#define LTK_UNSIGNED_SHORT_MAX     LTK_TYPECAST(unsigned short, 0xffffu)
-
-#define LTK_INT_MIN                LTK_TYPECAST(int, ~(~0u >> 1))
-#define LTK_INT_MAX                LTK_TYPECAST(int, ~0u >> 1)
-
-#define LTK_INT8_MIN               LTK_TYPECAST(int8_t, 0x80)
-#define LTK_INT8_MAX               LTK_TYPECAST(int8_t,  0x7f)
-
-#define LTK_INT16_MIN              LTK_TYPECAST(int16_t,  0x8000u)
-#define LTK_INT16_MAX              LTK_TYPECAST(int16_t,  0x7fffu)
-
-#define LTK_UNSIGNED_INT16_MIN     LTK_TYPECAST(int16_t, 0u)
-#define LTK_UNSIGNED_INT16_MAX     LTK_TYPECAST(unsigned int16_t, 0xffffu)
-
-#define LTK_INT32_MIN              LTK_TYPECAST(int32_t,  0x80000000u)
-#define LTK_INT32_MAX              LTK_TYPECAST(int32_t,  0x7fffffffu)
-
-#define LTK_UNSIGNED_INT32_MIN     LTK_TYPECAST(unsigned int32_t, 0u)
-#define LTK_UNSIGNED_INT32_MAX     LTK_TYPECAST(unsigned int32_t, 0xffffffffu)
-
-#define LTK_INT64_MIN              LTK_TYPECAST(int64_t, 0x8000000000000000u)
-#define LTK_INT64_MAX              LTK_TYPECAST(int64_t, 0x7fffffffffffffffu)
-
-#define LTK_UNSIGNED_INT8_MIN      LTK_TYPECAST(int8_t, 0u)
-#define LTK_UNSIGNED_INT8_MAX      LTK_TYPECAST(int8_t, 0xffu)
-
-#define LTK_UNSIGNED_INT64_MIN     LTK_TYPECAST(unsigned int64_t, 0u)
-#define LTK_UNSIGNED_INT64_MAX     LTK_TYPECAST(unsigned int64_t, \
-                                                0xffffffffffffffffu)
-
-#define LTK_UNSIGNED_INT_MIN       LTK_TYPECAST(unsigned int, 0)
-#define LTK_UNSIGNED_INT_MAX       LTK_TYPECAST(unsigned int, ~0u)
-
-#define LTK_LONG_MIN               LTK_TYPECAST(long, ~(~0ul >> 1))
-#define LTK_LONG_MAX               LTK_TYPECAST(long, ~0ul >> 1)
-
-#define LTK_UNSIGNED_LONG_MIN      LTK_TYPECAST(unsigned long, 0ul)
-#define LTK_UNSIGNED_LONG_MAX      LTK_TYPECAST(unsigned long, ~0ul)
-
-#define LTK_FLOAT_MIN              LTK_TYPECAST(float, -1.0e+38f)
-#define LTK_FLOAT_MAX              LTK_TYPECAST(float, 1.0e+38f)
-
-#define LTK_DOUBLE_MIN             LTK_TYPECAST(double, -1.0e+299)
-#define LTK_DOUBLE_MAX             LTK_TYPECAST(double, 1.0e+299)
-
-
-
-
-
-C_END_DECLS
-
-END_NAMESPACE
-
-
-#endif //TYPE_H

src/ltk/main.C

@@ -1,35 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-
-#include "Object.h"
-
-
-int main()
-{
-  return 0;
-}

src/ltk/main.c

@@ -1,72 +0,0 @@
-
-#include "DenseMatrix.h"
-#include "Vector.h"
-#include "Object.h"
-
-#include "vectormath/simd/instrset.h"
-
-/* LTK_VECTOR_DECLARE(int,LtkInt4,4) */
-
-/* LTK_MATRIX_DECLARE(int,LtkInt2x2,2,2) */
-/* LTK_MATRIX_DECLARE(int,LtkInt4x1,4,1) */
-/* LTK_MATRIX_DECLARE(int,LtkInt4x4,4,4) */
-
-int test(int a) { return 0; }
- 
-
-int main(void)
-{
-
-  // testing dense matrix //
-  /****************************************************/
-  /* LtkInt2x2 a;				      */
-  /* LtkInt4x1 b;				      */
-  /* LtkInt4x4 c;				      */
-  /* LtkInt4 v, w;				      */
-  /* 						      */
-  /* v = LtkInt4_ltk_vector_new ();		      */
-  /* w = LtkInt4_ltk_vector_new ();		      */
-  /* 						      */
-  /* int i;					      */
-  /* for (i = 0; i < LtkInt4_ltk_vector_size (); ++i) */
-  /*   {					      */
-  /*     LtkInt4_ltk_vector_set (v, i, 0);	      */
-  /*     LtkInt4_ltk_vector_set (w, i, 3);	      */
-  /*   }					      */
-  /* 						      */
-  /* printf ("v = ");				      */
-  /* for (i = 0; i < 4; ++i)			      */
-  /*   printf ("%d ", LtkInt4_ltk_vector_get (v, i)); */
-  /* printf ("\n");				      */
-  /* 						      */
-  /* printf ("w = ");				      */
-  /* for (i = 0; i < 4; ++i)			      */
-  /*   printf ("%d ", LtkInt4_ltk_vector_get (w, i)); */
-  /* printf ("\n");				      */
-  /****************************************************/
-
-  // testing intrinsics //
-  printf("INSTRUCTION SET -> %d\n",INSTRSET);
-  __m128 aligned_float = _mm_setzero_ps();
-  float *p = &aligned_float;
-  printf("%f,%f,%f,%f\n",p[0],p[1],p[2],p[3]);
-
-  // adder //
-  __m128 a_1,a_2;
-  a_1 = _mm_set_ps(3,3,3,3);
-  a_2 = _mm_set_ps(1,2,3,4);
-
-
-  aligned_float = _mm_add_ps(a_1,a_2);
-  p = &aligned_float; printf("%f,%f,%f,%f\n",p[0],p[1],p[2],p[3]);
-
-
-
-  // testing Objects //
-  //LTK_MATRIX_DECLARE(TypeName, type, r, c);
-  // Object *ob = New(ObjectClass);
-  // int el = ObjectClass->GetElement(ob);
-  
-
-  return 0;
-}

src/ltk/templates.c

@@ -1,92 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "templates.h"
-
-
-LtkList ltk_list_new()
-{
-  LtkList list = malloc(sizeof(struct _template_list));
-  list->size = 0;
-  list->start = NULL;
-  list->end = NULL;
-  return list;
-}
-
-void ltk_list_nodepush(LtkList list,LtkListNode node)
-{
-  if(list == NULL) return;
-  node->next = list->start;
-  list->start = node;
-  if(list->end == NULL) list->end = node;
-  list->size++;
-}
-
-LtkListNode ltk_list_get_start(LtkList list)
-{
-  if (list==NULL || list->start==NULL) return NULL;
-  return list->start;
-}
-
-LtkListNode ltk_list_get_end(LtkList list)
-{
-  if (list==NULL || list->end==NULL) return NULL;
-  return list->end;
-}
-
-void ltk_list_remove(LtkList list,LtkListNode node)
-{
-  if (list == NULL || list->start==NULL) return;
-  struct _template_list_node *node_tofree,*prev;
-  node_tofree=list->start;
-  while (node_tofree != node) {
-    if(node_tofree->next == NULL) return;
-    prev = node_tofree;
-    node_tofree = node_tofree->next;
-  }
-  if(node_tofree == list->start) list->start = node_tofree->next;
-  else prev->next = node_tofree->next;
-  free(node_tofree);
-}
-
-void ltk_list_pop_start(LtkList list)
-{
-  if (list==NULL || list->start==NULL) return;
-  struct _template_list_node *nodetofree;
-  nodetofree=list->start;
-  list->start = list->start->next;
-  free(nodetofree);
-}
-
-void ltk_list_pop_end(LtkList list)
-{
-  if (list==NULL || list->end==NULL) return;
-  struct _template_list_node *iter;
-  iter=list->start;
-  if(iter==list->end) {
-    free(iter);
-    list->start = list->end = NULL;
-  }
-  else { 
-    while(iter->next!=list->end) iter=iter->next;
-    free(iter->next);
-    iter->next = NULL;
-    list->end = iter;
-  }
-  list->size--;
-}
-
-int ltk_list_get_size(LtkList list)
-{
-  if(list==NULL) return 0;
-  return list->size;
-}
-
-
-LtkListIterator ltk_list_iterator_new(LtkList list)
-{
-  if(list==NULL || list->start == NULL) return NULL;
-  return (LtkListIterator)list->start;
-}
-
-

src/ltk/templates.h

@@ -1,303 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-/* 
- * <one line to give the program's name and a brief idea of what it does.>
- * Copyright (C) 2012  Andrea Rigoni Garola <andrea.rigoni@pd.infn.it>
- * 
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or (at
- * your option) any later version.
- * 
- * This program 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
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- * 
- */
-
-
-#ifndef TEMPLATES_H
-#define TEMPLATES_H
-
-#include <stdlib.h>      // for std allocator   //
-#include <string.h>      // for memcpy //
-#include <assert.h>
-
-#include "ltkmacros.h"      // default environment //
-#include "container.h"   // TODO !!! //
-
-#include <stdio.h>
-
-
-
-
-
-/* ////////////////////////////////////////////////////////////////////////// */
-/* //////////////////////////// ALLOC FUNCTIONS ///////////////////////////// */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-C_BEGIN_DECLS
-
-//inline ltkPointer ltk_malloc(unsigned int size) { return malloc(size); }
-//inline void       ltk_free  (ltkPointer ptr)    { free(ptr); }
-
-#define LTK_SIMPLE_ALLOC_FUNC(Type, ltkType, Class_name, size)		\
-  inline ltkType ltkType##_##Class_name##_new()				        \
-  {									\
-    return LTK_TYPECAST(ltkType, malloc(sizeof(Type) * size));     	\
-  }                                                                 \
-  inline void ltkType##_##Class_name##_delete(ltkType t)		    \
-  { free(t); }								                        \
-  inline void ltkType##_##Class_name##_copy(ltkType dst, const ltkType src) \
-  { memcpy((ltkPointer)dst, (ltkPointer)src, sizeof(Type) * size ); }
-
-C_END_DECLS
-
-
-
-
-
-/* ////////////////////////////////////////////////////////////////////////// */
-/* //////////////////////////// ABSTRACT C BUFFER /////////////////////////// */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-C_BEGIN_DECLS
-
-#define LTK_ABSTRACT_BUFFER_DECLARE_FUNC(Type,ltkType,Class_name,size)        \
-  inline int ltkType##_##Class_name##_size() { return size; }                 \
-  inline Type ltkType##_##Class_name##_get(ltkType v, unsigned int c)         \
-   { assert(c < size); return *((ltkType)m + c); }                            \
-  inline void ltkType##_##Class_name##_set(ltkType v, Type t, unsigned int c) \
-   { assert(c < size); *((ltkType)m + c) = t; }
-
-// FINIRE !!! //
-
-C_END_DECLS
-
-#ifdef __cplusplus
-
-template <typename T, unsigned int size> class ltkAbstractBuffer
-{
-  typedef ltkAbstractBuffer<T, size> ThisClass;  
-protected:
-    typedef T ContentType;
-    virtual       T* getBuffer()       = 0;
-    virtual const T* getBuffer() const = 0;
-
-    struct CommaInit
-    {
-	inline explicit CommaInit(ltkAbstractBuffer<T, size> *container,float s)
-	: container(container) {
-	    this->index = 0;
-	    this->container->getBuffer()[0] = s;
-	}
-	inline CommaInit & operator, (float s) {
-	    this->index++;
-	    assert(index < size);
-	    this->container->getBuffer()[this->index] = s;
-	    return *this;
-	}
-	ltkAbstractBuffer<T, size> *container;
-	unsigned int index;
-    };
-
-public:
-    inline CommaInit operator =(T scalar) {
-	return CommaInit(this, scalar);
-    }
-    inline CommaInit operator <<(T scalar) {
-	return CommaInit(this, scalar);
-    }    
-
-    inline T& at(const unsigned int i) {
-	return *(this->getBuffer() + i);
-    }
-
-    inline T & operator[](unsigned int i) {
-	return *(this->getBuffer() + i);
-    }
-    inline const T & operator[](unsigned int i) const {
-	return *(this->getBuffer() + i);
-    }
-    inline T & operator()(unsigned int i) {
-	return *(this->getBuffer() + i);
-    }
-    inline const T & operator()(unsigned int i) const {
-	return *(this->getBuffer() + i);
-    }
-
-
-};
-
-#endif // __cplusplus
-
-
-/* ////////////////////////////////////////////////////////////////////////// */
-/* //////////////////////////// ARRAY /////////////////////////////////////// */
-/* ////////////////////////////////////////////////////////////////////////// */
-
-// COMING SOON //
-
-
-
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-/// DO NOT USE ANYTHING AFTER THIS LINE ... EXPERIMENTAL      //////////////////
-
-
-
-
-
-
-
-
-
-/* ////////////////////////////////////////////////////////////////////////// */
-/* //////////////////////////// CIRCULAR BUFFER ///////////////////////////// */
-/* ////////////////////////////////////////////////////////////////////////// */
-/* CIRCULAR BUFFER */
-
-struct _ltk_template_buffer {
-  void *pos;
-  void *head;
-};
-
-#define LTK_BUFFER_DECLARE(Type, Type_name, size, overlap) \
-typedef struct _ltk_template_buffer *Type_name;                                \
-inline Type_name Type_name##_ltk_buffer_new()                                  \
-{ Type_name out = (Type_name)ltk_malloc                                        \
-                  (sizeof(Type) * (size + overlap) + 2);                       \
-  out->head = (void *)out + 2 + overlap * sizeof(Type); \
-  out->pos = out->head; \
-return out;              }                     \
-inline void Type_name##_ltk_buffer_free(Type_name buffer) { ltk_free(buffer); }\
-
-
-
-// TO BE CONTINUED.... //
-
-
-
-
-
-
-
-
-///// LtkPTree ////////
-
-struct _LtkPTreeNode
-{
-  struct _LtkPTreeNode *parent;
-};
-typedef struct _LtkPTreeNode *LtkPtree;
-
-
-
-
-
-
-
-
-
-
-
-
-/*
-  one way list template usable as FIFO or LIFO by macros
-  Element must be a pointer to a real allocated object.
-*/
-// this acts as dummy node, never really instanciated //
-struct _template_list_node { 
-  struct _template_list_node *next; 
-};
-typedef struct _template_list_node *LtkListNode;
-#define LTK_LIST_HEADER LtkListNode ltk_list_node_next;
-
-struct _template_list {
-  int size;
-  struct _template_list_node *start;
-  struct _template_list_node *end;
-};
-
-typedef struct _template_list *LtkList;
-typedef struct _template_list_node *LtkListIterator;
-
-LtkList ltk_list_new();
-void ltk_list_nodepush(LtkList list,LtkListNode node);
-LtkListNode ltk_list_get_start(LtkList list);
-LtkListNode ltk_list_get_end(LtkList list);
-void ltk_list_remove(LtkList list,LtkListNode node);
-void ltk_list_pop_start(LtkList list);
-void ltk_list_pop_end(LtkList list);
-
-
-#define LTK_LIST_DECLARE(Type,Type_name) \
-    static LtkList (* Type_name##_list_new)(void) = ltk_list_new;\
-    void    (* Type_name##_list_nodepush)(LtkList list, Type *node) = (void (*)(LtkList, Type *))ltk_list_nodepush; \
-    Type *  (* Type_name##_list_get_start)(LtkList list)            = (Type *(*)(LtkList))ltk_list_get_start;       \
-    Type *  (* Type_name##_list_get_end)(LtkList list)              = (Type *(*)(LtkList))ltk_list_get_end;         \
-    void    (* Type_name##_list_remove)(LtkList list, Type *node)   = (void (*)(LtkList, Type *))ltk_list_remove;   \
-    void    (* Type_name##_list_pop_start)(LtkList list)            = (void (*)(LtkList))ltk_list_pop_start;        \
-    void    (* Type_name##_list_pop_end)(LtkList list)              = (void (*)(LtkList))ltk_list_pop_end;
-
-#define LTK_LIST_DECLARE_KEYACCESS(Type,Type_name,KeyType,key_member_name,key_function) \
-    Type * Type_name##_list_key_lookup(LtkList list, KeyType key)  { \
-    LtkListIterator iter = ltk_list_iterator_new(list);             \
-    while(iter) { \
-    if (key_function( ((Type *)iter)->key_member_name, key )) \
-    return (Type *)iter; \
-    iter = iter->next; } \
-    return NULL; } \
-    \
-    void Type_name##_list_key_remove(LtkList list, KeyType key) { \
-    LtkListNode node = (LtkListNode)Type_name##_list_key_lookup(list,key); \
-    if(node) ltk_list_remove(list,node); } \
-
-
-LtkListIterator ltk_list_iterator_new(LtkList list);
-
-#endif // TEMPLATES_H

src/ltk/test_comma.h

@@ -1,117 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-/* 
- * File:   test_comma.h
- * Author: andrea
- *
- * Created on May 24, 2012, 4:47 PM
- */
-
-#ifndef TEST_COMMA_H
-#define	TEST_COMMA_H
-
-#include <assert.h>
-
-struct Vector3
-{
-    union
-    {
-	struct { float x, y, z; };
-	float data[3];
-    };
-
-   struct CommaAssign;
-
-    CommaAssign operator=(float _x)
-   {
-      x = _x;
-      return CommaAssign(this,1);
-   }
-
-   struct CommaAssign
-    {
-	Vector3 *vec3;
-	int index;
-
-	explicit CommaAssign(Vector3 *vec3, int index) : vec3(vec3) {
-	    this->index = index;
-	}
-	CommaAssign operator, (float f) {
-	    vec3->data[index] = f;
-	    return CommaAssign(vec3, index + 1);
-	}
-
-    };
-
-};
-
-
-
-struct Container
-{
-    union
-    {
-	struct { float x, y, z; };
-	float data[3];
-    };
-
-    inline float *getBuffer() {
-	return this->data;
-    }
-
-   template <typename T, unsigned int size> class CommaAssign
-    {
-    private:
-	T *container;
-	int index;
-
-    public:
-	inline explicit CommaAssign(T *container, float s) : container(container) {
-	    this->index = 0;
-	    this->container->getBuffer()[0] = s;
-	}
-
-	inline CommaAssign& operator, (float s) {
-	    this->index++;
-	    assert(index < size);
-	    this->container->getBuffer()[this->index] = s;
-	    return *this;
-	}
-    };
-
-    CommaAssign<Container, 3> operator=(float s) {
-	return CommaAssign<Container, 3 > (this, s);
-    }
-
-};
-
-
-
-
-#endif	/* TEST_COMMA_H */
-

src/ltk/testing/Makefile.am

@@ -1,37 +0,0 @@
-
-include $(top_srcdir)/Common.am
-
-#AM_DEFAULT_SOURCE_EXT = .cpp
-
-
-
-TESTS = LtkDebugTest \
-	LtkFunctionToStringTest
-
-LDADD = ../../../libmutom-0.1.la
-check_PROGRAMS = $(TESTS)
-
-
-####################################################
-# Hybrid c/c++ Ltk Specific tests                  #
-####################################################
-
-check_PROGRAMS += Vector-test
-Vector_test_SOURCES = Vector.c
-TESTS += Vector-test
-
-check_PROGRAMS += Vector-test-cc
-Vector_test_cc_SOURCES = Vector-cc.cpp
-TESTS += Vector-test-cc
-
-check_PROGRAMS += Object-test
-Object_test_SOURCES = Object.c
-TESTS += Object-test
-
-check_PROGRAMS += Object-test-cc
-Object_test_cc_SOURCES = Object-cc.cpp
-TESTS += Object-test-cc
-
-####################################################
-
-AM_COLOR_TESTS = always

src/ltk/testing/Object-cc.cpp

@@ -1,40 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#include "testing-prototype.h"
-#include "../Object.h"
-
-using namespace ltk;
-
-int main() {
-    BEGIN_TESTING(Object - cc);
-
-    Object ob;
-    TEST1( ob.GetElement() == 5552368 );
-
-    END_TESTING;
-}

src/ltk/testing/Object.c

@@ -1,11 +0,0 @@
-#include "testing-prototype.h"
-#include "../Object.h"
-
-
-int main() {
-    BEGIN_TESTING(Object);
-
-    struct _Object *ob = Object_new(ObjectClass);
-
-    END_TESTING;
-}

src/ltk/testing/Vector-cc.cpp

@@ -1,79 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#include "testing-prototype.h"
-#include "../Vector.h"
-
-using namespace ltk;
-
-int main() {
-    BEGIN_TESTING(Vector - cc);
-
-    typedef ltkVector<int, 4 > ltkInt4;
-
-    ltkInt4 v, w;
-    v = 1, 2, 3, 4;
-    w = v;
-
-    printf("v -> %d,%d,%d,%d\n", v[0], *(v.getBuffer() + 1), v.at(2), v(3));
-
-
-    // test assign operator
-    TEST1(v == w);
-    TEST0(v != w);
-
-    // test accessors
-    TEST1(v[0] == 1);
-    TEST1(*(v.getBuffer() + 1) == 2);
-    TEST1(v.at(2) == 3);
-    TEST1(v(3) == 4);
-
-    // setter
-    w << 1, 4, 9, 16;
-    TEST1(w[0] == 1);
-    TEST1(w[1] == 4);
-    TEST1(w[2] == 9);
-    TEST1(w[3] == 16);
-
-    // math operators
-    v *= v;
-    w = 1, 4, 9, 16;
-    TEST1(v == w);
-    v /= v;
-    w = 1, 1, 1, 1;
-    TEST1(v == w);
-    v += v;
-    w = 2, 2, 2, 2;
-    TEST1(v == w);
-
-    v << 1, 1, -1, 1;
-    w << -1, 1, 1, 1;
-    TEST0(v * w);
-    TEST0(v / w);
-
-    END_TESTING;
-}

src/ltk/testing/Vector.c

@@ -1,14 +0,0 @@
-#include <stdio.h>
-#include "testing-prototype.h"
-#include "../Vector.h"
-
-
-LTK_VECTOR_DECLARE (float, uFloat4, 4)
-
-int main()
-{
-  BEGIN_TESTING (Vector);
-  uFloat4 f = uFloat4_ltk_vector_new ();
-
-  END_TESTING;
-}

src/ltk/testing/testing-prototype.h

@@ -1,37 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#include <stdio.h>
-
-#define BEGIN_TESTING(name)                \
-static int _fail = 0;                      \
-printf("..:: Testing " #name " ::..\n");
-
-#define TEST1(val) _fail += (val)==0
-#define TEST0(val) _fail += (val)!=0
-#define END_TESTING return _fail;
-

src/utils/make_recipe/src/CMakeLists.txt

@@ -67,9 +67,8 @@ if(ULIB_FOUND)
 
     ############################################################################
     #    MANUAL INLCLUDE EXTERNAL DEPENDENCIES
-    #    ${Boost_SERIALIZATION_LIBRARY}
+    #    Boost::serialization
-    #    ${Boost_SIGNALS_LIBRARY}
+    #    Boost::program_options
-    #    ${Boost_PROGRAM_OPTIONS_LIBRARY}
     #    ${Geant4_LIBRARIES}
     #    ${ROOT_LIBRARIES}
     #    ${VTK_LIBRARIES} # all VTK libs