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

fix mismatch Origin - Position

.gitignore

@@ -0,0 +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/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/uLibConfigHeader.cmake

@@ -16,12 +16,6 @@ set(BOOST_PP_VARIADICS ON)
 message(STATUS "PROJECT NAME = ${PROJECT_NAME}")
 message(STATUS "PACKAGE VERSION = ${PACKAGE_VERSION}")
 message(STATUS "PACKAGE NAME = ${PACKAGE_NAME}")
-execute_process(COMMAND "svnversion"
-                WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-                OUTPUT_VARIABLE SVN_REVISION
-                OUTPUT_STRIP_TRAILING_WHITESPACE )
-
-message(STATUS "SVN REVISION = ${SVN_REVISION}")
 
 CHECK_INCLUDE_FILES(inittypes.h HAVE_INITTYPES_H)
 CHECK_INCLUDE_FILES(stdbool.h HAVE_STDBOOL_H)

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)
@@ -75,36 +75,36 @@ endif(ULIB_USE_VTK)
 
 
 ## GEANT ##
-option(ULIB_USE_GEANT4 "Activate use of GEANT Integration" ON)
+#option(ULIB_USE_GEANT4 "Activate use of GEANT Integration" ON)
-message(STATUS "## GEANT 4 ##")
+#message(STATUS "## GEANT 4 ##")
-#include(FindGEANT4) # disabled using system finder
+##include(FindGEANT4) # disabled using system finder
-find_package(Geant4)
+#find_package(Geant4)
-set(GEANT4_FOUND Geant4_DIR)
+#set(GEANT4_FOUND Geant4_DIR)
-if(GEANT4_FOUND AND ULIB_USE_GEANT4)
+#if(GEANT4_FOUND AND ULIB_USE_GEANT4)
- message(STATUS "Looking for Geant4... - Geant4 found in ${Geant4_DIR}")
+# message(STATUS "Looking for Geant4... - Geant4 found in ${Geant4_DIR}")
- set(HAVE_GEANT4 true)
+# set(HAVE_GEANT4 true)
- include_directories(${Geant4_INCLUDE_DIRS})         # Add -I type paths
+# include_directories(${Geant4_INCLUDE_DIRS})         # Add -I type paths
- add_definitions(${Geant4_DEFINITIONS})              # Add -D type defs
+# add_definitions(${Geant4_DEFINITIONS})              # Add -D type defs
- debug_package(Geant4)
+# debug_package(Geant4)
-endif(GEANT4_FOUND AND ULIB_USE_GEANT4)
+#endif(GEANT4_FOUND AND ULIB_USE_GEANT4)
 
 ## QT4 ##
-option(ULIB_USE_QT4 "Activate use of Qt Framework" ON)
+#option(ULIB_USE_QT4 "Activate use of Qt Framework" ON)
-if(ULIB_USE_QT4)
+#if(ULIB_USE_QT4)
- message(STATUS "## QT4 ##")
+# message(STATUS "## QT4 ##")
- find_package(Qt4)
+# find_package(Qt4)
-# include_directories(${Qt4_INCLUDE_DIRS})
+## include_directories(${Qt4_INCLUDE_DIRS})
-# debug(Qt4_INCLUDE_DIRS)
+## debug(Qt4_INCLUDE_DIRS)
-endif(ULIB_USE_QT4)
+#endif(ULIB_USE_QT4)
 
 ## QT5 ##
-option(ULIB_USE_QT5 "Activate use of Qt Framework" ON)
+#option(ULIB_USE_QT5 "Activate use of Qt Framework" ON)
-if(ULIB_USE_QT5)
+#if(ULIB_USE_QT5)
- message(STATUS "## QT5 ##")
+# message(STATUS "## QT5 ##")
- find_package(Qt5Widgets)
+# find_package(Qt5Widgets)
-# include_directories(${Qt5_INCLUDE_DIRS})
+## include_directories(${Qt5_INCLUDE_DIRS})
-# debug(Qt5_INCLUDE_DIRS)
+## debug(Qt5_INCLUDE_DIRS)
-endif(ULIB_USE_QT5)
+#endif(ULIB_USE_QT5)
 
 ## READLINE ##
 message(STATUS "## READLINE ##")

CMake/uLibGenerateDoc.cmake

@@ -0,0 +1,97 @@
+find_package(Doxygen)
+
+set(doxydirlist "")
+foreach(modname ${ULIB_SELECTED_MODULES})
+    set(doxydirlist "${CMAKE_CURRENT_SOURCE_DIR}/src/${modname} ${doxydirlist}")
+endforeach(modname)
+
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg
+     "PROJECT_NAME=${CMAKE_PROJECT_NAME}-${PACKAGE_VERSION}\n"
+     "OUTPUT_DIRECTORY=${CMAKE_CURRENT_BINARY_DIR}\n"
+     "CREATE_SUBDIRS=NO\n"
+     "OUTPUT_LANGUAGE=English\n"
+     "BRIEF_MEMBER_DESC=YES\n"
+     "REPEAT_BRIEF=YES\n"
+     "ALWAYS_DETAILED_SEC=NO\n"
+     "INLINE_INHERITED_MEMB=NO\n"
+     "STRIP_FROM_INC_PATH=${CMAKE_CURRENT_SOURCE_DIR}/src\n"
+     "FULL_PATH_NAMES=YES\n"
+     "STRIP_FROM_PATH=${CMAKE_CURRENT_SOURCE_DIR}/src\n"
+     "SHORT_NAMES=NO\n"
+     "MULTILINE_CPP_IS_BRIEF=NO\n"
+     "INHERIT_DOCS=YES\n"
+     "DISTRIBUTE_GROUP_DOC=NO\n"
+     "OPTIMIZE_OUTPUT_FOR_C=YES\n"
+     "SUBGROUPING=YES\n"
+     "EXTRACT_ALL=YES\n"
+     "EXTRACT_PRIVATE=NO\n"
+     "EXTRACT_STATIC=NO\n"
+     "EXTRACT_LOCAL_CLASSES=YES\n"
+     "EXTRACT_LOCAL_METHODS=NO\n"
+     "HIDE_UNDOC_MEMBERS=NO\n"
+     "HIDE_UNDOC_CLASSES=NO\n"
+     "HIDE_FRIEND_COMPOUNDS=NO\n"
+     "HIDE_IN_BODY_DOCS=NO\n"
+     "INTERNAL_DOCS=NO\n"
+     "CASE_SENSE_NAMES=NO\n"
+     "HIDE_SCOPE_NAMES=NO\n"
+     "SHOW_INCLUDE_FILES=YES\n"
+     "INLINE_INFO=YES\n"
+     "SORT_MEMBER_DOCS=YES\n"
+     "SORT_BRIEF_DOCS=NO\n"
+     "SORT_BY_SCOPE_NAME=NO\n"
+     "GENERATE_TODOLIST=YES\n"
+     "GENERATE_TESTLIST=YES\n"
+     "GENERATE_BUGLIST=YES\n"
+     "GENERATE_DEPRECATEDLIST=YES\n"
+     "MAX_INITIALIZER_LINES=30\n"
+     "SHOW_USED_FILES=YES\n"
+     "QUIET=YES\n"
+     "WARNINGS=NO\n"
+     "WARN_IF_UNDOCUMENTED=YES\n"
+     "WARN_IF_DOC_ERROR=YES\n"
+     "WARN_FORMAT=\"$file:$line: $text\"\n"
+     "INPUT=${doxydirlist}\n"
+     "FILE_PATTERNS=*.h *.hpp\n"
+     "ENABLE_PREPROCESSING=YES\n"
+     "MACRO_EXPANSION=YES\n"
+     "RECURSIVE=YES\n"
+     "EXCLUDE_SYMLINKS=NO\n"
+     "FILTER_SOURCE_FILES=NO\n"
+     "SOURCE_BROWSER=NO\n"
+     "INLINE_SOURCES=NO\n"
+     "STRIP_CODE_COMMENTS=YES\n"
+     "REFERENCED_BY_RELATION=YES\n"
+     "REFERENCES_RELATION=YES\n"
+     "VERBATIM_HEADERS=YES\n"
+     "ALPHABETICAL_INDEX=YES\n"
+     "COLS_IN_ALPHA_INDEX=5\n"
+     "GENERATE_HTML=YES\n"
+     "HTML_OUTPUT=html\n"
+     "HTML_FILE_EXTENSION=.html\n"
+     "GENERATE_HTMLHELP=NO\n"
+     "BINARY_TOC=NO\n"
+     "TOC_EXPAND=NO\n"
+     "DISABLE_INDEX=NO\n"
+     "ENUM_VALUES_PER_LINE=4\n"
+     "GENERATE_TREEVIEW=YES\n"
+     "TREEVIEW_WIDTH=250\n"
+     "GENERATE_LATEX=NO\n"
+     "GENERATE_RTF=NO\n"
+     "GENERATE_MAN=NO\n"
+     "GENERATE_XML=NO\n"
+     "GENERATE_AUTOGEN_DEF=NO\n"
+     "GENERATE_PERLMOD=NO\n")
+
+option(NODOXYGEN "Disable the creation of the API documentation")
+if(NODOXYGEN OR (NOT DOXYGEN_FOUND))
+    message("Doxygen is disabled or not installed")
+else(NODOXYGEN OR (NOT DOXYGEN_FOUND))
+    add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/html/index.html
+                       COMMAND doxygen ${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg)
+
+    add_custom_target(doxygen ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/html/index.html)
+
+    install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
+            DESTINATION share/doc/${PACKAGE_NAME})
+endif(NODOXYGEN OR (NOT DOXYGEN_FOUND))

CMake/uLibTargetMacros.cmake

@@ -30,24 +30,26 @@ macro(uLib_add_shared_library name)
   set_target_properties(${mname} PROPERTIES
                         VERSION ${PROJECT_VERSION}
                         SOVERSION ${PROJECT_SOVERSION}
-                      INTERFACE_LINK_LIBRARIES "${LIBRARIES}"
+#                       INTERFACE_LINK_LIBRARIES "${LIBRARIES}"
-                      LINK_INTERFACE_LIBRARIES "${LIBRARIES}"          ## <- ok for cmake from  2.12 ?
+#                       LINK_INTERFACE_LIBRARIES "${LIBRARIES}"          ## <- ok for cmake from  2.12 ?
-                      IMPORTED_LINK_INTERFACE_LIBRARIES "${LIBRARIES}" ## <- breaks cmake after 2.11 ?
+#                       IMPORTED_LINK_INTERFACE_LIBRARIES "${LIBRARIES}" ## <- breaks cmake after 2.11 ?
 #                       PUBLIC_HEADER ""
   )
   debug(LIBRARIES)
 
+  target_link_libraries(${mname} ${LIBRARIES})
+
   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)
 
@@ -68,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)
 
@@ -80,18 +82,10 @@ 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(${tn} ${tn})
+        add_test(NAME ${tn} COMMAND ${tn})
 
-  # adds dependencies to all selected modules in uLib
+        target_link_libraries(${tn} ${LIBRARIES})
-  #  foreach(module ${ULIB_SELECTED_MODULES})
-  #   add_dependencies(${tn} ${project_name}${module})
-  #  endforeach(module)
-
-  # adds libraries dependencies
-  foreach(library ${LIBRARIES})
-   target_link_libraries(${tn} ${library})
-  endforeach(library)
 
     endforeach(tn)
 

CMakeLists.txt

@@ -3,12 +3,7 @@
 ##### CMAKE LISTS ##############################################################
 ################################################################################
 
-cmake_minimum_required (VERSION 2.6)
+cmake_minimum_required (VERSION 3.26)
-
-execute_process(COMMAND "clear")
-message("//////////////////////////////////////////////////////////////////////")
-message("/////////////////// CMAKE PJOJECT CONFIGURATION //////////////////////")
-message("//////////////////////////////////////////////////////////////////////")
 
 ## -------------------------------------------------------------------------- ##
 
@@ -16,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}")
 
@@ -31,207 +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})
-      ltk
-      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)
 
-## this gets ulib modules into a variable ##
+include_directories(${SRC_DIR}/Math)
-function(uLib_modules result)
+add_subdirectory(${SRC_DIR}/Math)
- set(out)
- foreach(module ${ULIB_SELECTED_MODULES})
-  list(APPEND out ${PACKAGE_LIBPREFIX}${module})
- endforeach(module)
- set(${result} "${out}" PARENT_SCOPE)
-endfunction()
 
+include_directories(${SRC_DIR}/Detectors)
+add_subdirectory(${SRC_DIR}/Detectors)
 
-## ENTERING MODULES SUBDIRECTORIES ##
+include_directories(${SRC_DIR}/Root)
-message("/////////// SELECTED MODULES //////////////")
+add_subdirectory(${SRC_DIR}/Root)
-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)
 
-## SINGLE LIBRARY LINKING ## (work in progress ... )
+include_directories(${SRC_DIR}/Vtk)
-option(ULIB_SINGLELIBRARY "Link everything to a single library" OFF)
+add_subdirectory(${SRC_DIR}/Vtk)
-if(ULIB_SINGLELIBRARY) 
+
-# set(modgrp)
+#add_subdirectory("${SRC_DIR}/utils/make_recipe")
-# foreach(module ${ULIB_SELECTED_MODULES})
+
-#  set(grpn srcgrp_${module})
+## Documentation and packages
-#  list(APPEND modgrp ${grpn})
+
-# endforeach(module)
+#include(uLibGenerateDoc)
-# add_library(${project_name} SHARED ${srcgrp_Core})
-endif(ULIB_SINGLELIBRARY)
 
 ## UTILITIES ##
-add_subdirectory("${SRC_DIR}/utils/make_recipe")
+#add_subdirectory("${SRC_DIR}/utils/make_recipe")
-
-
-## PKG CONFIG compatible file ----------------------------------------------- ##
-
-set(PKGCONFIG_FILE_ENABLE OFF CACHE BOOL "enable pkg-config file")
-if(PKGCONFIG_FILE_ENABLE)
-message("/////////// PKG-CONFIG DISTILLER //////////////")
-set(PKGCONFIG_FILE_DESTDIR "/lib/pkgconfig/" CACHE PATH "destination path for pkg-config file")
-set(PKGCONFIG_LIBS)
-
-message(STATUS "[cflags] ${CMAKE_C_FLAGS}")
-message(STATUS "[cxxflags] ${CMAKE_CXX_FLAGS}")
-
-foreach(module ${ULIB_SHARED_LIBRARIES})
-set(PKGCONFIG_LIBS "${PKGCONFIG_LIBS} ${CMAKE_LINK_LIBRARY_FLAG}${module}")
-endforeach(module)
-message(STATUS "[libs] ${PKGCONFIG_LIBS}")
-
-set(PKGCONFIG_FLAGS)
-#add_custom_target(Dummy)
-
-# add the executable
-uLib_add_target(Dummy test.cpp)
-target_link_libraries(Dummy ${PACKAGE_LIBPREFIX}Core)
-target_link_libraries(Dummy ${Boost_SERIALIZATION_LIBRARY})
-target_link_libraries(Dummy ${Boost_SIGNALS_LIBRARY})
-target_link_libraries(Dummy ${Boost_PROGRAM_OPTIONS_LIBRARY})
-target_link_libraries(Dummy ${Geant4_LIBRARIES})
-target_link_libraries(Dummy ${ROOT_LIBRARIES})
-target_link_libraries(Dummy ${VTK_LIBRARIES})
-
-get_gcc_compile_flags(Dummy, gcc_flags_list)
-foreach(item ${gcc_flags_list})
- message(STATUS "[gcc cflags] ${item}")
- set(PKGCONFIG_FLAGS "${PKGCONFIG_FLAGS} ${item}")
-endforeach(item)
-message(STATUS "[includes] ${PKGCONFIG_FLAGS}")
-
-get_gcc_link_flags(Dummy, gcc_flags_list)
-foreach(item ${gcc_flags_list})
- message(STATUS "[gcc libs] ${item}")
-endforeach(item)
-
-configure_file(
-  "${PROJECT_SOURCE_DIR}/CMakePkgConfig.pc.in"
-  "${PROJECT_BINARY_DIR}/libmutom-${PACKAGE_VERSION}.pc"
-  )
-INSTALL_FILES(${PKGCONFIG_FILE_DESTDIR} FILES ${PROJECT_BINARY_DIR}/libmutom-${PACKAGE_VERSION}.pc)
-
-message("///////////////////////////////////////////")
-endif(PKGCONFIG_FILE_ENABLE)
-
-
-
 
 
 ## 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 the FooBarConfig.cmake and FooBarConfigVersion.cmake
+
-install(FILES
+# from CMake 3.x configure file shall be created using a dedicated function
-  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+# see: https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html
+#
+include(CMakePackageConfigHelpers)
+configure_package_config_file(uLibConfig.cmake.in
+                              "${PROJECT_BINARY_DIR}/uLibConfig.cmake"
+                              INSTALL_DESTINATION ${INSTALL_CMAKE_DIR}
+                              PATH_VARS 
+                                INSTALL_LIB_DIR 
+                                INSTALL_INC_DIR 
+                                INSTALL_BIN_DIR 
+                                INSTALL_CMAKE_DIR 
+                                INSTALL_ETC_DIR 
+                                INSTALL_DATA_DIR
+                                ULIB_SOURCE_DIR
+                                ULIB_SHARED_LIBRARIES
+                              # NO_SET_AND_CHECK_MACRO
+                              # NO_CHECK_REQUIRED_COMPONENTS_MACRO
+                              )
+
+install(FILES "${PROJECT_BINARY_DIR}/uLibConfig.cmake"
               "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake"
-  DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}" COMPONENT dev)
+        DESTINATION "${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
-## dummy main executable ---------------------------------------------------- ##
+# it is used also to identify if we are using a build direcory
-
+# to link a project against uLib. see: uLibConfig.cmake ( IF )
-message("Sara's debug....")
+export (TARGETS ${ULIB_SHARED_LIBRARIES}
-message(${ROOT_LIBRARIES})
+        FILE "${PROJECT_BINARY_DIR}/uLibTargets-build.cmake"
-
+        # NAMESPACE "uLib::"
-# add the executable
-add_executable(Coretest test.cpp)
-target_link_libraries(Coretest ${PACKAGE_LIBPREFIX}Core)
-#target_link_libraries(Coretest ${Boost_SERIALIZATION_LIBRARY})
-#target_link_libraries(Coretest ${Boost_SIGNALS_LIBRARY})
-#target_link_libraries(Coretest ${Boost_PROGRAM_OPTIONS_LIBRARY})
-#target_link_libraries(Coretest ${Geant4_LIBRARIES})
-target_link_libraries(Coretest ${ROOT_LIBRARIES})
-target_link_libraries(Coretest ${VTK_LIBRARIES})
-
-#message( "---------------------------------------------------------------------" )
-#execute_process(COMMAND
-#                "ls"
-##                "cmake --find-package -DNAME=uLib -DLANGUAGE=C -DCOMPILER_ID=GNU -DMODE=COMPILE"
-#                )
-#message( "---------------------------------------------------------------------" )
-
-## -------------------------------------------------------------------------- ##
-
-
-# TODO clean also subdirectories
-add_custom_target(clean-cmake-files
-   COMMAND ${CMAKE_COMMAND} -P ${ULIB_CMAKE_DIR}/clean-all.cmake
 )        
 
-
+# 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"
+    ]
+}

Jenkinsfile

@@ -0,0 +1,35 @@
+pipeline {
+
+    agent {
+        docker {
+            image 'infnpd/cmt-environment:1.1-centos7'
+            args '-u 0:0'
+            label 'DOCKER'
+        }
+    }
+
+    environment {
+        NEXUS_PD_CREDS = credentials('jenkins-nexus-pd-creds')
+        NEXUS_PD_URL = 'https://cld-smact-02.pd.infn.it/artifacts/repository/muotom/devel/centos7/x86_64/'
+    }
+
+    stages {
+
+        stage('Build') {
+
+            steps {
+                sh "mkdir build && cd build && cmake -DNODOXYGEN=ON .. && make rpm"
+            }
+
+        }
+        stage('Deploy') {
+
+            steps {
+                sh "find . -name '*.x86_64.rpm' curl -v -k --user '${NEXUS_PD_CREDS_USR}:${NEXUS_PD_CREDS_PSW}' --upload-file '{}' ${NEXUS_PD_URL} ';'"
+            }
+
+        }
+
+    }
+
+}

README.md

@@ -0,0 +1,63 @@
+# uLib
+
+[![DOI](https://zenodo.org/badge/36926725.svg)](https://zenodo.org/badge/latestdoi/36926725)
+
+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,46 +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
-                                Collection.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
-                                Vector.h
-                                CommaInitializer.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}
-       ${PACKAGE_LIBPREFIX}Core
-       ${PACKAGE_LIBPREFIX}Math
-)
 
-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/Debug.h

@@ -29,12 +29,11 @@
 #define U_CORE_DEBUG_H
 
 
-
+#include <vector>
-#include "ltk/ltkdebug.h"
 #include "Macros.h"
 #include "Types.h"
 #include "Mpl.h"
-#include "Vector.h"
+#include "SmartPointer.h"
 
 #include <boost/any.hpp>
 #include <TObject.h>
@@ -128,8 +127,8 @@ public:
     }
 
 private:
-    Vector<DItem>     m_v;
+    std::vector<DItem>     m_v;
-    Vector<Adapter>   m_a;
+    std::vector<Adapter>   m_a;
 };
 
 

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/StringReader.h

@@ -31,7 +31,6 @@
 #include <istream>
 #include <algorithm>
 
-#include "Core/Vector.h"
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 

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,75 +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 ltk::Id_t        Id_t;
+typedef float Real_t;
-//typedef ltk::Size_t      Size_t;
+#else
-typedef ltk::Pointer_t   Pointer_t;
+typedef double Real_t;
-typedef bool             Bool_t;      //Boolean (0=false, 1=true) (bool)
+#endif
+// typedef ltk::Id_t        Id_t;
+typedef id_t Id_t;
+////typedef ltk::Size_t      Size_t;
+// typedef ltk::Pointer_t   Pointer_t;
+typedef void *Pointer_t;
+typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
 
 //--- bit manipulation ---------------------------------------------------------
 #ifndef BIT
@@ -173,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/Uuid.h

@@ -29,6 +29,7 @@
 #define U_CORE_UUID_H
 
 #include <iostream>
+#include <vector>
 
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/name_generator.hpp>
@@ -36,7 +37,6 @@
 #include <boost/uuid/uuid_io.hpp>
 
 #include "Core/Mpl.h"
-#include "Core/Vector.h"
 #include "Core/Object.h"
 
 
@@ -127,7 +127,7 @@ public:
 
 private:
     IDGen_t gen;
-    Vector<RegisterEntry> m_registry;
+    std::vector<RegisterEntry> m_registry;
 
 };
 

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,21 +23,16 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
-#include <iostream>
 #include <fstream>
+#include <iostream>
 
-#include "Core/Object.h"
 #include "Core/Archives.h"
-#include "ParticlePhysics/MuonTomography/MuonScatter.h"
+#include "Core/Object.h"
 
 #include "testing-prototype.h"
 
 using namespace uLib;
 
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -46,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;
@@ -99,10 +86,6 @@ int test_V3f() {
   return (1);
 }
 
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -110,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");
@@ -181,69 +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");
 }
 
-
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// MUON SCATTER EXAMPLE //
-
-int testing_mu()
-{     
-     std::stringstream ss;
-
-     MuonScatter mu;
-     mu.SetMomentumIn(555);
-     mu.SetMomentumOut(2368);
-     {
-         std::ofstream file("test.txt");
-         file << mu;
-     }
-
-     mu.SetMomentumIn(0);
-     mu.SetMomentumOut(0);
-     {
-         std::ifstream file("test.txt");
-         file >> mu;
-     }
-
-     std::cout << mu << "\n";
-
-
-}
-
-
-
-
-
-
 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
-    TEST1( testing_mu() );
 
   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,38 +1,12 @@
-# HEADERS
+set(HEADERS MuonScatter.h MuonError.h MuonEvent.h)
-set(HEADERS
+
-                                DetectorChamber.h
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
-                                ExperimentFitEvent.h
-                                GeantEvent.h
-                                HitMC.h
-                                MuonScatter.h
-                                MuonEvent.h
-                                MuonError.h
-                                ChamberHitEvent.h
-                                Hit.h
-                                LinearFit.h
-                                Solid.h
-                                Matter.h
-                                Scene.h
-)
 
 
-# SOURCES
+install(FILES ${HEADERS}
-set(SOURCES
+        DESTINATION ${INSTALL_INC_DIR}/Detectors)
-                Solid.cpp
-                Scene.cpp
-)
 
-set(LIBRARIES
+if(BUILD_TESTING)
-       ${Boost_SERIALIZATION_LIBRARY}
+  include(uLibTargetMacros)
-       ${Boost_SIGNALS_LIBRARY}
+  add_subdirectory(testing)
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
+endif()
-       ${Eigen_LIBRARY}
-       ${Geant4_LIBRARIES}
-       ${ROOT_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
-       ${PACKAGE_LIBPREFIX}Math
-       ${PACKAGE_LIBPREFIX}Detectors
-)
-
-uLib_add_shared_library(${uLib-module})
-add_subdirectory(testing)

src/Detectors/HitMC.h

@@ -28,7 +28,6 @@
 #ifndef U_HITMC_H
 #define U_HITMC_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 #include "Hit.h"
 
@@ -43,10 +42,10 @@ public:
         DeltaRay
     };
 
-    uLibConstRefMacro(Position,HPoint3f)
+    inline const HPoint3f & Position() const { return this->m_Position; }
-    uLibGetMacro(Type, enum Type)
+    inline enum Type GetType() const { return this->m_Type; }
 
-private:
+protected:
     HPoint3f  m_Position;
     enum Type m_Type;
 };
@@ -54,8 +53,8 @@ private:
 
 class HitMC : public HitMCData {
 public:
-    uLibRefMacro(Position,HPoint3f)
+    inline HPoint3f & Position() { return this->m_Position; }
-    uLibSetMacro(Type, enum Type)
+    inline void SetType(enum Type name) { this->m_Type = name; }
 };
 
 

src/Detectors/LinearFit.h

@@ -28,7 +28,6 @@
 #ifndef U_LINEARFIT_H
 #define U_LINEARFIT_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 #include "ChamberDetector.h"
 
@@ -37,15 +36,14 @@ namespace uLib {
 
 class LinearFitData {
 public:
-    uLibConstRefMacro(Position,Vector2f)
+    inline const Vector2f & Position() const { return this->m_Position; }
-    uLibConstRefMacro(Slope,Vector2f)
+    inline const Vector2f & Slope() const { return this->m_Slope; }
-    uLibConstRefMacro(PositionError,Vector2f)
+    inline const Vector2f & PositionError() const { return this->m_PositionError; }
-    uLibConstRefMacro(SlopeError,Vector2f)
+    inline const Vector2f & SlopeError() const { return this->m_SlopeError; }
-    uLibGetMacro(HitsNumber,int)
+    inline int GetHitsNumber() const { return this->m_HitsNumber; }
-    uLibGetMacro(Idv,ChamberDetector::ID)
+    inline ChamberDetector::ID GetIdv() const { return this->m_Idv; }
 
-private:
+protected:
-        friend class LinearFit;
     Vector2f            m_Position;
     Vector2f            m_Slope;
     Vector2f            m_PositionError;
@@ -57,12 +55,12 @@ private:
 
 class LinearFit : public LinearFitData {
 public:
-    uLibRefMacro(Position,Vector2f)
+    inline Vector2f & Position() { return this->m_Position; }
-    uLibRefMacro(Slope,Vector2f)
+    inline Vector2f & Slope() { return this->m_Slope; }
-    uLibRefMacro(PositionError,Vector2f)
+    inline Vector2f & PositionError() { return this->m_PositionError; }
-    uLibRefMacro(SlopeError,Vector2f)
+    inline Vector2f & SlopeError() { return this->m_SlopeError; }
-    uLibSetMacro(HitsNumber,int)
+    inline void SetHitsNumber(int name) { this->m_HitsNumber = name; }
-    uLibSetMacro(Idv,ChamberDetector::ID)
+    inline void SetIdv(ChamberDetector::ID name) { this->m_Idv = name; }
 };
 
 

src/Detectors/MuonError.h

@@ -28,18 +28,16 @@
 #ifndef U_MUONERROR_H
 #define U_MUONERROR_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 namespace uLib {
 
 
 class MuonErrorData {
-    friend class MuonError;
 public:
-    uLibConstRefMacro(Theta,Scalarf)
+    inline const Scalarf & Theta() const { return this->m_Theta; }
-    uLibConstRefMacro(Phi,Scalarf)
+    inline const Scalarf & Phi() const { return this->m_Phi; }
-private:
+protected:
     Scalarf m_Theta;
     Scalarf m_Phi;
 };
@@ -47,8 +45,8 @@ private:
 
 class MuonError  : public MuonErrorData {
 public:
-    uLibRefMacro(Theta,Scalarf)
+    inline Scalarf & Theta() { return this->m_Theta; }
-    uLibRefMacro(Phi,Scalarf)
+    inline Scalarf & Phi() { return this->m_Phi; }
 };
 
 

src/Detectors/MuonEvent.h

@@ -28,20 +28,18 @@
 #ifndef U_MUONEVENT_H
 #define U_MUONEVENT_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 namespace uLib {
 
 
 class MuonEventData {
-    friend class MuonEvent;
 public:
-    uLibConstRefMacro(LineIn,HLine3f)
+    inline const HLine3f & LineIn() const { return this->m_LineIn; }
-    uLibConstRefMacro(LineOut,HLine3f)
+    inline const HLine3f & LineOut() const { return this->m_LineOut; }
-    uLibGetMacro(Momentum,Scalarf)
+    inline Scalarf GetMomentum() const { return this->m_Momentum; }
 
-private:
+protected:
     HLine3f  m_LineIn;
     HLine3f  m_LineOut;
     Scalarf  m_Momentum;
@@ -50,9 +48,9 @@ private:
 
 class MuonEvent  : public MuonEventData {
 public:
-    uLibRefMacro(LineIn,HLine3f)
+    inline HLine3f & LineIn() { return this->m_LineIn; }
-    uLibRefMacro(LineOut,HLine3f)
+    inline HLine3f & LineOut() { return this->m_LineOut; }
-    uLibRefMacro(Momentum,Scalarf)
+    inline Scalarf & Momentum() { return this->m_Momentum; }
 
 };
 

src/Detectors/MuonScatter.h

@@ -29,7 +29,6 @@
 #ifndef U_MUONSCATTER_H
 #define U_MUONSCATTER_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 namespace uLib {
@@ -37,20 +36,21 @@ namespace uLib {
 
 class MuonScatter {
 public:
-    uLibConstRefMacro(LineIn,HLine3f)
+    inline const HLine3f & LineIn() const { return this->m_LineIn; }
-    uLibConstRefMacro(ErrorIn,HError3f)
+    inline const HError3f & ErrorIn() const { return this->m_ErrorIn; }
-    uLibConstRefMacro(LineOut,HLine3f)
+    inline const HLine3f & LineOut() const { return this->m_LineOut; }
-    uLibConstRefMacro(ErrorOut,HError3f)
+    inline const HError3f & ErrorOut() const { return this->m_ErrorOut; }
 
-    uLibRefMacro(LineIn,HLine3f)
+    inline HLine3f & LineIn() { return this->m_LineIn; }
-    uLibRefMacro(ErrorIn,HError3f)
+    inline HError3f & ErrorIn() { return this->m_ErrorIn; }
-    uLibRefMacro(LineOut,HLine3f)
+    inline HLine3f & LineOut() { return this->m_LineOut; }
-    uLibRefMacro(ErrorOut,HError3f)
+    inline HError3f & ErrorOut() { return this->m_ErrorOut; }
-    uLibSetMacro(Momentum,Scalarf)
-    uLibSetMacro(MomentumPrime,Scalarf)
 
-    uLibGetMacro(Momentum,Scalarf)
+    inline void SetMomentum(Scalarf name) { this->m_Momentum = name; }
-    uLibGetMacro(MomentumPrime,Scalarf)
+    inline void SetMomentumPrime(Scalarf name) { this->m_MomentumPrime = name; }
+
+    inline Scalarf GetMomentum() const { return this->m_Momentum; }
+    inline Scalarf GetMomentumPrime() const { return this->m_MomentumPrime; }
 
 protected:
     HLine3f  m_LineIn;

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/Accumulator.h

@@ -28,7 +28,8 @@
 #ifndef U_DATABINNING_H
 #define U_DATABINNING_H
 
-#include "Core/Vector.h"
+#include <vector>
+
 #include "Dense.h"
 
 
@@ -69,7 +70,7 @@ public:
     void AddPass() { m_Means.push_back( Tmean(0,0) ); }
 
 private:
-    Vector< Tmean > m_Means;
+    std::vector< Tmean > m_Means;
 };
 
 

src/Math/BitCode.h

@@ -27,15 +27,16 @@
 #ifndef U_MATH_BITCODE_H
 #define U_MATH_BITCODE_H
 
+#include <iostream>
+
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
-//#include <Core/CommaInitializer.h>
-#include <Math/Dense.h>
-
-#include <Core/Mpl.h>
 #include <boost/mpl/vector_c.hpp>
 #include <boost/mpl/set_c.hpp>
 
+#include <Math/Dense.h>
+
+
 namespace uLib {
 
 
@@ -237,9 +238,9 @@ public:
 //        std::cout << boost::mpl::at_c< BitSet,1 >::type::value << "\n";
     }
 
-    int Get(unsigned short field) const {
+//    int Get(unsigned short field) const {
-        return boost::mpl::at_c< BitSet, field >::type::value;
+//        return boost::mpl::at_c< BitSet, field >::type::value;
-    }
+//    }
 };
 
 

src/Math/CMakeLists.txt

@@ -1,7 +1,5 @@
 
-# HEADERS
+set(HEADERS ContainerBox.h
-set(HEADERS
-                                ContainerBox.h
             Dense.h
             Geometry.h
             Transform.h
@@ -22,29 +20,42 @@ set(HEADERS
             Accumulator.h
             TriangleMesh.h
             BitCode.h
-)
+            Structured2DGrid.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)
 
-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})
-       ${PACKAGE_LIBPREFIX}Math
+
-)
+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.cpp

@@ -27,8 +27,8 @@
 
 
 #include "Dense.h"
-#include "Core/Archives.h"
 
+#ifdef ULIB_SERIALIZATION_ON
 ULIB_SERIALIZE(uLib::HPoint3f) {
     ar & boost::serialization::make_nvp(NULL,boost::serialization::base_object<uLib::HPoint3f::BaseClass,uLib::HPoint3f>(ob));
 }
@@ -48,5 +48,5 @@ ULIB_SERIALIZE(uLib::HError3f) {
     ar
             & "HLine -> ( poserr: " & AR(position_error) & "; direrr: " & AR(direction_error) & ") ";
 }
-
+#endif // ULIB_SERIALIZATION_ON
 

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,17 +44,12 @@
  *
  */
 
-
 #ifndef ULIB_DENSEMATRIX_H
 #define ULIB_DENSEMATRIX_H
 
 #include <stdlib.h>
 
 #include <Eigen/Dense>
-#include "Core/Types.h"
-#include "Core/Serializable.h"
-
-
 
 //// BOOST SERIALIZATION ///////////////////////////////////////////////////////
 
@@ -65,20 +57,23 @@
 #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
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -87,28 +82,30 @@ 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;
 
 typedef int Scalari;
 typedef unsigned int Scalarui;
@@ -117,164 +114,147 @@ 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
-}
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // SERIALIZTION //
 
+#ifdef ULIB_SERIALIZATION_ON
+#include "Core/Serializable.h"
+
 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/Geometry.h

@@ -28,7 +28,6 @@
 #ifndef U_GEOMETRY_H
 #define U_GEOMETRY_H
 
-#include "Core/Object.h"
 #include "Math/Dense.h"
 #include "Math/Transform.h"
 

src/Math/Quote.h

@@ -32,11 +32,11 @@
 
 namespace uLib {
 
-class Quote : public Vector2f {
+class Quote : public Vector2f
+{
 public:
 
-
+    inline Scalarf& Offset() { return this->m_Offset; }
-    uLibRefMacro(Offset,Scalarf);
 
 private:
     Scalarf m_Offset;

src/Math/Structured2DGrid.cpp

@@ -0,0 +1,130 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Sara Vanini < sara.vanini@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 "Structured2DGrid.h"
+
+using namespace uLib;
+
+//_____________________________________________________________
+Structured2DGrid::Structured2DGrid()
+{
+    // reset uni-dim space
+    m_Dims = Vector2i(0,0);
+    m_Origin = Vector2f(0.,0.);
+    m_Increments = Vector2i(0,0);
+    m_binW = Vector2f(1.,1.);
+    m_debug = true;
+}
+
+
+//_____________________________________________________________
+void Structured2DGrid::SetDims(const Vector2i &size)
+{
+    this->m_Dims = size;
+
+    // set increments
+    this->m_Increments[0] = 1;
+    this->m_Increments[1] = m_Dims[0];
+   }
+
+//_____________________________________________________________
+void Structured2DGrid::SetPhysicalSpace(const Vector2f &origin, const Vector2f &spacing)
+{
+    m_Origin = origin;
+    m_binW = spacing;
+
+    m_uni2phys_T = Translation<float,2>(m_Origin) * Scaling(m_binW);
+    m_phys2uni_T = m_uni2phys_T.matrix().inverse();
+
+    return;
+}
+
+
+//_____________________________________________________________
+bool Structured2DGrid::IsInsideBounds(const Vector2f &pt) const
+{
+    Vector2i pLoc = this->PhysicsToUnitSpace(pt);
+    return this->IsInsideGrid(pLoc);
+}
+
+
+//_____________________________________________________________
+Vector2i Structured2DGrid::UnMap(int index) const
+{
+    Vector2i v( 0,0 );
+    Vector2i iv = m_Increments;
+
+    int id = 0;
+    for(int k=0; k<2; ++k) {
+        int inc = iv.maxCoeff(&id);
+        v(id) = index / inc;
+        index -= v(id) * inc;
+        iv(id) = 0;
+    }
+    return v;
+}
+
+//_____________________________________________________________
+bool Structured2DGrid::IsInsideGrid(const Vector2i &v) const
+{
+    int vok = 1;
+    vok *= (v(0) >= 0 && v(0) < m_Dims[0]);
+    vok *= (v(1) >= 0 && v(1) < m_Dims[1]);
+
+    return vok;
+}
+
+
+//_____________________________________________________________
+Vector2i Structured2DGrid::PhysicsToUnitSpace(const Vector2f &pt) const
+{
+    Vector2i out;
+    Vector2f pLoc = m_phys2uni_T * pt;
+
+    out << (int)floor(pLoc(0)),
+                (int)floor(pLoc(1));
+
+    return out;
+}
+
+//_____________________________________________________________
+Vector2f Structured2DGrid::UnitToPhysicsSpace(const Vector2i &ind) const
+{
+    Vector2f p;
+    p = m_uni2phys_T * ind.cast<float>();
+
+    return p;
+}
+
+//_____________________________________________________________
+void Structured2DGrid::PrintSelf(std::ostream &o)
+{
+    o << "uLib Structured Data 2D: \n"
+      << "dim     = " << this->GetDims().transpose() << "\n"
+      << "spacing = " << this->GetSpacing().transpose() << "\n";
+}
+

src/Math/Structured2DGrid.h

@@ -0,0 +1,74 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Sara Vanini < sara.vanini@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 Structured2DGrid_H
+#define Structured2DGrid_H
+
+#include "Math/Dense.h"
+
+#include <Eigen/Dense>
+#include <Eigen/Geometry>
+
+using namespace Eigen;
+
+namespace uLib {
+
+class Structured2DGrid {
+public:
+
+    Structured2DGrid();
+
+    /// unit-space
+    void SetDims(const Vector2i &size);
+    inline Vector2i GetDims() {return m_Dims; }
+    bool IsInsideGrid(const Vector2i &v) const;
+    inline int Map(Vector2i index) const  { return (m_Increments.transpose() * index);}
+    Vector2i UnMap(int index) const;
+
+    /// physics-space
+    void SetPhysicalSpace(const Vector2f &origin, const Vector2f &spacing);
+    inline Vector2f GetSpacing() const {    return m_binW; }
+    inline Vector2f GetOrigin() const {    return m_Origin; }
+    bool IsInsideBounds(const Vector2f &pt) const;
+
+    /// operations
+    Vector2i PhysicsToUnitSpace(const Vector2f &pt) const;
+    Vector2f UnitToPhysicsSpace(const Vector2i &ind) const;
+    void PrintSelf(std::ostream &o);
+    void SetDebug(bool debug){ m_debug = debug; };
+
+private:
+    Vector2i m_Dims;
+    Vector2i m_Increments;
+    Vector2f m_binW;
+    Vector2f m_Origin;
+    bool m_debug;
+
+     Transform<float, 2, Eigen::Affine>  m_uni2phys_T;
+     Transform<float, 2, Eigen::Affine>  m_phys2uni_T;
+};
+}
+
+#endif // Structured2DGrid_H

src/Math/Structured4DGrid.cpp

@@ -0,0 +1,136 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 "Structured4DGrid.h"
+
+using namespace uLib;
+
+//_____________________________________________________________
+Structured4DGrid::Structured4DGrid()
+{
+    // reset uni-dim space
+    m_Dims = Vector4i(0,0,0,0);
+    m_Origin = Vector4f(0.,0.,0.,0.);
+    m_Increments = Vector4i(0,0,0,0);
+    m_binW = Vector4f(1.,1.,1.,1.);
+    m_debug = true;
+}
+
+
+//_____________________________________________________________
+void Structured4DGrid::SetDims(const Vector4i &size)
+{
+    this->m_Dims = size;
+
+    // set increments
+    this->m_Increments[0] = 1;
+    this->m_Increments[1] = m_Dims[0];
+    this->m_Increments[2] = m_Dims[0] * m_Dims[1];
+    this->m_Increments[3] = m_Dims[0] * m_Dims[1] * m_Dims[2];
+
+}
+
+//_____________________________________________________________
+void Structured4DGrid::SetPhysicalSpace(const Vector4f &origin, const Vector4f &spacing)
+{
+    m_Origin = origin;
+    m_binW = spacing;
+
+    m_uni2phys_T = Translation<float,4>(m_Origin) * Scaling(m_binW);
+    m_phys2uni_T = m_uni2phys_T.matrix().inverse();
+
+    return;
+}
+
+
+//_____________________________________________________________
+bool Structured4DGrid::IsInsideBounds(const Vector4f &pt) const
+{
+    Vector4i pLoc = this->PhysicsToUnitSpace(pt);
+    return this->IsInsideGrid(pLoc);
+}
+
+
+//_____________________________________________________________
+Vector4i Structured4DGrid::UnMap(int index) const
+{
+    Vector4i v( 0,0,0, 0 );
+    Vector4i iv = m_Increments;
+
+    int id = 0;
+    for(int k=0; k<4; ++k) {
+        int inc = iv.maxCoeff(&id);
+        v(id) = index / inc;
+        index -= v(id) * inc;
+        iv(id) = 0;
+    }
+    return v;
+}
+
+//_____________________________________________________________
+bool Structured4DGrid::IsInsideGrid(const Vector4i &v) const
+{
+    int vok = 1;
+    vok *= (v(0) >= 0 && v(0) < m_Dims[0]);
+    vok *= (v(1) >= 0 && v(1) < m_Dims[1]);
+    vok *= (v(2) >= 0 && v(2) < m_Dims[2]);
+    vok *= (v(3) >= 0 && v(3) < m_Dims[3]);
+    return vok;
+}
+
+
+//_____________________________________________________________
+Vector4i Structured4DGrid::PhysicsToUnitSpace(const Vector4f &pt) const
+{
+    Vector4i out;
+    Vector4f pLoc = m_phys2uni_T * pt;
+
+    out << (int)floor(pLoc(0)),
+                (int)floor(pLoc(1)),
+                (int)floor(pLoc(2)),
+                (int)floor(pLoc(3));
+
+    return out;
+}
+
+//_____________________________________________________________
+Vector4f Structured4DGrid::UnitToPhysicsSpace(const Vector4i &ind) const
+{
+    Vector4f p;
+    p = m_uni2phys_T * ind.cast<float>();
+
+    return p;
+}
+
+//_____________________________________________________________
+void Structured4DGrid::PrintSelf(std::ostream &o)
+{
+    o << "uLib Structured Data 4D: \n"
+      << "dim     = " << this->GetDims().transpose() << "\n"
+      << "spacing = " << this->GetSpacing().transpose() << "\n";
+}
+

src/Math/Structured4DGrid.h

@@ -0,0 +1,74 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 Structured4DGrid_H
+#define Structured4DGrid_H
+
+#include "Math/Dense.h"
+
+#include <Eigen/Dense>
+#include <Eigen/Geometry>
+
+using namespace Eigen;
+
+namespace uLib {
+
+class Structured4DGrid {
+public:
+
+    Structured4DGrid();
+
+    /// unit-space
+    void SetDims(const Vector4i &size);
+    inline Vector4i GetDims() {return m_Dims; }
+    bool IsInsideGrid(const Vector4i &v) const;
+    inline int Map(Vector4i index) const  { return (m_Increments.transpose() * index);}
+    Vector4i UnMap(int index) const;
+
+    /// physics-space
+    void SetPhysicalSpace(const Vector4f &origin, const Vector4f &spacing);
+    inline Vector4f GetSpacing() const {    return m_binW; }
+    inline Vector4f GetOrigin() const {    return m_Origin; }
+    bool IsInsideBounds(const Vector4f &pt) const;
+
+    /// operations
+    Vector4i PhysicsToUnitSpace(const Vector4f &pt) const;
+    Vector4f UnitToPhysicsSpace(const Vector4i &ind) const;
+    void PrintSelf(std::ostream &o);
+    void SetDebug(bool debug){ m_debug = debug; };
+
+private:
+    Vector4i m_Dims;
+    Vector4i m_Increments;
+    Vector4f m_binW;
+    Vector4f m_Origin;
+    bool m_debug;
+
+     Transform<float, 4, Eigen::Affine>  m_uni2phys_T;
+     Transform<float, 4, Eigen::Affine>  m_phys2uni_T;
+};
+}
+
+#endif // Structured4DGrid_H

src/Math/StructuredData.h

@@ -28,15 +28,12 @@
 #ifndef STRUCTUREDDATA_H
 #define STRUCTUREDDATA_H
 
-#include "Core/Macros.h"
-#include "Core/Object.h"
 #include "Math/Dense.h"
 
 namespace uLib {
 
-class StructuredData : public Object {
+class StructuredData {
 public:
-    typedef Object BaseClass;
     enum _Order
     {
         CustomOrder = 0,
@@ -53,22 +50,23 @@ public:
     StructuredData(const Vector3i &size);
 
     StructuredData(const StructuredData &copy) :
-        BaseClass(copy),
         m_DataOrder(copy.m_DataOrder),
         m_Dims(copy.m_Dims),
         m_Increments(copy.m_Increments)
     {}
 
 
-    uLibGetMacro(Dims,Vector3i)
+    inline Vector3i GetDims() const { return this->m_Dims; }
 
     void SetDims(const Vector3i &size);
 
-    uLibGetSetMacro(Increments,Vector3i)
+    inline Vector3i GetIncrements() const { return this->m_Increments; }
+
+    inline void SetIncrements(Vector3i name) { this->m_Increments = name; }
 
     void SetDataOrder(Order order = YXZ);
 
-    uLibGetMacro(DataOrder,Order)
+    inline Order GetDataOrder() const { return this->m_DataOrder; }
 
     bool IsInsideGrid(const Vector3i &v) const;
 

src/Math/StructuredGrid.h

@@ -28,7 +28,6 @@
 #ifndef U_MATH_STRUCTUREDGRID_H
 #define U_MATH_STRUCTUREDGRID_H
 
-#include "Core/Object.h"
 #include "Math/ContainerBox.h"
 #include "Math/StructuredData.h"
 

src/Math/Transform.h

@@ -49,7 +49,6 @@
 #ifndef U_TRANSFORM_H
 #define U_TRANSFORM_H
 
-#include <Core/Macros.h>
 #include <Eigen/Geometry>
 
 
@@ -80,7 +79,10 @@ public:
     {}
 
     Eigen::Affine3f& GetTransform() { return m_T; }
-    uLibGetSetMacro(Parent,AffineTransform *)
+
+    inline AffineTransform *GetParent() const { return this->m_Parent; }
+
+    inline void SetParent(AffineTransform *name) { this->m_Parent = name; }
 
     inline void SetMatrix (Matrix4f &mat) { m_T.matrix() = mat; }
     inline Matrix4f& GetMatrix () { return m_T.matrix(); }
@@ -108,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/TriangleMesh.h

@@ -28,14 +28,14 @@
 #ifndef TRIANGLEMESH_H
 #define TRIANGLEMESH_H
 
-#include "Core/Object.h"
+#include <vector>
-#include "Core/Vector.h"
+
 #include "Math/Dense.h"
 
 namespace uLib {
 
-class TriangleMesh : public Object {
+class TriangleMesh
-
+{
 public:
     void PrintSelf(std::ostream &o);
 
@@ -44,12 +44,12 @@ public:
     void AddTriangle(const Id_t *id);
     void AddTriangle(const Vector3i &id);
 
-    uLibRefMacro(Points,Vector<Vector3f>)
+    inline std::vector<Vector3f> & Points() { return this->m_Points; }
-    uLibRefMacro(Triangles,Vector<Vector3i>)
+    inline std::vector<Vector3i> & Triangles() { return this->m_Triangles; }
 
 private:
-    Vector<Vector3f> m_Points;
+    std::vector<Vector3f> m_Points;
-    Vector<Vector3i> m_Triangles;
+    std::vector<Vector3i> m_Triangles;
 
 };
 

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

@@ -28,13 +28,13 @@
 #ifndef U_MATH_VOXIMAGE_H
 #define U_MATH_VOXIMAGE_H
 
-#include "Core/Vector.h"
 #include "Core/StaticInterface.h"
 #include "Math/Dense.h"
 #include "Math/StructuredGrid.h"
 
 #include <iostream>
 #include <stdlib.h>
+#include <vector>
 
 namespace uLib {
 
@@ -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:
 
@@ -104,8 +114,8 @@ public:
         this->m_Data = copy.m_Data;
     }
 
-    uLibRefMacro(Data,Vector<T>)
+    inline std::vector<T> & Data() { return this->m_Data; }
-    inline const Vector<T>& ConstData() const { return m_Data; }
+    inline const std::vector<T>& ConstData() const { return m_Data; }
 
     inline const T& At(int i)              const { return m_Data.at(i); }
     inline const T& At(const Vector3i &id) const { return m_Data.at(Map(id)); }
@@ -213,7 +223,7 @@ public:
     }
 
 private:
-    Vector<T> m_Data;
+    std::vector<T> m_Data;
 };
 
 

src/Math/VoxImageFilter.h

@@ -29,7 +29,6 @@
 #define VOXIMAGEFILTER_H
 
 #include "Core/StaticInterface.h"
-#include "Core/Object.h"
 #include "Math/Dense.h"
 
 #include "Math/VoxImage.h"
@@ -64,7 +63,7 @@ protected:
 
 
 template < typename VoxelT, typename AlgorithmT >
-class VoxImageFilter : public Abstract::VoxImageFilter, public Object
+class VoxImageFilter : public Abstract::VoxImageFilter
 {
 
 public:
@@ -72,7 +71,7 @@ public:
 
     void Run();
 
-    void SetKernelNumericXZY(const Vector<float> &numeric);
+    void SetKernelNumericXZY(const std::vector<float> &numeric);
 
     void SetKernelSpherical(float (*shape)(float));
 
@@ -84,9 +83,9 @@ public:
     template < class ShapeT >
     void SetKernelWeightFunction( ShapeT shape );
 
-    uLibGetMacro(KernelData,Kernel<VoxelT>)
+    inline Kernel<VoxelT> GetKernelData() const { return this->m_KernelData; }
 
-    uLibGetMacro(Image,VoxImage<VoxelT> *)
+    inline VoxImage<VoxelT>* GetImage() const { return this->m_Image; }
 
     void SetImage(Abstract::VoxImage *image);
 

src/Math/VoxImageFilter.hpp

@@ -48,14 +48,14 @@ public:
     inline T& operator[](const int &id) { return m_Data[id]; }
     inline int GetCenterData() const;
 
-    uLibRefMacro(Data,Vector<T>)
+    inline std::vector<T> & Data() { return this->m_Data; }
 
-    inline const Vector<T>& ConstData() const { return this->m_Data; }
+    inline const std::vector<T>& ConstData() const { return this->m_Data; }
 
     void PrintSelf(std::ostream &o) const;
 
 private:
-    Vector<T> m_Data;
+    std::vector<T> m_Data;
 };
 
 template < typename T >
@@ -163,7 +163,7 @@ float VoxImageFilter<_TPLT_>::Distance2(const Vector3i &v)
 
 
 _TPL_
-void VoxImageFilter<_TPLT_>::SetKernelNumericXZY(const Vector<float> &numeric)
+void VoxImageFilter<_TPLT_>::SetKernelNumericXZY(const std::vector<float> &numeric)
 {
     // set data order //
     StructuredData::Order order = m_KernelData.GetDataOrder();
@@ -268,8 +268,8 @@ void VoxImageFilter<_TPLT_>::SetImage(Abstract::VoxImage *image)
 _TPL_
 float VoxImageFilter<_TPLT_>::Convolve(const VoxImage<VoxelT> &buffer, int index)
 {
-    const Vector<VoxelT> &vbuf = buffer.ConstData();
+    const std::vector<VoxelT> &vbuf = buffer.ConstData();
-    const Vector<VoxelT> &vker = m_KernelData.ConstData();
+    const std::vector<VoxelT> &vker = m_KernelData.ConstData();
     int vox_size = vbuf.size();
     int ker_size = vker.size();
     int pos;

src/Math/VoxImageFilter2ndStat.hpp

@@ -50,8 +50,8 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;

src/Math/VoxImageFilterABTrim.hpp

@@ -59,13 +59,13 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
 
-        Vector<VoxelT> mfh(ker_size);
+        std::vector<VoxelT> mfh(ker_size);
         for (int i = 0; i < ker_size; ++i)
             mfh[i].Count = i; //index key for ordering function
         for (int ik = 0; ik < ker_size; ik++) {
@@ -126,13 +126,13 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
 
-        Vector<VoxelT> mfh(ker_size);
+        std::vector<VoxelT> mfh(ker_size);
         for (int i = 0; i < ker_size; ++i)
             mfh[i].Count = i; //index key for ordering function
         for (int ik = 0; ik < ker_size; ik++) {

src/Math/VoxImageFilterBilateral.hpp

@@ -50,8 +50,8 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
@@ -101,15 +101,15 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int img_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
 
 
 
-        Vector<FPair> mfh(ker_size);
+        std::vector<FPair> mfh(ker_size);
         for (int i = 0; i < ker_size; ++i)
             mfh[i].first = vker[i].Value; // kernel value in first
         for (int ik = 0; ik < ker_size; ik++) {

src/Math/VoxImageFilterCustom.hpp

@@ -32,6 +32,8 @@
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
 
+#define likely(expr) __builtin_expect(!!(expr), 1)
+
 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER CUSTOM  /////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -43,7 +45,7 @@ class VoxFilterAlgorithmCustom :
         public VoxImageFilter<VoxelT, VoxFilterAlgorithmCustom<VoxelT> > {
 
 
-    typedef float (* FunctionPt)(const Vector<Scalarf> &);
+    typedef float (* FunctionPt)(const std::vector<Scalarf> &);
 public:
     typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmCustom<VoxelT> > BaseClass;
     VoxFilterAlgorithmCustom(const Vector3i &size) :
@@ -53,14 +55,14 @@ public:
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
         if(likely(m_CustomEvaluate)) {
-            const Vector<VoxelT> &vbuf = buffer.ConstData();
+            const std::vector<VoxelT> &vbuf = buffer.ConstData();
-            const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+            const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
             int vox_size = vbuf.size();
             int ker_size = vker.size();
             int pos;
 
             float ker_sum = 0;
-            Vector<Scalarf> mfh(ker_size);
+            std::vector<Scalarf> mfh(ker_size);
             for (int ik = 0; ik < ker_size; ik++) {
                 pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
                 pos = (pos + vox_size) % vox_size;
@@ -76,7 +78,7 @@ public:
 
     }
 
-    uLibSetMacro(CustomEvaluate,FunctionPt)
+    inline void SetCustomEvaluate(FunctionPt funPt) { this->m_CustomEvaluate = funPt; }
 
 private:
     FunctionPt m_CustomEvaluate;

src/Math/VoxImageFilterLinear.hpp

@@ -48,8 +48,8 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;

src/Math/VoxImageFilterMedian.hpp

@@ -47,13 +47,13 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
 
-        Vector<float> mfh(ker_size);
+        std::vector<float> mfh(ker_size);
         for (int ik = 0; ik < ker_size; ik++) {
             pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
             pos = (pos + vox_size) % vox_size;

src/Math/VoxImageFilterUser.cpp

@@ -26,7 +26,6 @@
 
 
 
-#include "Core/Vector.h"
 #include "Dense.h"
 #include "VoxImage.h"
 #include "VoxImageFilterUser.h"

src/Math/VoxRaytracer.cpp

@@ -23,11 +23,12 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+#include <iostream>
 
-
-
-#include "VoxRaytracer.h"
 #include "Utils.h"
+#include "VoxRaytracer.h"
+
+#define unlikely(expr) __builtin_expect(!!(expr), 0)
 
 inline float fast_sign(float f) { return 1 - 2 * (f < 0); }
 
@@ -37,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();
@@ -67,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";
-    Vector<Element>::Iterator it;
+  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);
 
@@ -102,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(),
@@ -166,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 //
@@ -197,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);
@@ -212,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
@@ -220,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));
@@ -248,4 +240,4 @@ VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
   return ray;
 }
 
-}
+} // namespace uLib

src/Math/VoxRaytracer.h

@@ -29,8 +29,8 @@
 #define VOXRAYTRACER_H
 
 #include <math.h>
+#include <vector>
 
-#include "Core/Vector.h"
 #include "Math/StructuredGrid.h"
 
 namespace uLib {
@@ -51,13 +51,14 @@ public:
 
         void AppendRay ( const RayData &in);
 
-        uLibConstRefMacro(Data,Vector<Element>)
+        inline const std::vector<Element>& Data() const { return this->m_Data; }
-        uLibConstRefMacro(TotalLength,Scalarf)
+
+        inline const Scalarf& TotalLength() const { return this->m_TotalLength; }
 
         void PrintSelf(std::ostream &o);
 
     private:
-        Vector<Element> m_Data;
+        std::vector<Element> m_Data;
         Scalarf              m_TotalLength;
     };
 
@@ -78,7 +79,7 @@ public:
 
     RayData TraceLine(const HLine3f &line) const;
 
-    uLibGetMacro(Image,StructuredGrid *)
+    inline StructuredGrid* GetImage() const { return this->m_Image; }
 
 private:
     StructuredGrid *m_Image;

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,66 +40,72 @@ int test_ABTrim() {
 
   Accumulator_ABTrim<float> acc;
 
-    acc.SetABTrim(1,1);
+  acc.SetABTrim(1, 1);
 
-    Vector<float> v;
+  std::vector<float> v;
-    v << 1,5,5,5,300;
+  for (float tmpf : {1, 5, 5, 5, 300})
+    v.push_back(tmpf);
+  // v << 1,5,5,5,300;
 
-    for(Vector<float>::Iterator itr=v.begin(); itr<v.end(); itr++)
+  for (std::vector<float>::iterator itr = v.begin(); itr < v.end(); itr++)
     acc += *itr;
 
-    std::cout << "Accumulating  Trim(1,1) vector: "
+  // TODO missing operator <<
-              << v << " ... out = " << acc() << "\n";
+  // 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;
-    Vector<float> v;
+  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

@@ -14,5 +14,11 @@ set(TESTS
         BitCodeTest
 )
 
+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/VoxImageFilterTest.cpp

@@ -63,7 +63,7 @@ private:
 };
 
 
-static float MaxInVector(const Vector<float> &v)
+static float MaxInVector(const std::vector<float> &v)
 {
     float max = 0;
     for(int i=0; i<v.size(); ++i)
@@ -93,7 +93,7 @@ int main()
 
         VoxImage<TestVoxel> filtered = image;
 
-        Vector<float> values;
+        std::vector<float> values;
         for(int i=0; i < filter.GetKernelData().GetDims().prod(); ++i) {
             values.push_back(1.);
             std::cout << values[i] << " ";
@@ -128,7 +128,7 @@ int main()
 
         VoxFilterAlgorithmCustom<TestVoxel> filter(Vector3i(3,3,4));
 
-        Vector<float> values;
+        std::vector<float> values;
         for(int i=0; i < filter.GetKernelData().GetDims().prod(); ++i) {
             values.push_back(static_cast<float>(1));
         }

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 =
-        foreach (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,49 +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
-)
-
-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)
-list(APPEND SOURCES     uLibRootDict.cxx)
 
+set(rDictName ${PACKAGE_LIBPREFIX}RootDict)
+root_generate_dictionary(${rDictName} ${DICTIONARY_HEADERS}
+                         LINKDEF Linkdef.h)
+set_source_files_properties(${rDictName}.cxx
+                            PROPERTIES GENERATED TRUE)
+set_source_files_properties(${rDictName}.h
+                            PROPERTIES GENERATED TRUE)
+list(APPEND SOURCES ${rDictName}.cxx)
 
-uLib_add_shared_library(${uLib-module})
+# TODO use a custom target linked to root_generate_dictionary
-add_subdirectory(testing)
+set(R_ARTIFACTS ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}_rdict.pcm
+                ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}.rootmap)
+install(FILES ${R_ARTIFACTS}
+        DESTINATION ${INSTALL_LIB_DIR})
+
+set(libname ${PACKAGE_LIBPREFIX}Root)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Root PARENT_SCOPE)
+
+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,49 +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+;
 
 #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/muCastorInfo.cpp

@@ -0,0 +1,44 @@
+//------------------------------------------------
+// The Virtual Monte Carlo examples
+// Copyright (C) 2007, 2008 Ivana Hrivnacova
+// All rights reserved.
+//
+// For the licensing terms see geant4_vmc/LICENSE.
+// Contact: vmc@pcroot.cern.ch
+//-------------------------------------------------
+
+/// \file muCastorInfo.cxx 
+/// \brief Implementation of the muCastorInfo class 
+///
+/// \author G. Bonomi, A. Donzella - INFN
+
+#include <iostream>
+
+#include "muCastorInfo.h"
+
+/// \cond CLASSIMP
+ClassImp(muCastorInfo)
+/// \endcond
+
+using namespace std;
+
+//_____________________________________________________________________________
+muCastorInfo::muCastorInfo() 
+  : fMuGen(-1)
+{
+/// Default constructor
+}
+//_____________________________________________________________________________
+muCastorInfo::~muCastorInfo() 
+{
+/// Destructor
+}
+//_____________________________________________________________________________
+void muCastorInfo::Print(const Option_t* /*opt*/) const
+{
+/// Printing
+
+  cout << "  Generated muons: " << fMuGen 
+       << endl;
+}
+

src/Root/muCastorInfo.h

@@ -0,0 +1,44 @@
+#ifndef muCastor_RUN_H
+#define muCastor_RUN_H
+
+//------------------------------------------------
+// The Virtual Monte Carlo examples
+// Copyright (C) 2007, 2008 Ivana Hrivnacova
+// All rights reserved.
+//
+// For the licensing terms see geant4_vmc/LICENSE.
+// Contact: vmc@pcroot.cern.ch
+//-------------------------------------------------
+
+/// \file muCastorInfo.h
+/// \brief Definition of the muCastorInfo class 
+///
+/// \authors G. Bonomi, A. Donzella - INFN
+
+#include <TObject.h>
+#include <TVector3.h>
+
+class muCastorInfo : public TObject
+{
+  public:
+    muCastorInfo();
+    virtual ~muCastorInfo();
+
+    // methods
+    virtual void Print(const Option_t* option = "") const;
+
+    void SetMuGen  (Int_t muGen)  { fMuGen = muGen; };
+    void SetMuTrk  (Int_t muTrk)  { fMuTrk = muTrk; };
+
+    Int_t GetMuGen()   { return fMuGen; };
+
+  private:
+    Int_t      fMuGen;   // Generated muons
+    Int_t      fMuTrk;   // Tracked muons
+    
+  ClassDef(muCastorInfo,1) //muCastorInfo  
+};
+
+#endif //muCastor_RUN_H
+
+

src/Root/muCastorMCTrack.cpp

@@ -6,11 +6,9 @@
 //         Martin Subieta   martin.subieta@ing.unibs.it
 //******************************************************************************************
 
-#include <iostream>
-
-#include "Detectors/MuonScatter.h"
 #include <Root/muCastorMCTrack.h>
 #include <TClonesArray.h>
+#include <iostream>
 
 using namespace std;
 
@@ -32,8 +30,6 @@ uLib::MuonScatter &operator << (uLib::MuonScatter &mu, const muCastorMCTrack &bs
     return mu;
 }
 
-//namespace ROOT {
-//namespace Mutom {
 // -----   Default constructor   -------------------------------------------
 muCastorMCTrack::muCastorMCTrack()
 {
@@ -223,5 +219,3 @@ void muCastorMCTrack::Reset()
    fPntE       = 0;
 
 }
-//} // Mutom
-//} // ROOT

src/Root/muCastorMCTrack.h

@@ -9,20 +9,14 @@
 //         Martin Subieta   martin.subieta@ing.unibs.it
 //########################################
 
+#include <iostream>
 #include "vector"
 #include "TObject.h"
 #include "TParticle.h"
+#include "Detectors/MuonScatter.h"
 
 class TClonesArray;
 
-
-namespace uLib {
-class MuonScatter;
-}
-
-//namespace ROOT {
-//namespace Mutom {
-
 class muCastorMCTrack : public TObject
 {
 
@@ -89,8 +83,6 @@ public:
   ClassDef(muCastorMCTrack,1);
 
 };
-//} // Mutom
-//} // ROOT
 
 uLib::MuonScatter &operator << (uLib::MuonScatter &mu, const muCastorMCTrack &bsmu);
 #endif //muCastor_MCTRACK_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)