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

fix mismatch Origin - Position

.gitignore

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

.vscode/settings.json

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

CMake/uLibCommon.cmake

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

CMake/uLibTargetMacros.cmake

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

CMakeLists.txt

@@ -3,7 +3,7 @@
 ##### CMAKE LISTS ##############################################################
 ################################################################################
 
-cmake_minimum_required (VERSION 2.6)
+cmake_minimum_required (VERSION 3.26)
 
 ## -------------------------------------------------------------------------- ##
 
@@ -11,7 +11,7 @@ project(uLib)
 
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 3)
+set(PROJECT_VERSION_MINOR 6)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
@@ -33,19 +33,31 @@ message(STATUS "Module path = ${CMAKE_MODULE_PATH}")
 
 ## GLOBALS ------------------------------------------------------------------ ##
 
-set(PACKAGE_INSTALL_BIN_DIR ${CMAKE_INSTALL_PREFIX}/bin 
-    CACHE PATH "Installation directory for executables")
-set(PACKAGE_INSTALL_LIB_DIR ${CMAKE_INSTALL_PREFIX}/lib/
-    CACHE PATH "Installation directory for libraries")
-set(PACKAGE_INSTALL_INC_DIR ${CMAKE_INSTALL_PREFIX}/include/${PACKAGE_NAME}
-    CACHE PATH "Installation directory for headers")
-set(PACKAGE_INSTALL_DATA_DIR ${CMAKE_INSTALL_PREFIX}/share/${PACKAGE_NAME}
-    CACHE PATH "Installation directory for data files")
-set(PACKAGE_INSTALL_CMAKE_DIR ${CMAKE_INSTALL_PREFIX}/lib/cmake/${PACKAGE_NAME}
-    CACHE PATH "Installation directory for CMake files")
+# -- move to GnuInstallDirs
+# ref: https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+include(GNUInstallDirs)
+set(INSTALL_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of header files (.../include)" )
+set(INSTALL_ETC_DIR ${CMAKE_INSTALL_SYSCONFDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of configuration files (.../etc)" )
+set(INSTALL_BIN_DIR ${CMAKE_INSTALL_BINDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of executable files (.../bin)" )
+set(INSTALL_LIB_DIR ${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "Location of library files (.../lib)" )
+set(INSTALL_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PACKAGE_NAME}
+    CACHE PATH "Location of cmake files (.../lib/cmake)" )   
+set(INSTALL_DATA_DIR ${CMAKE_INSTALL_DATADIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of data files (.../share)" )
+
+
+
 
 set(SRC_DIR ${PROJECT_SOURCE_DIR}/src)
 
+# this is used to be exported in build target 
+# ( to compile against build directory instead of install )
+set(ULIB_SOURCE_DIR ${PROJECT_SOURCE_DIR})
+
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
     message(STATUS "Setting build type to 'Release' as none was specified.")
     set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
@@ -60,27 +72,60 @@ set(CMAKE_CXX_WARNING_OPTION ""
 set(CMAKE_VERBOSE_MAKEFILE FALSE
     CACHE STRING "Verbose compile output switch")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x ${CMAKE_CXX_WARNING_OPTION}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_WARNING_OPTION}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
+
+# CTEST framework
+include(CTest)
+enable_testing()
 
-#enable_testing()
 
 ## FIND PACKAGES ------------------------------------------------------------ ##
 
 set(Boost_USE_STATIC_LIBS OFF)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
-find_package(Boost 1.45.0 COMPONENTS program_options REQUIRED)
+message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}")
+find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_framework REQUIRED)
 include_directories(${Boost_INCLUDE_DIRS})
 
 find_package(Eigen3 CONFIG REQUIRED)
-include(${EIGEN3_USE_FILE})
+get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+include_directories(${EIGEN3_INCLUDE_DIRS})
 
 find_package(ROOT CONFIG REQUIRED)
 include(${ROOT_USE_FILE})
 
-find_package(VTK CONFIG REQUIRED)
-include(${VTK_USE_FILE})
+find_package(VTK REQUIRED)
+# 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)
@@ -119,7 +164,7 @@ configure_file("${PROJECT_SOURCE_DIR}/CMakeConfig.in.h"
                "${PROJECT_BINARY_DIR}/config.h")
 
 install(FILES "${PROJECT_BINARY_DIR}/config.h"
-        DESTINATION ${PACKAGE_INSTALL_INC_DIR})
+        DESTINATION ${INSTALL_INC_DIR})
 
 ## ADD LIBRARIES SUBDIRECTORIES --------------------------------------------- ##
 
@@ -164,8 +209,8 @@ add_subdirectory(${SRC_DIR}/Vtk)
 
 
 # Create the FooBarConfig.cmake and FooBarConfigVersion files
-file(RELATIVE_PATH REL_INCLUDE_DIR "${PACKAGE_INSTALL_CMAKE_DIR}"
-   "${PACKAGE_INSTALL_INC_DIR}")
+# file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}"
+#    "${INSTALL_INC_DIR}")
 
 # ... for the build tree
 #set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}")
@@ -174,21 +219,53 @@ file(RELATIVE_PATH REL_INCLUDE_DIR "${PACKAGE_INSTALL_CMAKE_DIR}"
 
 # ... for the install tree
 set(CONF_INCLUDE_DIRS "\${ULIB_CMAKE_DIR}/${REL_INCLUDE_DIR}")
-configure_file(uLibConfig.cmake.in
-               "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
-               @ONLY)
+# [ removed for the configure_config_file ]
+# configure_file(uLibConfig.cmake.in
+#                "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+#                @ONLY)
 
 # ... for both
 configure_file(uLibConfigVersion.cmake.in
-               "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake" @ONLY)
+                "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake" @ONLY)
 
-install(FILES "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+
+# from CMake 3.x configure file shall be created using a dedicated function
+# see: https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html
+#
+include(CMakePackageConfigHelpers)
+configure_package_config_file(uLibConfig.cmake.in
+                              "${PROJECT_BINARY_DIR}/uLibConfig.cmake"
+                              INSTALL_DESTINATION ${INSTALL_CMAKE_DIR}
+                              PATH_VARS 
+                                INSTALL_LIB_DIR 
+                                INSTALL_INC_DIR 
+                                INSTALL_BIN_DIR 
+                                INSTALL_CMAKE_DIR 
+                                INSTALL_ETC_DIR 
+                                INSTALL_DATA_DIR
+                                ULIB_SOURCE_DIR
+                                ULIB_SHARED_LIBRARIES
+                              # NO_SET_AND_CHECK_MACRO
+                              # NO_CHECK_REQUIRED_COMPONENTS_MACRO
+                              )
+
+install(FILES "${PROJECT_BINARY_DIR}/uLibConfig.cmake"
               "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake"
-        DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}"
+        DESTINATION "${INSTALL_CMAKE_DIR}"
         COMPONENT dev)
 
+
+# this is a special target file for the build tree
+# it is used also to identify if we are using a build direcory
+# to link a project against uLib. see: uLibConfig.cmake ( IF )
+export (TARGETS ${ULIB_SHARED_LIBRARIES}
+        FILE "${PROJECT_BINARY_DIR}/uLibTargets-build.cmake"
+        # NAMESPACE "uLib::"
+)        
+
 # Install the export set for use with the install-tree
-install(EXPORT "${PROJECT_NAME}Targets"
-        DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}"
+install(EXPORT "uLibTargets"
+        FILE "uLibTargets.cmake"
+        DESTINATION "${INSTALL_CMAKE_DIR}"
         COMPONENT dev)
 

CMakeUserPresets.json

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

README.md

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

build.log

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

conanfile.txt

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

condaenv.yml

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

src/Core/CMakeLists.txt

@@ -1,10 +1,9 @@
 
-set(HEADERS Options.h
-            StaticInterface.h)
+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)
 
-set(SOURCES Options.cpp)
+set(SOURCES Archives.cpp Debug.cpp Object.cpp Options.cpp Serializable.cpp Signal.cpp Uuid.cpp)
 
-set(LIBRARIES ${Boost_PROGRAM_OPTIONS_LIBRARY})
+set(LIBRARIES Boost::program_options)
 
 set(libname ${PACKAGE_LIBPREFIX}Core)
 set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
@@ -18,10 +17,12 @@ target_link_libraries(${libname} ${LIBRARIES})
 
 install(TARGETS ${libname}
         EXPORT "${PROJECT_NAME}Targets"
-        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
-
-install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Core)
-
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
 
+install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Core)
 
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Core/Export.h

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

src/Core/Makefile.am

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

src/Core/Object.cpp

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

src/Core/Object.h

@@ -23,200 +23,186 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #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
-} // boost
-
+} // namespace archive
+} // namespace boost
 
 namespace uLib {
 
-
 class Version {
 public:
-    static const char *PackageName;
-    static const char *VersionNumber;
-    static const char *Release;
+  static const char *PackageName;
+  static const char *VersionNumber;
+  static const char *Release;
 };
 
-
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 //// OBJECT ////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
-
 /**
  * @brief Object class is the object base implementation for uLib Framework.
  */
-class Object : public ObjectPropable
-{
-
+class Object {
 
 public:
-    //    std::string name;
-    //    void PrintName() { std::cout << "Ob name: " << name << "\n"; }
+  //    std::string name;
+  //    void PrintName() { std::cout << "Ob name: " << name << "\n"; }
 
-    Object();
-    Object(const Object &copy);
-    ~Object();
+  Object();
+  Object(const Object &copy);
+  ~Object();
 
-    ////////////////////////////////////////////////////////////////////////////
-    // PARAMETERS //
+  ////////////////////////////////////////////////////////////////////////////
+  // PARAMETERS //
 
-    // FIXX !!!
-    virtual void DeepCopy(const Object &copy);
+  // FIXX !!!
+  virtual void DeepCopy(const Object &copy);
 
+  ////////////////////////////////////////////////////////////////////////////
+  // SERIALIZATION //
 
-    ////////////////////////////////////////////////////////////////////////////
-    // SERIALIZATION //
+  template <class ArchiveT>
+  void serialize(ArchiveT &ar, const unsigned int version) {}
+  template <class ArchiveT>
+  void save_override(ArchiveT &ar, const unsigned int version) {}
 
-    template <class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version)    {
-                ObjectPropable::serialize(ar,version);
+  void SaveConfig(std::ostream &os, int version = 0);
+  void LoadConfig(std::istream &is, int version = 0);
+
+  static void SaveXml(std::ostream &os, Object &ob);
+  static void LoadXml(std::istream &is, Object &ob);
+
+  ////////////////////////////////////////////////////////////////////////////
+  // SIGNALS //
+
+  // Qt4 style connector //
+  static bool connect(const Object *ob1, const char *signal_name,
+                      const Object *receiver, const char *slot_name) {
+    //        // NOT WORKING YET //
+    //        1) find slot pointer from name
+    //        SignalBase   *sig = ob1->findSignal(signal_name);
+    //        GenericMFPtr *slo = receiver->findSlot(slot_name);
+    //        if(sig && slo)
+    //            return Object::connect(sig,slo->operator ()(),receiver);
+    //        else return false;
+    return false;
+  }
+
+  // Qt5 style connector //
+  template <typename Func1, typename Func2>
+  static bool
+  connect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
+          typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
+    SignalBase *sigb = sender->findOrAddSignal(sigf);
+    typedef boost::signals2::signal<
+        typename FunctionPointer<Func2>::SignalSignature>
+        SigT;
+    ConnectSignal(sigb, slof, receiver);
+    return true;
+  }
+
+  template <typename FuncT>
+  static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
+    ConnectSignal(sigb, slof, receiver);
+    return true;
+  }
+
+  template <typename FuncT>
+  inline
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+      addSignal(FuncT fun, const char *name) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    SignalBase *sig = NewSignal(fun);
+    addSignalImpl(sig, fun, name);
+    return (SigT *)sig;
+  }
+
+  template <typename FuncT> inline bool addSlot(FuncT fun, const char *name) {
+    return this->addSlotImpl(GenericMFPtr(fun), name);
+  }
+
+  template <typename FuncT>
+  inline
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+      findSignal(FuncT fptr) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    return (SigT *)findSignalImpl(GenericMFPtr(fptr));
+  }
+
+  template <typename FuncT>
+  inline
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+      findOrAddSignal(FuncT fptr) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    SignalBase *sig = findSignalImpl(GenericMFPtr(fptr));
+    if (!sig) {
+      sig = NewSignal(fptr);
+      addSignalImpl(sig, fptr, "signal_name_to_be_implemented");
     }
-    template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version) {}
+    return (SigT *)sig;
+  }
 
-    void SaveConfig(std::ostream &os, int version = 0);
-    void LoadConfig(std::istream &is, int version = 0);
+  inline SignalBase *findSignal(const char *name) const {
+    return findSignalImpl(name);
+  }
 
-    static void SaveXml(std::ostream &os, Object &ob);
-    static void LoadXml(std::istream &is, Object &ob);
+  inline GenericMFPtr *findSlot(const char *name) const {
+    return findSlotImpl(name);
+  }
 
+  void PrintSelf(std::ostream &o) const;
 
-
-    ////////////////////////////////////////////////////////////////////////////
-    // SIGNALS //
-
-    // Qt4 style connector //
-    static bool connect(const Object *ob1, const char *signal_name, const Object *receiver, const char *slot_name) {
-        //        // NOT WORKING YET //
-        //        1) find slot pointer from name
-        //        SignalBase   *sig = ob1->findSignal(signal_name);
-        //        GenericMFPtr *slo = receiver->findSlot(slot_name);
-        //        if(sig && slo)
-        //            return Object::connect(sig,slo->operator ()(),receiver);
-        //        else return false;
-    }
-
-    // Qt5 style connector //
-    template <typename Func1, typename Func2>
-    static bool connect( typename FunctionPointer<Func1>::Object *sender,   Func1 sigf,
-                         typename FunctionPointer<Func2>::Object *receiver, Func2 slof)
-    {
-        SignalBase *sigb = sender->findOrAddSignal(sigf);
-        typedef boost::signals2::signal<typename FunctionPointer<Func2>::SignalSignature> SigT;
-        ConnectSignal(sigb,slof,receiver);
-    }
-
-    template <typename FuncT>
-    static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
-        ConnectSignal(sigb,slof,receiver);
-    }
-
-
-    template< typename FuncT >
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    addSignal(FuncT fun, const char *name) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        SignalBase *sig = NewSignal(fun);
-        addSignalImpl(sig,fun,name);
-        return (SigT *)sig;
-    }
-
-    template< typename FuncT>
-    inline bool addSlot(FuncT fun, const char *name) {
-        this->addSlotImpl(GenericMFPtr(fun),name);
-    }
-
-    template < typename FuncT >
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    findSignal(FuncT fptr)
-    {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        return (SigT *)findSignalImpl(GenericMFPtr(fptr));
-    }
-
-    template < typename FuncT >
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    findOrAddSignal(FuncT fptr)
-    {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        SignalBase *sig = findSignalImpl(GenericMFPtr(fptr));
-        if(!sig) {
-            sig = NewSignal(fptr);
-            addSignalImpl(sig,fptr,"signal_name_to_be_implemented");
-        }
-        return (SigT *)sig;
-    }
-
-
-    inline SignalBase *
-    findSignal(const char *name) const
-    {
-        return findSignalImpl(name);
-    }
-
-    inline GenericMFPtr *
-    findSlot(const char *name) const
-    {
-        return findSlotImpl(name);
-    }
-
-
-    void PrintSelf(std::ostream &o) const;
-
-    inline const Object& operator = (const Object &copy)
-    { this->DeepCopy(copy); return *this; }
-
+  inline const Object &operator=(const Object &copy) {
+    this->DeepCopy(copy);
+    return *this;
+  }
 
 private:
-    bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
-    bool addSlotImpl(GenericMFPtr fptr, const char *name);
-    SignalBase   *findSignalImpl(const GenericMFPtr &fptr) const;
-    SignalBase   *findSignalImpl(const char *name) const;
-    GenericMFPtr *findSlotImpl(const char *name) const;
+  bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
+  bool addSlotImpl(GenericMFPtr fptr, const char *name);
+  SignalBase *findSignalImpl(const GenericMFPtr &fptr) const;
+  SignalBase *findSignalImpl(const char *name) const;
+  GenericMFPtr *findSlotImpl(const char *name) const;
 
-    friend class boost::serialization::access;
-    friend class ObjectPrivate;
-    class ObjectPrivate *d;
+  friend class boost::serialization::access;
+  friend class ObjectPrivate;
+  class ObjectPrivate *d;
 };
 
-
-
-} // uLib
+} // namespace uLib
 
 ////////////////////////////////////////////////////////////////////////////////
 
-//std::ostream & operator << (std::ostream &os, uLib::Object &ob);
-//std::ostream & operator << (std::ostream &os, uLib::Object *ob);
-//std::istream & operator >> (std::istream &is, uLib::Object &ob);
-
+// std::ostream & operator << (std::ostream &os, uLib::Object &ob);
+// std::ostream & operator << (std::ostream &os, uLib::Object *ob);
+// std::istream & operator >> (std::istream &is, uLib::Object &ob);
 
 #endif // U_OBJECT_H

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

src/Core/Signal.h

@@ -23,21 +23,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;
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -48,12 +46,12 @@
 #define slots
 #define signals /*virtual void init_signals();*/ public
 #define emit
-#define SLOT(a)     BOOST_STRINGIZE(a)
-#define SIGNAL(a)   BOOST_STRINGIZE(a)
+#define SLOT(a) BOOST_STRINGIZE(a)
+#define SIGNAL(a) BOOST_STRINGIZE(a)
 
-#define _ULIB_DETAIL_SIGNAL_EMIT(_name,...)                       \
-        static BOOST_AUTO(sig,this->findOrAddSignal(&_name));     \
-        sig->operator()(__VA_ARGS__);
+#define _ULIB_DETAIL_SIGNAL_EMIT(_name, ...)                                   \
+  static BOOST_AUTO(sig, this->findOrAddSignal(&_name));                       \
+  sig->operator()(__VA_ARGS__);
 
 /**
  * Utility macro to implement signal emission implementa una delle seguenti:
@@ -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>
-struct Signal {
-    typedef boost::signals2::signal<T> type;
+template <typename T> struct Signal {
+  typedef boost::signals2::signal<T> type;
 };
 
-
-
 ////////////////////////////////////////////////////////////////////////////////
 
-
 namespace detail {
 
+template <typename FuncT, int arity> struct ConnectSignal {};
 
-template <typename FuncT, int arity>
-struct ConnectSignal {};
-
-template <typename FuncT>
-struct ConnectSignal< FuncT, 0 > {
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(slof);
-    }
+template <typename FuncT> struct ConnectSignal<FuncT, 0> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(slof);
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 1 > {
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver));
-    }
+template <typename FuncT> struct ConnectSignal<FuncT, 1> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 2 > {
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1));
-    }
+template <typename FuncT> struct ConnectSignal<FuncT, 2> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 3 > {
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2));
-    }
+template <typename FuncT> struct ConnectSignal<FuncT, 3> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2));
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 4 > {
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3));
-    }
+template <typename FuncT> struct ConnectSignal<FuncT, 4> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2, _3));
+  }
 };
 
-template <typename FuncT>
-struct ConnectSignal< FuncT, 5 > {
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3,_4));
-    }
+template <typename FuncT> struct ConnectSignal<FuncT, 5> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2, _3, _4));
+  }
 };
 
+} // namespace detail
 
-} // detail
-
-
-
-template <typename FuncT>
-SignalBase *NewSignal(FuncT f) {
-    // seems to work wow !
-    return new Signal<void()>::type;
+template <typename FuncT> SignalBase *NewSignal(FuncT f) {
+  // seems to work wow !
+  return new Signal<void()>::type;
 }
 
 template <typename FuncT>
-void ConnectSignal(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver)
-{
-    detail::ConnectSignal< FuncT, FunctionPointer<FuncT>::arity >::connect(sigb,slof,receiver);
+void ConnectSignal(SignalBase *sigb, FuncT slof,
+                   typename FunctionPointer<FuncT>::Object *receiver) {
+  detail::ConnectSignal<FuncT, FunctionPointer<FuncT>::arity>::connect(
+      sigb, slof, receiver);
 }
 
-
-
-
-} // uLib
+} // namespace uLib
 
 #endif // SIGNAL_H

src/Core/Types.h

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

src/Core/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_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
+       Boost::serialization
+       Boost::program_options
        ${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)
-    A() : numa(5552368) {}
-    int numa;
+struct A : Object {
+  uLibTypeMacro(A, Object) A() : numa(5552368) {}
+  int numa;
 };
 
-
 ULIB_SERIALIZABLE_OBJECT(A)
-ULIB_SERIALIZE_OBJECT(A,Object) {
-   ar & AR(numa);
-}
+ULIB_SERIALIZE_OBJECT(A, Object) { ar &AR(numa); }
 
 struct B : virtual Object {
-    uLibTypeMacro(B,Object)
-    B() : numb(5552369) {}
-    int numb;
+  uLibTypeMacro(B, Object) B() : numb(5552369) {}
+  int numb;
 };
 
 ULIB_SERIALIZABLE_OBJECT(B)
-ULIB_SERIALIZE_OBJECT(B,Object) { ar & AR(numb); }
-
+ULIB_SERIALIZE_OBJECT(B, Object) { ar &AR(numb); }
 
 struct C : B {
-    uLibTypeMacro(C,B)
-    C() : numc(5552370) {}
-    int numc;
+  uLibTypeMacro(C, B) C() : numc(5552370) {}
+  int numc;
 };
 
 ULIB_SERIALIZABLE_OBJECT(C)
-ULIB_SERIALIZE_OBJECT(C,B) { ar & AR(numc); }
+ULIB_SERIALIZE_OBJECT(C, B) { ar &AR(numc); }
 
-struct D : A,B {
-    uLibTypeMacro(D,A,B)
+struct D : A, B {
+  uLibTypeMacro(D, A, B)
 
-    D() : numd(5552371) {}
-    int numd;
+      D()
+      : numd(5552371) {}
+  int numd;
 };
 
 ULIB_SERIALIZABLE_OBJECT(D)
-ULIB_SERIALIZE_OBJECT(D,A,B) { ar & AR(numd); }
+ULIB_SERIALIZE_OBJECT(D, A, B) { ar &AR(numd); }
 
+int main() {
+  A o;
 
-
-main() {
-    A o; o.init_properties();
-
-    Archive::xml_oarchive(std::cout) << NVP(o);
-
+  Archive::xml_oarchive(std::cout) << NVP(o);
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

src/Core/testing/SerializeTest.cpp

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

src/Core/testing/StaticInterfaceTest.cpp

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

src/Detectors/CMakeLists.txt

@@ -2,5 +2,11 @@ set(HEADERS MuonScatter.h MuonError.h MuonEvent.h)
 
 set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
 
+
 install(FILES ${HEADERS}
-        DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Detectors)
+        DESTINATION ${INSTALL_INC_DIR}/Detectors)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Detectors/testing/CMakeLists.txt

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

src/Gui/Qt/QVTKViewport2/Makefile.am

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

src/Gui/Qt/QVTKViewport2/QVTKViewport2.pro

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

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

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

src/Gui/Qt/QVTKViewport2/main.cpp

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

src/Gui/Qt/QVTKViewport2/vtkviewport.cpp

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

src/Gui/Qt/QVTKViewport2/vtkviewport.h

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

src/Gui/Qt/QVTKViewport2/vtkviewport.ui

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

src/Math/BitCode.h

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

src/Math/CMakeLists.txt

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

src/Math/Dense.h

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

src/Math/Transform.h

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

src/Math/VoxImage.cpp

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

src/Math/VoxImage.h

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

src/Math/VoxRaytracer.cpp

@@ -23,11 +23,10 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
 #include <iostream>
 
-#include "VoxRaytracer.h"
 #include "Utils.h"
+#include "VoxRaytracer.h"
 
 #define unlikely(expr) __builtin_expect(!!(expr), 0)
 
@@ -39,215 +38,206 @@ namespace uLib {
 ///// RAY DATA /////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-void VoxRaytracer::RayData::AddElement(Id_t id, float L)
-{
-    Element el = {id, L};
-    m_Data.push_back(el);
-    m_TotalLength += 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)
-{
-    if (unlikely(!in.m_Data.size())) {
-        std::cout << "Warinig: PoCA on exit border!\n";
-        return;
-    }
-    else if (unlikely(!m_Data.size())) {
-        m_Data = in.m_Data;
-        std::cout << "Warinig: PoCA on entrance border!\n";
-        return;
-    }
-    else {
-        // Opzione 1) un voxel in piu' //
-        m_Data.reserve(m_Data.size() + in.m_Data.size());
-        m_Data.insert(m_Data.end(), in.m_Data.begin(), in.m_Data.end());
-        // Opzione 2) merge dei voxel nel poca.
-        //        RayData::Element &e1 = m_Data.back();
-        //        const RayData::Element &e2 = in.m_Data.front();
-        //        if(e1.vox_id == e2.vox_id)
-        //        {
-        //            m_Data.reserve(m_Data.size() + in.m_Data.size() - 1);
-        //            e1.L += e2.L; //fix//
-        //            m_Data.insert(m_Data.end(), in.m_Data.begin()+1, in.m_Data.end());
-        //        }
-        //        else {
-        //            m_Data.reserve(m_Data.size() + in.m_Data.size());
-        //            m_Data.insert(m_Data.end(), in.m_Data.begin(), in.m_Data.end());
-        //        }
-        m_TotalLength += in.m_TotalLength;
+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())) {
+    m_Data = in.m_Data;
+    std::cout << "Warinig: PoCA on entrance border!\n";
+    return;
+  } else {
+    // Opzione 1) un voxel in piu' //
+    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();
+    //        if(e1.vox_id == e2.vox_id)
+    //        {
+    //            m_Data.reserve(m_Data.size() + in.m_Data.size() - 1);
+    //            e1.L += e2.L; //fix//
+    //            m_Data.insert(m_Data.end(), in.m_Data.begin()+1,
+    //            in.m_Data.end());
+    //        }
+    //        else {
+    //            m_Data.reserve(m_Data.size() + in.m_Data.size());
+    //            m_Data.insert(m_Data.end(), in.m_Data.begin(),
+    //            in.m_Data.end());
+    //        }
+    m_TotalLength += in.m_TotalLength;
+  }
 }
 
-void VoxRaytracer::RayData::PrintSelf(std::ostream &o)
-{
-    o << "Ray: total lenght " << m_TotalLength << "\n";
-    std::vector<Element>::iterator it;
-    for(it = m_Data.begin(); it < m_Data.end(); ++it)
-        o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
+void VoxRaytracer::RayData::PrintSelf(std::ostream &o) {
+  o << "Ray: total lenght " << m_TotalLength << "\n";
+  std::vector<Element>::iterator it;
+  for (it = m_Data.begin(); it < m_Data.end(); ++it)
+    o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 //// RAY TRACER ////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
+bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt) {
+  Vector4f s = m_Image->GetLocalPoint(line.direction);
+  pt = m_Image->GetLocalPoint(line.origin);
 
-bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt)
-{
-    Vector4f s = m_Image->GetLocalPoint(line.direction);
-    pt = m_Image->GetLocalPoint(line.origin);
+  // Considers Structured grid dimensions //
+  Vector4f dims = m_Image->GetDims().homogeneous().cast<float>();
+  pt = pt.cwiseQuotient(dims);
+  s = s.cwiseQuotient(dims);
 
-    // Considers Structured grid dimensions //
-    Vector4f dims = m_Image->GetDims().homogeneous().cast<float>();
-    pt = pt.cwiseQuotient(dims);
-    s  = s.cwiseQuotient(dims);
+  float l = s.head(3).norm();
+  Vector3f L(l / s(0), l / s(1), l / s(2));
 
-    float l = s.head(3).norm();
-    Vector3f L(l/s(0), l/s(1), l/s(2));
+  Vector3f offset;
+  for (int i = 0; i < 3; ++i)
+    offset(i) = (s(i) > 0) - (pt(i) - floor(pt(i)));
+  offset = offset.cwiseProduct(L).cwiseAbs();
 
-    Vector3f offset;
-    for(int i=0;i<3;++i)
-        offset(i) = (s(i)>0) - (pt(i)-floor(pt(i))) ;
-    offset = offset.cwiseProduct(L).cwiseAbs();
-
-    int id; float d;
-    for(int loop=0; loop<8; loop++)
-    {
-        int check_border = 0;
-        for ( int i=0; i<3 ;++i) {
-            check_border += pt(i) > 1;
-            check_border += pt(i) < 0;
-        }
-        if(check_border == 0) {
-            for(int i=0;i<3;++i)
-                pt(i) *= (float)dims(i);
-            pt = m_Image->GetWorldPoint(pt);
-            return true;
-        }
-
-       d = offset.minCoeff(&id);
-       for(int i=0; i<3; ++i)
-           pt(i) += d / L(i);
-
-       pt(id) = rintf(pt(id));
-
-
-       offset.array() -= d;
-       offset(id) = fabs(L(id));
+  int id;
+  float d;
+  for (int loop = 0; loop < 8; loop++) {
+    int check_border = 0;
+    for (int i = 0; i < 3; ++i) {
+      check_border += pt(i) > 1;
+      check_border += pt(i) < 0;
     }
-    for(int i=0;i<3;++i)
+    if (check_border == 0) {
+      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)
-{
-    HLine3f out = line;
-    out.direction *= -1;
-    return GetEntryPoint(out,pt);
-}
-
-
-VoxRaytracer::RayData VoxRaytracer::TraceBetweenPoints(const HPoint3f &in,
-                                                       const HPoint3f &out)
-const
-{
-    RayData ray;
-    Vector4f pt1 = m_Image->GetLocalPoint(in);
-    Vector4f pt2 = m_Image->GetLocalPoint(out);
-    Vector4f s = pt2 - pt1;
-
-    float l = s.head(3).norm();
-    Vector3f L(l/s(0), l/s(1), l/s(2));
-
-    // Vector3f scale; // FIXXX
-    // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
-    //          (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
-    //          (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
-
-    Vector3f offset;
-    for(int i=0;i<3;++i) offset(i) = (s(i)>=0) - (pt1(i)-floor(pt1(i))) ;
-    offset = offset.cwiseProduct(L).cwiseAbs();
-    L = L.cwiseAbs();
-
-    //---- Check if the ray only crosses one voxel
-    Vector3i vid = m_Image->Find(in);
-    if(vid == m_Image->Find(out)){
-      ray.AddElement(m_Image->Map(vid),s.norm());
-      return ray;
+      pt = m_Image->GetWorldPoint(pt);
+      return true;
     }
 
-    //---- Otherwise, loop until ray is finished
-    int id; float d;
-    while(l>0){
+    d = offset.minCoeff(&id);
+    for (int i = 0; i < 3; ++i)
+      pt(i) += d / L(i);
 
-      d = offset.minCoeff(&id);
+    pt(id) = rintf(pt(id));
 
-      if(m_Image->IsInsideGrid(vid)){
-	ray.AddElement(m_Image->Map(vid), d * m_scale(id) );
-      }
+    offset.array() -= d;
+    offset(id) = fabs(L(id));
+  }
+  for (int i = 0; i < 3; ++i)
+    pt(i) *= (float)dims(i);
+  pt = m_Image->GetWorldPoint(pt);
+  return false;
+}
 
-      // nan check //
-      //        if(unlikely(!isFinite(d * scale(id)))) {
-      //            std:: cout << "NAN in raytracer\n";
-      //            exit(1);
-      //        }
+bool VoxRaytracer::GetExitPoint(const HLine3f &line, HPoint3f &pt) {
+  HLine3f out = line;
+  out.direction *= -1;
+  return GetEntryPoint(out, pt);
+}
 
-      vid(id) += (int)fast_sign(s(id));
+VoxRaytracer::RayData
+VoxRaytracer::TraceBetweenPoints(const HPoint3f &in,
+                                 const HPoint3f &out) const {
+  RayData ray;
+  Vector4f pt1 = m_Image->GetLocalPoint(in);
+  Vector4f pt2 = m_Image->GetLocalPoint(out);
+  Vector4f s = pt2 - pt1;
 
-      l -= d;
-      offset.array() -= d;
-      offset(id) = fmin(L(id),l);
-    }
+  float l = s.head(3).norm();
+  Vector3f L(l / s(0), l / s(1), l / s(2));
+
+  // Vector3f scale; // FIXXX
+  // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
+  //          (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
+  //          (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
+
+  Vector3f offset;
+  for (int i = 0; i < 3; ++i)
+    offset(i) = (s(i) >= 0) - (pt1(i) - floor(pt1(i)));
+  offset = offset.cwiseProduct(L).cwiseAbs();
+  L = L.cwiseAbs();
+
+  //---- Check if the ray only crosses one voxel
+  Vector3i vid = m_Image->Find(in);
+  if (vid == m_Image->Find(out)) {
+    ray.AddElement(m_Image->Map(vid), s.norm());
     return ray;
+  }
+
+  //---- Otherwise, loop until ray is finished
+  int id;
+  float d;
+  while (l > 0) {
+
+    d = offset.minCoeff(&id);
+
+    if (m_Image->IsInsideGrid(vid)) {
+      ray.AddElement(m_Image->Map(vid), d * m_scale(id));
+    }
+
+    // nan check //
+    //        if(unlikely(!isFinite(d * scale(id)))) {
+    //            std:: cout << "NAN in raytracer\n";
+    //            exit(1);
+    //        }
+
+    vid(id) += (int)fast_sign(s(id));
+
+    l -= d;
+    offset.array() -= d;
+    offset(id) = fmin(L(id), l);
+  }
+  return ray;
 }
 
 // 20150528 SV for absorbed muons
-VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
-{
-    RayData ray;
+VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const {
+  RayData ray;
 
-    Vector4f pt = m_Image->GetLocalPoint(line.origin);
-    Vector4f s = m_Image->GetLocalPoint(line.direction);
+  Vector4f pt = m_Image->GetLocalPoint(line.origin);
+  Vector4f s = m_Image->GetLocalPoint(line.direction);
 
-    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));
+  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));
 
-    // RayTracer works with a grid of interspace +1
-    // Vector3f scale; // FIXXX
-    // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
-    //          (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
-    //          (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
+  // RayTracer works with a grid of interspace +1
+  // Vector3f scale; // FIXXX
+  // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
+  //          (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
+  //          (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
 
-    // offset is the fraction of the segment between grid lines when origin is insiede voxel
-    // cwiseAbs for having positive distances
-    Vector3f offset;
-    for(int i=0;i<3;++i)
-        offset(i) = (s(i)>=0) - (pt(i)-floor(pt(i)));
-    offset = offset.cwiseProduct(L).cwiseAbs();
-    L = L.cwiseAbs();
+  // offset is the fraction of the segment between grid lines when origin is
+  // insiede voxel cwiseAbs for having positive distances
+  Vector3f offset;
+  for (int i = 0; i < 3; ++i)
+    offset(i) = (s(i) >= 0) - (pt(i) - floor(pt(i)));
+  offset = offset.cwiseProduct(L).cwiseAbs();
+  L = L.cwiseAbs();
 
-    int id; float d;
-    Vector3i vid = m_Image->Find(line.origin);
-    while(m_Image->IsInsideGrid(vid))
-    {
-        // minimun coefficient of offset: id is the coordinate, d is the value
-        // dependig on which grid line horizontal or vertical it is first intercept
-        d = offset.minCoeff(&id);
+  int id;
+  float d;
+  Vector3i vid = m_Image->Find(line.origin);
+  while (m_Image->IsInsideGrid(vid)) {
+    // minimun coefficient of offset: id is the coordinate, d is the value
+    // dependig on which grid line horizontal or vertical it is first intercept
+    d = offset.minCoeff(&id);
 
-        // add Lij to ray
-        ray.AddElement(m_Image->Map(vid), d * m_scale(id) );
+    // add Lij to ray
+    ray.AddElement(m_Image->Map(vid), d * m_scale(id));
 
-        // move to the next voxel
-        vid(id) += (int)fast_sign(s(id));
+    // move to the next voxel
+    vid(id) += (int)fast_sign(s(id));
 
-        offset.array() -= d;
-        offset(id) = L(id);
-    }
-    return ray;
+    offset.array() -= d;
+    offset(id) = L(id);
+  }
+  return ray;
 }
 
-}
+} // namespace uLib

src/Math/testing/AccumulatorTest.cpp

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

src/Math/testing/CMakeLists.txt

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

src/Math/testing/TriangleMeshTest.cpp

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

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;
-//}
-
+//     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()
-{
-    BEGIN_TESTING(Math VoxRaytracer);
+int main() {
+  BEGIN_TESTING(Math VoxRaytracer);
 
-    StructuredGrid img(Vector3i(2,2,2));
-    img.SetSpacing(Vector3f(2,2,2));
-    img.SetPosition(Vector3f(-2,0,-2));
+  StructuredGrid img(Vector3i(2, 2, 2));
+  img.SetSpacing(Vector3f(2, 2, 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;
-        Raytracer rt(img);
-        HPoint3f pt;
-        TEST1( rt.GetEntryPoint(line,pt) );
-        TEST0( Vector4f0( pt - HPoint3f(0.2,4,0.2)  ) );
+  {
+    HLine3f line;
+    line.origin << 0.1, 4.1, 0.1, 1;
+    line.direction << 0.1, -0.1, 0.1, 0;
+    Raytracer rt(img);
+    HPoint3f pt;
+    TEST1(rt.GetEntryPoint(line, pt));
+    TEST0(Vector4f0(pt - HPoint3f(0.2, 4, 0.2)));
+  }
+
+  {
+    HLine3f line;
+    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));
+    TEST0(Vector4f0(pt - HPoint3f(2, 2, 2)));
+  }
+
+  { // Test a point inside image //
+    StructuredGrid img(Vector3i(4, 4, 4));
+    img.SetSpacing(Vector3f(2, 2, 2));
+    img.SetPosition(Vector3f(-4, -4, -4));
+    Raytracer ray(img);
+    HPoint3f pt;
+    HLine3f line;
+    line.origin = HPoint3f(-3, -3, -3);
+    //        line.direction = HVector3f(1,1,1); //
+    TEST1(ray.GetEntryPoint(line, pt));
+    TEST1(pt == HPoint3f(-3, -3, -3));
+
+    Raytracer::RayData rdata =
+        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";
     }
+  }
 
-    {
-        HLine3f line;
-        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) );
-        TEST0( Vector4f0( pt - HPoint3f(2,2,2)  ) );
-    }
+  {
+    HPoint3f pt1(1, -0.5, 1);
+    HPoint3f pt2(1, 4.5, 1);
+    Raytracer rt(img);
 
-    {   // Test a point inside image //
-        StructuredGrid img(Vector3i(4,4,4));
-        img.SetSpacing(Vector3f(2,2,2));
-        img.SetPosition(Vector3f(-4,-4,-4));
-        Raytracer ray(img);
-        HPoint3f pt;
-        HLine3f  line;
-        line.origin = HPoint3f(-3,-3,-3);
-        //        line.direction = HVector3f(1,1,1); //
-        TEST1( ray.GetEntryPoint(line,pt) );
-        TEST1( pt == HPoint3f(-3,-3,-3) );
+    Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
+    TEST1(ray.Data().size() == 2);
+    TEST1(ray.Data().at(0).vox_id == 6);
+    TEST1(ray.Data().at(1).vox_id == 7);
+    ray.PrintSelf(std::cout);
+  }
 
-        Raytracer::RayData rdata = 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(5, 1, 1);
+    HPoint3f pt2(-3, 1, 1);
+    Raytracer rt(img);
 
+    Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
+    TEST1(ray.Data().size() == 2);
+    TEST1(ray.Data().at(0).vox_id == 6);
+    TEST1(ray.Data().at(1).vox_id == 4);
+    ray.PrintSelf(std::cout);
+  }
 
-    {
-        HPoint3f pt1(1,-0.5,1);
-        HPoint3f pt2(1,4.5,1);
-        Raytracer rt(img);
+  {
+    HPoint3f pt1(1, 1, 1);
+    HPoint3f pt2(-1, 3, -1);
+    Raytracer rt(img);
 
-        Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
-        TEST1( ray.Data().size() == 2 );
-        TEST1( ray.Data().at(0).vox_id == 6 );
-        TEST1( ray.Data().at(1).vox_id == 7 );
-        ray.PrintSelf(std::cout);
-    }
+    Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
+    TEST1(ray.Data().size() == 4);
+    TEST1(ray.Data().at(0).vox_id == 6);
+    TEST1(ray.Data().at(1).vox_id == 4);
+    TEST1(ray.Data().at(2).vox_id == 5);
+    TEST1(ray.Data().at(3).vox_id == 1);
+    ray.PrintSelf(std::cout);
+  }
 
-    {
-        HPoint3f pt1(5,1,1);
-        HPoint3f pt2(-3,1,1);
-        Raytracer rt(img);
-
-        Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
-        TEST1( ray.Data().size() == 2 );
-        TEST1( ray.Data().at(0).vox_id == 6 );
-        TEST1( ray.Data().at(1).vox_id == 4 );
-        ray.PrintSelf(std::cout);
-    }
-
-    {
-        HPoint3f pt1(1,1,1);
-        HPoint3f pt2(-1,3,-1);
-        Raytracer rt(img);
-
-        Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
-        TEST1( ray.Data().size() == 4 );
-        TEST1( ray.Data().at(0).vox_id == 6 );
-        TEST1( ray.Data().at(1).vox_id == 4 );
-        TEST1( ray.Data().at(2).vox_id == 5 );
-        TEST1( ray.Data().at(3).vox_id == 1 );
-        ray.PrintSelf(std::cout);
-    }
-
-    END_TESTING
+  END_TESTING
 }
-
-
-
-
-
-
-
-

src/Root/CMakeLists.txt

@@ -1,30 +1,30 @@
-set(HEADERS TestTObject.h
-            RootMathDense.h
+set(HEADERS RootMathDense.h
             RootMuonScatter.h
             RootHitRaw.h
-            muBlastHit.h
-            muBlastMCTrack.h
             muCastorMCTrack.h
             muCastorHit.h
-            muCastorInfo.h)
+            muCastorInfo.h
+            muCastorSkinHit.h
+            muCastorPrimaryVertex.h
+            muCastorMuDetDIGI.h
+            SkinDetectorWriter.h)
 
-set(DICTIONARY_HEADERS TestTObject.h
-                       RootMathDense.h
-                       RootMuonScatter.h
-                       RootHitRaw.h
-                       muBlastHit.h
-                       muBlastMCTrack.h
-                       muCastorMCTrack.h
+set(SOURCES ${HEADERS} RootMuonScatter.cpp
+                       muCastorMCTrack.cpp
+                       muCastorHit.cpp
+                       muCastorInfo.cpp
+                       muCastorSkinHit.cpp
+                       muCastorPrimaryVertex.cpp
+                       muCastorMuDetDIGI.cpp
+                       SkinDetectorWriter.cpp)
+
+set(DICTIONARY_HEADERS muCastorMCTrack.h
                        muCastorHit.h
-                       muCastorInfo.h)
-
-set(SOURCES TestTObject.cpp
-            RootMuonScatter.cpp
-            muBlastHit.cpp
-            muBlastMCTrack.cpp
-            muCastorMCTrack.cpp
-            muCastorHit.cpp
-            muCastorInfo.cpp)
+                       muCastorInfo.h
+                       muCastorSkinHit.h
+                       muCastorPrimaryVertex.h
+                       muCastorMuDetDIGI.h
+                       SkinDetectorWriter.h)
 
 set(LIBRARIES ${ROOT_LIBRARIES}
               ${PACKAGE_LIBPREFIX}Math)
@@ -40,9 +40,9 @@ list(APPEND SOURCES ${rDictName}.cxx)
 
 # TODO use a custom target linked to root_generate_dictionary
 set(R_ARTIFACTS ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}_rdict.pcm
-                   ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}.rootmap)
+                ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}.rootmap)
 install(FILES ${R_ARTIFACTS}
-        DESTINATION ${PACKAGE_INSTALL_LIB_DIR})
+        DESTINATION ${INSTALL_LIB_DIR})
 
 set(libname ${PACKAGE_LIBPREFIX}Root)
 set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
@@ -51,14 +51,18 @@ set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Root PARENT_SCOPE)
 add_library(${libname} SHARED ${SOURCES})
 set_target_properties(${libname} PROPERTIES
                       VERSION ${PROJECT_VERSION}
-                      SOVERSION ${PROJECT_SOVERSION})
+                      SOVERSION ${PROJECT_SOVERSION}
+                      CXX_STANDARD 17)
 target_link_libraries(${libname} ${LIBRARIES})
 
 install(TARGETS ${libname}
         EXPORT "${PROJECT_NAME}Targets"
-        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
-
-install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Root)
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
 
+install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Root)
 
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Root/Linkdef.h

@@ -23,8 +23,6 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_ROOT_LINKDEF_H
 #define U_ROOT_LINKDEF_H
 
@@ -35,50 +33,21 @@
 #pragma link off all functions;
 #pragma link C++ nestedclasses;
 
-#pragma link C++ class TestTObject+;
-
 using namespace ROOT::Mutom;
 
-#pragma link C++ class ROOT::Math::Cartesian2D<int>+;
-#pragma link C++ class ROOT::Math::Cartesian2D<float>+;
-#pragma link C++ class ROOT::Math::Cartesian2D<double>+;
-
-#pragma link C++ class ROOT::Math::Cartesian3D<int>+;
-#pragma link C++ class ROOT::Math::Cartesian3D<float>+;
-#pragma link C++ class ROOT::Math::Cartesian3D<double>+;
-
-#pragma link C++ class Vector2i+;
-#pragma link C++ class Vector2f+;
-#pragma link C++ class Vector2d+;
-
-#pragma link C++ class Vector3i+;
-#pragma link C++ class Vector3f+;
-#pragma link C++ class Vector3d+;
-
-#pragma link C++ typedef Matrix3i;
-#pragma link C++ typedef Matrix3f;
-#pragma link C++ typedef Matrix3d;
-
-#pragma link C++ class Line3f+;
-#pragma link C++ class Line3d+;
-
-#pragma link C++ class MuonTrack+;
-#pragma link C++ class MuonScatter+;
-#pragma link C++ function MuonScatter::p_mean() const;
+#pragma link C++ class ROOT::Math::Cartesian3D < int> + ;
+#pragma link C++ class ROOT::Math::Cartesian3D < float> + ;
+#pragma link C++ class ROOT::Math::Cartesian3D < double> + ;
 
 // #pragma link C++ class DetectorChamber+;
 
-#pragma link C++ class HitRaw+;
-#pragma link C++ function HitRaw::Chm() const;
-#pragma link C++ function HitRaw::Rob() const;
-#pragma link C++ function HitRaw::Tdc() const;
-#pragma link C++ function HitRaw::Ch() const;
-
-#pragma link C++ class  muBlastMCTrack+;
-#pragma link C++ class  muBlastHit+;
-#pragma link C++ class  muCastorMCTrack+;
-#pragma link C++ class  muCastorHit+;
-#pragma link C++ class  muCastorInfo+;
+#pragma link C++ class muCastorMCTrack + ;
+#pragma link C++ class muCastorHit + ;
+#pragma link C++ class muCastorInfo + ;
+#pragma link C++ class muCastorSkinHit + ;
+#pragma link C++ class muCastorPrimaryVertex + ;
+#pragma link C++ class muCastorMuDetDIGI + ;
+#pragma link C++ class SkinDetectorWriter + ;
 
 #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/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_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
+       Boost::serialization
+       Boost::program_options
        ${ROOT_LIBRARIES}
 )
-uLib_add_tests(${uLib-module})
+uLib_add_tests(Root)

src/Vtk/CMakeLists.txt

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

src/Vtk/testing/CMakeLists.txt

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

src/Vtk/uLibVtkInterface.cxx

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

src/Vtk/vtkContainerBox.cpp

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

src/Vtk/vtkMuonScatter.h

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

src/Vtk/vtkVoxImage.h

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

src/ltk/CMakeLists.txt

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

src/ltk/DenseMatrix.h

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

src/ltk/Makefile.am

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

src/ltk/Object.c

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

src/ltk/Object.h

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

src/ltk/Vector.h

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

src/ltk/container.h

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

src/ltk/ltk.h

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

src/ltk/ltk_bridge/ltkb.c

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

src/ltk/ltk_bridge/ltkb_test.c

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

src/ltk/ltk_bridge/setup.sh

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

src/ltk/ltkdebug.c

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

src/ltk/ltkdebug.h

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

src/ltk/ltkmacros.h

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

src/ltk/ltktypes.h

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

src/ltk/main.c

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

src/ltk/templates.c

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

src/ltk/templates.h

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

src/ltk/test_comma.h

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

src/ltk/testing/Makefile.am

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

src/ltk/testing/Object-cc.cpp

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

src/ltk/testing/Object.c

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

src/ltk/testing/Vector-cc.cpp

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

src/ltk/testing/Vector.c

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

src/ltk/testing/testing-prototype.h

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

src/utils/make_recipe/src/CMakeLists.txt

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

src/utils/moc/Makefile

@@ -1,24 +0,0 @@
-
-
-# Makefile example -- scanner and parser.
-#
-CXX     = g++ -D_DEBUG
-LEX     = flex
-YACC    = bison -y -t 
-YFLAGS  = -d
-objects = parse.o scan.o
-
-moc: $(objects)
-	$(CXX) -o $@ $(objects) -lfl
-
-parse.o: parse.y
-
-#       parse.h: parse.c
-#	mv -f y.tab.h parse.h
-
-scan.o: scan.l 
-
-
-clean:
-	rm -f *.o parse.tab.c parse.tab.h
-

src/utils/moc/moc_actions.h

@@ -1,92 +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 MOC_ACTION_H
-#define MOC_ACTION_H
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-
-#ifndef NDEBUG
-#define DEBUG( ... ) { printf(" /*["); printf( __VA_ARGS__ ); printf("]*/ "); }
-#else
-#define DEBUG( ... ) ;
-#endif
-
-#define CONCAT( dest , ... ) string_append(dest, __VA_ARGS__, NULL)
-
-char * string_append(char *first, ... ) {
-    va_list ap;
-    va_start (ap, first);         /* Initialize the argument list. */
-
-    char *str_in = first;
-    char *str = malloc(sizeof(char) * strlen(str_in));
-    strcat(str,str_in);
-
-    str_in = va_arg (ap,char *);
-    while (str_in) {
-        char *tmp = malloc(sizeof(char) * (strlen(str)+strlen(str_in)) );
-        memcpy(tmp,str,strlen(str));
-        memcpy(tmp+strlen(str),str_in,strlen(str_in));
-        free(str);
-        str = tmp;
-        str_in = va_arg (ap,char *);
-    }
-    return str;
-}
-
-
-
-
-
-
-// ACTIONS //
-
-
-
-#define SIMPLE_DECLARATION simple_declaration_action
-
-static int simple_declaration_action(const char *type, const char *ids);
-
-
-
-
-
-
-// move to implementation .. //
-static int simple_declaration_action(const char *type, const char *ids) {
-    DEBUG("simple_declaration -> type:\"%s\" decl:\"%s\" ",type,ids);
-    return 0;
-}
-
-
-
-
-
-#endif // MOC_ACTION_H

src/utils/moc/sample.cpp

@@ -1,51 +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.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-
-typedef int TestInt;
-
-class DerivedObject {
-
-
-public:
-
-    ULIB_OBJECT_PARAMETERS(test)
-    {
-       Bubu *a;
-    };
-    
-};
-
-int main() {
-
- ULIB_OBJECT_PARAMETERS(prova) {
-     int a,b;
-     char *c;
- };
-
- return 0;
-}

src/utils/moc/scan.l

@@ -1,252 +0,0 @@
-%option stack
-%{
-/* preamble */
-#include <ctype.h>
-#include <stdio.h>
-#include "y.tab.h"
-
-#define PRINT(str)  { printf("%s",str); }
-#define ENSTATE(st) { yy_push_state(YY_START); BEGIN(st); /*printf("ST[%i]",YY_START);*/ }
-#define EXSTATE     { BEGIN(yy_top_state()); yy_pop_state(); /*printf("ST[%i]",YY_START);*/ }
-
-#define SCANTEXT    { fill_sval(); }
-#define MATCH(name) { ECHO; SCANTEXT; return name; }
-
-int lineno;
-int moc_level = 0;
-
-static int yywrap(void);
-static void skip_until_eol(void);
-static void skip_comment(void);
-static int check_identifier(const char *);
-static int fill_sval();
-%}
-
-blank                           [\t\f\v\r ]+
-anyunch                         <*>.
-
-intsuffix			([uU][lL]?)|([lL][uU]?)
-fracconst			([0-9]*\.[0-9]+)|([0-9]+\.)
-exppart				[eE][-+]?[0-9]+
-floatsuffix			[fFlL]
-chartext			([^'])|(\\.)
-stringtext			([^"])|(\\.)
-
-digit				[0-9]
-hex				[0-9A-Fa-f]
-letter				[A-Z_a-z]
-simple_escape_sequence		(\\\'|\\\"|\\\?|\\\\|\\a|\\b|\\f|\\n|\\r|\\t|\\v)
-octal_escape_sequence		(\\[0-7]|\\[0-7][0-7]|\\[0-7][0-7][0-7])
-hexadecimal_escape_sequence	(\\x{hex}+)
-escape_sequence			({simple_escape_sequence}|{octal_escape_sequence}|{hexadecimal_escape_sequence})
-universal_character_name	(\\u{hex}{hex}{hex}{hex}|\\U{hex}{hex}{hex}{hex}{hex}{hex}{hex}{hex})
-non_digit			({letter}|{universal_character_name})
-identifier			({non_digit}({non_digit}|{digit})*)
-
-begin_comment        "/*"
-end_comment          "*/"
-begin_inline_comment "//"
-end_inline_comment   "\n"
-
-
-%s moc
-%x cmt
-%x inlcmt
-
-%%
-
-"\n"		{ ++lineno; ECHO; }
-{blank}         ECHO;
-
-{begin_comment}    { ENSTATE(cmt); ECHO; }
-<cmt>{end_comment} { EXSTATE;      ECHO; }
-
-{begin_inline_comment}       { ENSTATE(inlcmt); ECHO; }
-<inlcmt>{end_inline_comment} { EXSTATE;         ECHO; }
-
-
-property               { ECHO; ENSTATE(moc); return MOC_PROPERTY; }
-ULIB_OBJECT_PARAMETERS { ECHO; ENSTATE(moc); return MOC_OBJECT_PARAMETERS; }
-<moc>{
-              "{"        { moc_level++; MATCH('{'); }
-              "}"        { if(!--moc_level)EXSTATE; MATCH('}'); }
-
-              "<%"				{ MATCH('{'); }
-              "%>"				{ MATCH('}'); }
-              "["				{ MATCH('['); }
-              "<:"				{ MATCH('['); }
-              "]"				{ MATCH(']'); }
-              ":>"				{ MATCH(']'); }
-              "("				{ MATCH('('); }
-              ")"				{ MATCH(')'); }
-              ";"				{ MATCH(';'); }
-              "::"				{ MATCH(COLONCOLON); }
-              ":"				{ MATCH(':'); }
-              "..."				{ MATCH(ELLIPSIS); }
-              "?"				{ MATCH('?'); }
-              "."				{ MATCH('.'); }
-              ".*"				{ MATCH(DOTSTAR); }
-              "+"				{ MATCH('+'); }
-              "-"				{ MATCH('-'); }
-              "*"				{ MATCH('*'); }
-              "/"				{ MATCH('/'); }
-              "%"				{ MATCH('%'); }
-              "^"				{ MATCH('^'); }
-              "xor"				{ MATCH('^'); }
-              "&"				{ MATCH('&'); }
-              "bitand"				{ MATCH('&'); }
-              "|"				{ MATCH('|'); }
-              "bitor"				{ MATCH('|'); }
-              "~"				{ MATCH('~'); }
-              "compl"				{ MATCH('~'); }
-              "!"				{ MATCH('!'); }
-              "not"				{ MATCH('!'); }
-              "="				{ MATCH('='); }
-              "<"				{ MATCH('<'); }
-              ">"				{ MATCH('>'); }
-              "+="				{ MATCH(ADDEQ); }
-              "-="				{ MATCH(SUBEQ); }
-              "*="				{ MATCH(MULEQ); }
-              "/="				{ MATCH(DIVEQ); }
-              "%="				{ MATCH(MODEQ); }
-              "^="				{ MATCH(XOREQ); }
-              "xor_eq"				{ MATCH(XOREQ); }
-              "&="				{ MATCH(ANDEQ); }
-              "and_eq"				{ MATCH(ANDEQ); }
-              "|="				{ MATCH(OREQ); }
-              "or_eq"				{ MATCH(OREQ); }
-              "<<"				{ MATCH(SL); }
-              ">>"				{ MATCH(SR); }
-              "<<="				{ MATCH(SLEQ); }
-              ">>="				{ MATCH(SREQ); }
-              "=="				{ MATCH(EQ); }
-              "!="				{ MATCH(NOTEQ); }
-              "not_eq"				{ MATCH(NOTEQ); }
-              "<="				{ MATCH(LTEQ); }
-              ">="				{ MATCH(GTEQ); }
-              "&&"				{ MATCH(ANDAND); }
-              "and"				{ MATCH(ANDAND); }
-              "||"				{ MATCH(OROR); }
-              "or"				{ MATCH(OROR); }
-              "++"				{ MATCH(PLUSPLUS); }
-              "--"				{ MATCH(MINUSMINUS); }
-              ","				{ MATCH(','); }
-              "->*"				{ MATCH(ARROWSTAR); }
-              "->"				{ MATCH(ARROW); }
-
-              "asm"				{ MATCH(ASM); }
-              "auto"				{ MATCH(AUTO); }
-              "bool"				{ MATCH(BOOL); }
-              "break"				{ MATCH(BREAK); }
-              "case"				{ MATCH(CASE); }
-              "catch"				{ MATCH(CATCH); }
-              "char"				{ MATCH(CHAR); }
-              "class"				{ MATCH(CLASS); }
-              "const"				{ MATCH(CONST); }
-              "const_cast"			{ MATCH(CONST_CAST); }
-              "continue"			{ MATCH(CONTINUE); }
-              "default"				{ MATCH(DEFAULT); }
-              "delete"				{ MATCH(DELETE); }
-              "do"				{ MATCH(DO); }
-              "double"				{ MATCH(DOUBLE); }
-              "dynamic_cast"			{ MATCH(DYNAMIC_CAST); }
-              "else"				{ MATCH(ELSE); }
-              "enum"				{ MATCH(ENUM); }
-              "explicit"			{ MATCH(EXPLICIT); }
-              "export"				{ MATCH(EXPORT); }
-              "extern"				{ MATCH(EXTERN); }
-              "false"				{ MATCH(FALSE); }
-              "float"				{ MATCH(FLOAT); }
-              "for"				{ MATCH(FOR); }
-              "friend"				{ MATCH(FRIEND); }
-              "goto"				{ MATCH(GOTO); }
-              "if"				{ MATCH(IF); }
-              "inline"				{ MATCH(INLINE); }
-              "int"                             { MATCH(INT); }
-              "long"				{ MATCH(LONG); }
-              "mutable"				{ MATCH(MUTABLE); }
-              "namespace"			{ MATCH(NAMESPACE); }
-              "new"				{ MATCH(NEW); }
-              "operator"			{ MATCH(OPERATOR); }
-              "private"				{ MATCH(PRIVATE); }
-              "protected"			{ MATCH(PROTECTED); }
-              "public"				{ MATCH(PUBLIC); }
-              "register"			{ MATCH(REGISTER); }
-              "reinterpret_cast"		{ MATCH(REINTERPRET_CAST); }
-              "return"				{ MATCH(RETURN); }
-              "short"				{ MATCH(SHORT); }
-              "signed"				{ MATCH(SIGNED); }
-              "sizeof"				{ MATCH(SIZEOF); }
-              "static"				{ MATCH(STATIC); }
-              "static_cast"			{ MATCH(STATIC_CAST); }
-              "struct"				{ MATCH(STRUCT); }
-              "switch"				{ MATCH(SWITCH); }
-              "template"			{ MATCH(TEMPLATE); }
-              "this"				{ MATCH(THIS); }
-              "throw"				{ MATCH(THROW); }
-              "true"				{ MATCH(TRUE); }
-              "try"				{ MATCH(TRY); }
-              "typedef"				{ MATCH(TYPEDEF); }
-              "typeid"				{ MATCH(TYPEID); }
-              "typename"			{ MATCH(TYPENAME); }
-              "union"				{ MATCH(UNION); }
-              "unsigned"			{ MATCH(UNSIGNED); }
-              "using"				{ MATCH(USING); }
-              "virtual"				{ MATCH(VIRTUAL); }
-              "void"				{ MATCH(VOID); }
-              "volatile"			{ MATCH(VOLATILE); }
-              "wchar_t"				{ MATCH(WCHAR_T); }
-              "while"				{ MATCH(WHILE); }
-              [a-zA-Z_][a-zA-Z_0-9]*		{ ECHO; return check_identifier(yytext); }
-
-              "0"[xX][0-9a-fA-F]+{intsuffix}?	{ ECHO; return INTEGER; }
-              "0"[0-7]+{intsuffix}?		{ ECHO; return INTEGER; }
-              [0-9]+{intsuffix}?		{ ECHO; return INTEGER; }
-
-              {fracconst}{exppart}?{floatsuffix}?	{ ECHO; return FLOATING; }
-              [0-9]+{exppart}{floatsuffix}?		{ ECHO; return FLOATING; }
-
-              "'"{chartext}*"'"			{ ECHO; return CHARACTER; }
-              "L'"{chartext}*"'"		{ ECHO; return CHARACTER; }
-              "\""{stringtext}*"\""		{ ECHO; return STRING; }
-              "L\""{stringtext}*"\""		{ ECHO; return STRING; }
-
-}
-
-%%
-
-static int yywrap(void)
-{
-        return 1;
-}
-
-
-static int fill_sval() {
-     int len = strlen(yytext);
-     if(len) {
-       yylval.sval = malloc(len);
-       strncpy(yylval.sval, yytext, len);
-     }
-     else {
-       yylval.sval = strdup("");
-     }
-     return len;
-}
-
-static int check_identifier(const char *s)
-{
-/*
-        switch (s[0]) {
-        case 'D': return TYPEDEF_NAME;
-        case 'N': return NAMESPACE_NAME;
-        case 'C': return CLASS_NAME;
-        case 'E': return ENUM_NAME;
-        case 'T': return TEMPLATE_NAME;
-        }
-*/
-
-        yylval.sval = malloc(strlen(yytext));
-        strncpy(yylval.sval, yytext, strlen(yytext));
-        return IDENTIFIER;
-}
-

uLib.files

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

uLibConfig.cmake.in

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