diff --git a/Core/CppMicroServices/CMakeLists.txt b/Core/CppMicroServices/CMakeLists.txt
index 80d0002101..9427072dee 100644
--- a/Core/CppMicroServices/CMakeLists.txt
+++ b/Core/CppMicroServices/CMakeLists.txt
@@ -1,449 +1,453 @@
 project(CppMicroServices)
 
 set(${PROJECT_NAME}_MAJOR_VERSION 2)
 set(${PROJECT_NAME}_MINOR_VERSION 99)
 set(${PROJECT_NAME}_PATCH_VERSION 0)
 set(${PROJECT_NAME}_VERSION ${${PROJECT_NAME}_MAJOR_VERSION}.${${PROJECT_NAME}_MINOR_VERSION}.${${PROJECT_NAME}_PATCH_VERSION})
 
 cmake_minimum_required(VERSION 2.8)
 cmake_policy(VERSION 2.8)
 cmake_policy(SET CMP0017 NEW)
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #------------------------------------------------------------------------------
 
 set(US_CMAKE_DIR ${PROJECT_SOURCE_DIR}/cmake)
 
 set(CMAKE_MODULE_PATH
   ${US_CMAKE_DIR}
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(CMakeParseArguments)
 include(CMakePackageConfigHelpers)
 include(CheckCXXSourceCompiles)
 include(usFunctionAddResources)
 include(usFunctionEmbedResources)
 include(usFunctionGetResourceSource)
 include(usFunctionCheckResourceLinking)
 include(usFunctionCheckCompilerFlags)
 include(usFunctionGetGccVersion)
 include(usFunctionGenerateModuleInit)
 include(usMacroCreateModule)
 
 if(US_BUILD_TESTING)
   include(usFunctionCompileSnippets)
 endif()
 
 #-----------------------------------------------------------------------------
 # Init output directories
 #-----------------------------------------------------------------------------
 
 set(US_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
 set(US_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
 set(US_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
 
 foreach(_type ARCHIVE LIBRARY RUNTIME)
   if(NOT CMAKE_${_type}_OUTPUT_DIRECTORY)
     set(CMAKE_${_type}_OUTPUT_DIRECTORY ${US_${_type}_OUTPUT_DIRECTORY})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Set a default build type if none was specified
 #-----------------------------------------------------------------------------
 
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "Setting build type to 'Debug' as none was specified.")
   set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
 
   # Set the possible values of build type for cmake-gui
   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
                STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
 endif()
 
 #-----------------------------------------------------------------------------
 # CMake options
 #-----------------------------------------------------------------------------
 
 function(us_cache_var _var_name _var_default _var_type _var_help)
   set(_advanced 0)
   set(_force)
   foreach(_argn ${ARGN})
     if(_argn STREQUAL ADVANCED)
       set(_advanced 1)
     elseif(_argn STREQUAL FORCE)
       set(_force FORCE)
     endif()
   endforeach()
 
   if(US_IS_EMBEDDED)
     if(NOT DEFINED ${_var_name} OR _force)
       set(${_var_name} ${_var_default} PARENT_SCOPE)
     endif()
   else()
     set(${_var_name} ${_var_default} CACHE ${_var_type} "${_var_help}" ${_force})
     if(_advanced)
       mark_as_advanced(${_var_name})
     endif()
   endif()
 endfunction()
 
 # Determine if we are being build inside a larger project
 if(NOT DEFINED US_IS_EMBEDDED)
   if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
     set(US_IS_EMBEDDED 0)
   else()
     set(US_IS_EMBEDDED 1)
   endif()
 endif()
 
 # Determine the name of the install component for "SDK" artifacts.
 # The default is "sdk"
 if(NOT DEFINED US_SDK_INSTALL_COMPONENT)
   set(US_SDK_INSTALL_COMPONENT COMPONENT sdk)
 elseif(US_SDK_INSTALL_COMPONENT)
   set(US_SDK_INSTALL_COMPONENT COMPONENT ${US_SDK_INSTALL_COMPONENT})
 endif()
 
 us_cache_var(US_ENABLE_AUTOLOADING_SUPPORT OFF BOOL "Enable module auto-loading support")
 us_cache_var(US_ENABLE_THREADING_SUPPORT OFF BOOL "Enable threading support")
 us_cache_var(US_ENABLE_DEBUG_OUTPUT OFF BOOL "Enable debug messages" ADVANCED)
 us_cache_var(US_BUILD_SHARED_LIBS ON BOOL "Build shared libraries")
 us_cache_var(US_BUILD_TESTING OFF BOOL "Build tests")
 us_cache_var(US_BUILD_EXAMPLES OFF BOOL "Build example projects")
 
 if(US_BUILD_TESTING)
   enable_testing()
 endif()
 
 if(WIN32 AND NOT CYGWIN)
   set(default_runtime_install_dir bin/)
   set(default_library_install_dir bin/)
   set(default_archive_install_dir lib/)
   set(default_header_install_dir include/)
   set(default_auxiliary_install_dir share/)
 else()
   set(default_runtime_install_dir bin/)
   set(default_library_install_dir lib/${PROJECT_NAME})
   set(default_archive_install_dir lib/${PROJECT_NAME})
   set(default_header_install_dir include/${PROJECT_NAME})
   set(default_auxiliary_install_dir share/${PROJECT_NAME})
 endif()
 
 us_cache_var(RUNTIME_INSTALL_DIR ${default_runtime_install_dir} STRING "Relative install location for binaries" ADVANCED)
 us_cache_var(LIBRARY_INSTALL_DIR ${default_library_install_dir} STRING "Relative install location for libraries" ADVANCED)
 us_cache_var(ARCHIVE_INSTALL_DIR ${default_archive_install_dir} STRING "Relative install location for archives" ADVANCED)
 us_cache_var(HEADER_INSTALL_DIR ${default_header_install_dir} STRING "Relative install location for headers" ADVANCED)
 us_cache_var(AUXILIARY_INSTALL_DIR ${default_auxiliary_install_dir} STRING "Relative install location for auxiliary files" ADVANCED)
 set(AUXILIARY_CMAKE_INSTALL_DIR ${AUXILIARY_INSTALL_DIR}/cmake)
 
 us_cache_var(US_NAMESPACE "us" STRING "The namespace for the C++ Micro Services symbols")
 
 set(BUILD_SHARED_LIBS ${US_BUILD_SHARED_LIBS})
 
 set(US_MODULE_INIT_TEMPLATE "${US_CMAKE_DIR}/usModuleInit.cpp" CACHE INTERNAL "The module initialization template code")
 set(US_RESOURCE_RC_TEMPLATE "${US_CMAKE_DIR}/us_resources.rc.in" CACHE INTERNAL "The Windows RC resource template")
 set(US_CMAKE_RESOURCE_DEPENDENCIES_CPP "${US_CMAKE_DIR}/usCMakeResourceDependencies.cpp" CACHE INTERNAL "The dummy resource dependencies code")
 
 #-----------------------------------------------------------------------------
 # US C/CXX Flags
 #-----------------------------------------------------------------------------
 
 if(US_IS_EMBEDDED)
   set(CMAKE_C_FLAGS)
   set(CMAKE_C_FLAGS_RELEASE)
   set(CMAKE_C_FLAGS_DEBUG)
   set(CMAKE_CXX_FLAGS)
   set(CMAKE_CXX_FLAGS_RELEASE)
   set(CMAKE_CXX_FLAGS_DEBUG)
   set(CMAKE_LINK_FLAGS)
   set(CMAKE_LINK_FLAGS_RELEASE)
   set(CMAKE_LINK_FLAGS_DEBUG)
 endif()
 
 # Set C++ compiler flags
 if(NOT MSVC)
   foreach(_cxxflag  -Werror -Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align
                     -Wwrite-strings -Woverloaded-virtual -Wnon-virtual-dtor -Wold-style-cast
                     -Wstrict-null-sentinel -Wsign-promo -fdiagnostics-show-option)
     usFunctionCheckCompilerFlags(${_cxxflag} US_CXX_FLAGS)
   endforeach()
 endif()
 
 set(US_HAVE_VISIBILITY_ATTRIBUTE 0)
 usFunctionCheckCompilerFlags("-fvisibility=hidden -fvisibility-inlines-hidden" _have_visibility)
 if(_have_visibility)
   set(US_HAVE_VISIBILITY_ATTRIBUTE 1)
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
 
   usFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
   if(${GCC_VERSION} VERSION_LESS "4.0.0")
     message(FATAL_ERROR "gcc version ${GCC_VERSION} not supported. Please use gcc >= 4.")
   endif()
 
   # With older versions of gcc the flag -fstack-protector-all requires an extra dependency to libssp.so.
   # If the gcc version is lower than 4.4.0 and the build type is Release let's not include the flag.
   if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
     usFunctionCheckCompilerFlags("-fstack-protector-all" US_CXX_FLAGS)
   endif()
 
   if(MINGW)
     # suppress warnings about auto imported symbols
     set(US_CXX_FLAGS "-Wl,--enable-auto-import ${US_CXX_FLAGS}")
     # we need to define a Windows version
     set(US_CXX_FLAGS "-D_WIN32_WINNT=0x0500 ${US_CXX_FLAGS}")
   else()
     # Enable visibility support (only for gcc >= 4.5)
     # We only support hidden visibility with gcc for now.
     #
     # Clang has troubles with correctly marking template declarations and explicit template
     # instantiations as exported across shared library boundaries. Specifically, comparing
     # type_info objects from STL types does not work (used in us::Any::Type() == typeid(std::string))
     # which could be related to the default visibility of STL types declared in libstdc++ and/or libc++
     # but also to using RTLD_LOCAL or RTLD_GLOBAL when loading shared libraries via dlopen().
     #
     # See http://comments.gmane.org/gmane.comp.compilers.clang.scm/50028
     # and http://llvm.org/bugs/show_bug.cgi?id=10113
     #
     if(_have_visibility AND NOT ${GCC_VERSION} VERSION_LESS "4.5")
       set(US_CXX_FLAGS "${US_CXX_FLAGS} ${_have_visibility}")
     else()
       set(US_GCC_RTTI_WORKAROUND_NEEDED 1)
     endif()
   endif()
 
   usFunctionCheckCompilerFlags("-O1 -D_FORTIFY_SOURCE=2" _fortify_source_flag)
   if(_fortify_source_flag)
     set(US_CXX_FLAGS_RELEASE "${US_CXX_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
   endif()
 endif()
 
 if(MSVC)
   set(US_CXX_FLAGS "/MP /WX /wd4996 /wd4251 /wd4503 ${US_CXX_FLAGS}")
 endif()
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${US_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${US_CXX_FLAGS_RELEASE}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${US_C_FLAGS}")
 set(CMAKE_C_FLAGS_REALEASE "${CMAKE_C_FLAGS_RELEASE} ${US_C_FLAGS_RELEASE}")
 
 #-----------------------------------------------------------------------------
 # US Link Flags
 #-----------------------------------------------------------------------------
 
 set(US_LINK_FLAGS )
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)
   foreach(_linkflag -Wl,--no-undefined)
     set(_add_flag)
     usFunctionCheckCompilerFlags("${_linkflag}" _add_flag)
     if(_add_flag)
       set(US_LINK_FLAGS "${US_LINK_FLAGS} ${_linkflag}")
     endif()
   endforeach()
 endif()
 
 usFunctionCheckResourceLinking()
 
 #-----------------------------------------------------------------------------
 # US Header Checks
 #-----------------------------------------------------------------------------
 
 include(CheckIncludeFileCXX)
 include(CheckCXXSourceCompiles)
 
 CHECK_INCLUDE_FILE_CXX(cxxabi.h US_HAVE_CXXABI_H)
 CHECK_INCLUDE_FILE_CXX(stdint.h US_HAVE_STDINT_H)
 CHECK_INCLUDE_FILE_CXX(tr1/unordered_map US_HAVE_TR1_UNORDERED_MAP_H)
 CHECK_INCLUDE_FILE_CXX(tr1/unordered_set US_HAVE_TR1_UNORDERED_SET_H)
 CHECK_INCLUDE_FILE_CXX(tr1/functional US_HAVE_TR1_FUNCTIONAL_H)
 CHECK_INCLUDE_FILE_CXX(unordered_map US_HAVE_UNORDERED_MAP_H)
 CHECK_INCLUDE_FILE_CXX(unordered_set US_HAVE_UNORDERED_SET_H)
 CHECK_INCLUDE_FILE_CXX(functional US_HAVE_FUNCTIONAL_H)
 
 if(US_HAVE_UNORDERED_MAP_H)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::tr1::unordered_map<int,int> m; return 0; }"
                             US_HAVE_TR1_UNORDERED_MAP)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::unordered_map<int,int> m; return 0; }"
                             US_HAVE_STD_UNORDERED_MAP)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::tr1::hash<int>(); return 0; }"
                             US_HAVE_TR1_HASH)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nint main() { std::hash<int>(); return 0; }"
                             US_HAVE_STD_HASH)
   if(US_HAVE_STD_HASH)
     CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend struct std::hash<int>; }; int main() { return 0; }"
                               US_HAVE_STD_HASH_STRUCT)
     CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend class std::hash<int>; }; int main() { return 0; }"
                               US_HAVE_STD_HASH_CLASS)
   elseif(US_HAVE_TR1_HASH)
     CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend struct std::tr1::hash<int>; }; int main() { return 0; }"
                               US_HAVE_TR1_HASH_STRUCT)
     CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>\nstruct A { friend class std::tr1::hash<int>; }; int main() { return 0; }"
                               US_HAVE_TR1_HASH_CLASS)
   endif()
 elseif(US_HAVE_TR1_UNORDERED_MAP_H)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::tr1::unordered_map<int,int> m; return 0; }"
                             US_HAVE_TR1_UNORDERED_MAP)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::unordered_map<int,int> m; return 0; }"
                             US_HAVE_STD_UNORDERED_MAP)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::tr1::hash<int>(); return 0; }"
                             US_HAVE_TR1_HASH)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nint main() { std::hash<int>(); return 0; }"
                             US_HAVE_STD_HASH)
   if(US_HAVE_STD_HASH)
     CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend struct std::hash<int>; }; int main() { return 0; }"
                               US_HAVE_STD_HASH_STRUCT)
     CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend class std::hash<int>; }; int main() { return 0; }"
                               US_HAVE_STD_HASH_CLASS)
   elseif(US_HAVE_TR1_HASH)
     CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend struct std::tr1::hash<int>; }; int main() { return 0; }"
                               US_HAVE_TR1_HASH_STRUCT)
     CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_map>\nstruct A { friend class std::tr1::hash<int>; }; int main() { return 0; }"
                               US_HAVE_TR1_HASH_CLASS)
   endif()
 else()
   message(SEND_ERROR "The header file \"unordered_map\" is not available.")
 endif()
 if(NOT (US_HAVE_TR1_UNORDERED_MAP OR US_HAVE_STD_UNORDERED_MAP))
   message(SEND_ERROR "The \"unordered_map\" type is not available.")
 endif()
 
 if(US_HAVE_UNORDERED_SET_H)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_set>\nint main() { std::tr1::unordered_set<int> s; return 0; }"
                             US_HAVE_TR1_UNORDERED_SET)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_set>\nint main() { std::unordered_set<int> s; return 0; }"
                             US_HAVE_STD_UNORDERED_SET)
 elseif(US_HAVE_TR1_UNORDERED_SET_H)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_set>\nint main() { std::tr1::unordered_set<int> s; return 0; }"
                             US_HAVE_TR1_UNORDERED_SET)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/unordered_set>\nint main() { std::unordered_set<int> s; return 0; }"
                             US_HAVE_STD_UNORDERED_SET)
 else()
   message(SEND_ERROR "The header file \"unordered_set\" is not available.")
 endif()
 if(NOT (US_HAVE_TR1_UNORDERED_SET OR US_HAVE_STD_UNORDERED_SET))
   message(SEND_ERROR "The \"unordered_set\" type is not available.")
 endif()
 
 if(NOT (US_HAVE_FUNCTIONAL_H OR US_HAVE_TR1_FUNCTIONAL_H))
   message(SEND_ERROR "The header file \"functional\" is not available.")
 endif()
 
 if(US_HAVE_FUNCTIONAL_H)
   CHECK_CXX_SOURCE_COMPILES("#include <functional>\nint main() { std::tr1::function<int(void)> f(main); return 0; }"
                             US_HAVE_TR1_FUNCTION)
   CHECK_CXX_SOURCE_COMPILES("#include <functional>\nint main() { std::function<int(void)> f(main); return 0; }"
                             US_HAVE_STD_FUNCTION)
 endif()
 if((NOT (US_HAVE_STD_FUNCTION OR US_HAVE_TR1_FUNCTION)) AND US_HAVE_TR1_FUNCTIONAL_H)
   unset(US_HAVE_TR1_FUNCTION CACHE)
   unset(US_HAVE_STD_FUNCTION CACHE)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/functional>\nint main() { std::tr1::function<int(void)> f(main); return 0; }"
                             US_HAVE_TR1_FUNCTION)
   CHECK_CXX_SOURCE_COMPILES("#include <tr1/functional>\nint main() { std::function<int(void)> f(main); return 0; }"
                             US_HAVE_STD_FUNCTION)
 endif()
 
 if(NOT (US_HAVE_STD_FUNCTION OR US_HAVE_TR1_FUNCTION))
   message(SEND_ERROR "The \"function\" type is not available.")
 endif()
 
 #-----------------------------------------------------------------------------
 # Source directory
 #-----------------------------------------------------------------------------
 
 set(US_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/third_party ${PROJECT_BINARY_DIR}/include)
 
 # Configure CppMicroServicesConfig.cmake for the build tree.
 # The file is used in sub-directories.
 
 set(PACKAGE_CONFIG_INCLUDE_DIR ${US_INCLUDE_DIRS})
 set(PACKAGE_CONFIG_RUNTIME_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 set(PACKAGE_CONFIG_CMAKE_DIR ${US_CMAKE_DIR})
 
 set(US_RCC_EXECUTABLE_NAME usResourceCompiler CACHE INTERNAL "The target name of the usResourceCompiler executable.")
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake.in
   ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
   @ONLY
   )
 
 set(us_global_config_h_file "${PROJECT_BINARY_DIR}/include/usGlobalConfig.h")
 configure_file(${US_CMAKE_DIR}/usGlobalConfig.h.in ${us_global_config_h_file})
 
 include_directories(${US_INCLUDE_DIRS})
 
 add_subdirectory(tools)
 
 add_subdirectory(core)
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 add_subdirectory(doc)
 
 #-----------------------------------------------------------------------------
 # Last configuration and install steps
 #-----------------------------------------------------------------------------
 
-
-export(TARGETS ${US_RCC_EXECUTABLE_NAME}
-       FILE ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake)
-install(EXPORT ${PROJECT_NAME}Targets
-        FILE ${PROJECT_NAME}Targets.cmake
-        DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
-
-set(_install_cmake_scripts
-  ${US_MODULE_INIT_TEMPLATE}
-  ${US_CMAKE_RESOURCE_DEPENDENCIES_CPP}
-  ${US_CMAKE_DIR}/CMakeParseArguments.cmake
-  ${US_CMAKE_DIR}/FindPackageHandleStandardArgs.cmake
-  ${US_CMAKE_DIR}/FindPackageMessage.cmake
-  ${US_CMAKE_DIR}/usFunctionGenerateModuleInit.cmake
-  ${US_CMAKE_DIR}/usFunctionAddResources.cmake
-  ${US_CMAKE_DIR}/usFunctionEmbedResources.cmake
-  ${US_CMAKE_DIR}/usFunctionGetResourceSource.cmake
-  ${US_CMAKE_DIR}/usFunctionCheckResourceLinking.cmake
-  ${US_CMAKE_DIR}/usFunctionCheckCompilerFlags.cmake
-  )
-
-install(FILES ${_install_cmake_scripts}
-        DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
-
-install(FILES ${us_global_config_h_file}
-        DESTINATION ${HEADER_INSTALL_DIR})
-
-# Configure CppMicroServicesConfig.cmake for the install tree
-set(CONFIG_INCLUDE_DIR ${HEADER_INSTALL_DIR})
-set(CONFIG_RUNTIME_DIR ${RUNTIME_INSTALL_DIR})
-set(CONFIG_CMAKE_DIR ${AUXILIARY_CMAKE_INSTALL_DIR})
-configure_package_config_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake.in
-  ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${PROJECT_NAME}Config.cmake
-  INSTALL_DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
-  PATH_VARS CONFIG_INCLUDE_DIR CONFIG_RUNTIME_DIR CONFIG_CMAKE_DIR
-  NO_SET_AND_CHECK_MACRO
-  NO_CHECK_REQUIRED_COMPONENTS_MACRO
-  )
-
 # Version information
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}ConfigVersion.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
   @ONLY
   )
 
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${PROJECT_NAME}Config.cmake
-              ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
-        DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
-        ${US_SDK_INSTALL_COMPONENT}
-  )
+export(TARGETS ${US_RCC_EXECUTABLE_NAME}
+       FILE ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake)
+
+if(NOT US_NO_INSTALL)
+
+  install(EXPORT ${PROJECT_NAME}Targets
+          FILE ${PROJECT_NAME}Targets.cmake
+          DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
+
+  set(_install_cmake_scripts
+    ${US_MODULE_INIT_TEMPLATE}
+    ${US_CMAKE_RESOURCE_DEPENDENCIES_CPP}
+    ${US_CMAKE_DIR}/CMakeParseArguments.cmake
+    ${US_CMAKE_DIR}/FindPackageHandleStandardArgs.cmake
+    ${US_CMAKE_DIR}/FindPackageMessage.cmake
+    ${US_CMAKE_DIR}/usFunctionGenerateModuleInit.cmake
+    ${US_CMAKE_DIR}/usFunctionAddResources.cmake
+    ${US_CMAKE_DIR}/usFunctionEmbedResources.cmake
+    ${US_CMAKE_DIR}/usFunctionGetResourceSource.cmake
+    ${US_CMAKE_DIR}/usFunctionCheckResourceLinking.cmake
+    ${US_CMAKE_DIR}/usFunctionCheckCompilerFlags.cmake
+    )
+
+  install(FILES ${_install_cmake_scripts}
+          DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
+
+  install(FILES ${us_global_config_h_file}
+          DESTINATION ${HEADER_INSTALL_DIR})
+
+  # Configure CppMicroServicesConfig.cmake for the install tree
+  set(CONFIG_INCLUDE_DIR ${HEADER_INSTALL_DIR})
+  set(CONFIG_RUNTIME_DIR ${RUNTIME_INSTALL_DIR})
+  set(CONFIG_CMAKE_DIR ${AUXILIARY_CMAKE_INSTALL_DIR})
+  configure_package_config_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake.in
+    ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${PROJECT_NAME}Config.cmake
+    INSTALL_DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
+    PATH_VARS CONFIG_INCLUDE_DIR CONFIG_RUNTIME_DIR CONFIG_CMAKE_DIR
+    NO_SET_AND_CHECK_MACRO
+    NO_CHECK_REQUIRED_COMPONENTS_MACRO
+    )
+
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${PROJECT_NAME}Config.cmake
+                ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+          DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
+          ${US_SDK_INSTALL_COMPONENT}
+    )
+
+endif()
diff --git a/Core/CppMicroServices/cmake/usMacroCreateModule.cmake b/Core/CppMicroServices/cmake/usMacroCreateModule.cmake
index b1cc729b0c..870f1b62fb 100644
--- a/Core/CppMicroServices/cmake/usMacroCreateModule.cmake
+++ b/Core/CppMicroServices/cmake/usMacroCreateModule.cmake
@@ -1,221 +1,227 @@
 # For internal use only
 
 macro(usMacroCreateModule _project_name)
 
 project(${_project_name})
 
 cmake_parse_arguments(${PROJECT_NAME}
   "SKIP_EXAMPLES;SKIP_INIT"
   "VERSION;TARGET"
   "DEPENDS;INTERNAL_INCLUDE_DIRS;LINK_LIBRARIES;SOURCES;PRIVATE_HEADERS;PUBLIC_HEADERS;RESOURCES;BINARY_RESOURCES"
   ${ARGN}
 )
 
 if(NOT ${PROJECT_NAME}_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+$")
   message(SEND_ERROR "VERSION argument invalid: ${${PROJECT_NAME}_VERSION}")
 endif()
 
 string(REPLACE "." ";" _version_numbers ${${PROJECT_NAME}_VERSION})
 list(GET _version_numbers 0 ${PROJECT_NAME}_MAJOR_VERSION)
 list(GET _version_numbers 1 ${PROJECT_NAME}_MINOR_VERSION)
 list(GET _version_numbers 2 ${PROJECT_NAME}_PATCH_VERSION)
 
 if(NOT ${PROJECT_NAME}_TARGET)
   set(${PROJECT_NAME}_TARGET us${PROJECT_NAME})
 endif()
 set(PROJECT_TARGET ${${PROJECT_NAME}_TARGET})
 
 if(${PROJECT_NAME}_DEPENDS)
   find_package(CppMicroServices REQUIRED ${${PROJECT_NAME}_DEPENDS} QUIET
     HINTS ${CppMicroServices_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 endif()
 
 #-----------------------------------------------------------------------------
 # Include dirs and libraries
 #-----------------------------------------------------------------------------
 
 set(${PROJECT_NAME}_INCLUDE_DIRS
   ${CMAKE_CURRENT_SOURCE_DIR}/include
   ${CMAKE_CURRENT_BINARY_DIR}/include
 )
 
 configure_file(${CppMicroServices_SOURCE_DIR}/cmake/usExport.h.in
                ${CMAKE_CURRENT_BINARY_DIR}/include/us${PROJECT_NAME}Export.h)
 list(APPEND ${PROJECT_NAME}_PUBLIC_HEADERS
   ${CMAKE_CURRENT_BINARY_DIR}/include/us${PROJECT_NAME}Export.h)
 
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/include/us${PROJECT_NAME}Config.h.in)
   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/include/us${PROJECT_NAME}Config.h.in
                  ${CMAKE_CURRENT_BINARY_DIR}/include/us${PROJECT_NAME}Config.h)
   list(APPEND ${PROJECT_NAME}_PUBLIC_HEADERS
     ${CMAKE_CURRENT_BINARY_DIR}/include/us${PROJECT_NAME}Config.h)
 endif()
 
 include_directories(
   ${US_INCLUDE_DIRS}
   ${${PROJECT_NAME}_INCLUDE_DIRS}
 )
 
 set(_internal_include_dirs ${${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS})
 set(${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS )
 if(_internal_include_dirs)
   foreach(_internal_include_dir ${_internal_include_dirs})
     if(IS_ABSOLUTE "${_internal_include_dir}")
       list(APPEND ${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS ${_internal_include_dir})
     else()
       list(APPEND ${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/${_internal_include_dir})
     endif()
   endforeach()
   include_directories(${${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS})
 endif()
 
 #-----------------------------------------------------------------------------
 # Create library
 #-----------------------------------------------------------------------------
 
 # Generate the module init file
 if(NOT ${PROJECT_NAME}_SKIP_INIT)
   usFunctionGenerateModuleInit(${PROJECT_NAME}_SOURCES)
 endif()
 
 if(${PROJECT_NAME}_RESOURCES OR ${PROJECT_NAME}_BINARY_RESOURCES)
   usFunctionGetResourceSource(TARGET ${${PROJECT_NAME}_TARGET} OUT ${PROJECT_NAME}_SOURCES)
 endif()
 
 # Create the module library
 add_library(${${PROJECT_NAME}_TARGET} ${${PROJECT_NAME}_SOURCES}
             ${${PROJECT_NAME}_PRIVATE_HEADERS} ${${PROJECT_NAME}_PUBLIC_HEADERS})
 
 # Compile definitions
 set_property(TARGET ${${PROJECT_NAME}_TARGET} APPEND PROPERTY COMPILE_DEFINITIONS US_MODULE_NAME=${${PROJECT_NAME}_TARGET})
 set_property(TARGET ${${PROJECT_NAME}_TARGET} PROPERTY US_MODULE_NAME ${${PROJECT_NAME}_TARGET})
 if(NOT US_BUILD_SHARED_LIBS)
   set_property(TARGET ${${PROJECT_NAME}_TARGET} APPEND PROPERTY COMPILE_DEFINITIONS US_STATIC_MODULE)
 endif()
 
 # Link flags
 if(${PROJECT_NAME}_LINK_FLAGS OR US_LINK_FLAGS)
   set_target_properties(${${PROJECT_NAME}_TARGET} PROPERTIES
     LINK_FLAGS "${US_LINK_FLAGS} ${${PROJECT_NAME}_LINK_FLAGS}"
   )
 endif()
 
 set_target_properties(${${PROJECT_NAME}_TARGET} PROPERTIES
   SOVERSION ${${PROJECT_NAME}_VERSION}
   PUBLIC_HEADER "${${PROJECT_NAME}_PUBLIC_HEADERS}"
   PRIVATE_HEADER "${${PROJECT_NAME}_PRIVATE_HEADERS}"
 )
 
 # Link additional libraries
 if(${PROJECT_NAME}_LINK_LIBRARIES OR US_LIBRARIES)
   target_link_libraries(${${PROJECT_NAME}_TARGET} ${US_LIBRARIES} ${${PROJECT_NAME}_LINK_LIBRARIES})
 endif()
 
 # Embed module resources
 
 if(${PROJECT_NAME}_RESOURCES OR US_LIBRARIES)
   usFunctionAddResources(TARGET ${${PROJECT_NAME}_TARGET}
                          WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/resources
                          FILES ${${PROJECT_NAME}_RESOURCES}
                          ZIP_ARCHIVES ${US_LIBRARIES}
                         )
 endif()
 if(${PROJECT_NAME}_BINARY_RESOURCES)
   usFunctionAddResources(TARGET ${${PROJECT_NAME}_TARGET}
                          WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/resources
                          FILES ${${PROJECT_NAME}_BINARY_RESOURCES}
                         )
 endif()
 usFunctionEmbedResources(TARGET ${${PROJECT_NAME}_TARGET})
 
 #-----------------------------------------------------------------------------
 # Install support
 #-----------------------------------------------------------------------------
 
-install(TARGETS ${${PROJECT_NAME}_TARGET}
-        EXPORT us${PROJECT_NAME}Targets
-        RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
-        LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
-        ARCHIVE DESTINATION ${ARCHIVE_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
-        PUBLIC_HEADER DESTINATION ${HEADER_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
-        PRIVATE_HEADER DESTINATION ${HEADER_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT})
+if(NOT US_NO_INSTALL)
+  install(TARGETS ${${PROJECT_NAME}_TARGET}
+          EXPORT us${PROJECT_NAME}Targets
+          RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
+          LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
+          ARCHIVE DESTINATION ${ARCHIVE_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
+          PUBLIC_HEADER DESTINATION ${HEADER_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
+          PRIVATE_HEADER DESTINATION ${HEADER_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT})
+endif()
 
 #-----------------------------------------------------------------------------
 # US testing
 #-----------------------------------------------------------------------------
 
 if(US_BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
   add_subdirectory(test)
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 if(US_BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/doc/snippets/CMakeLists.txt")
   # Compile source code snippets
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/doc/snippets)
 endif()
 
 #-----------------------------------------------------------------------------
 # Last configuration and install steps
 #-----------------------------------------------------------------------------
 
+# Version information
+configure_file(
+  ${US_CMAKE_DIR}/usModuleConfigVersion.cmake.in
+  ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}ConfigVersion.cmake
+  @ONLY
+  )
+
 export(TARGETS ${${PROJECT_NAME}_TARGET} ${US_LIBRARIES}
        FILE ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}Targets.cmake)
-install(EXPORT us${PROJECT_NAME}Targets
-        FILE us${PROJECT_NAME}Targets.cmake
-        DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
+if(NOT US_NO_INSTALL)
+  install(EXPORT us${PROJECT_NAME}Targets
+          FILE us${PROJECT_NAME}Targets.cmake
+          DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
+endif()
 
 # Configure config file for the build tree
 
 set(PACKAGE_CONFIG_INCLUDE_DIR
   ${${PROJECT_NAME}_INCLUDE_DIRS}
   ${${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS})
 set(PACKAGE_CONFIG_RUNTIME_LIBRARY_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 
 configure_file(
   ${US_CMAKE_DIR}/usModuleConfig.cmake.in
   ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}Config.cmake
   @ONLY
   )
 
 # Configure config file for the install tree
 
-set(CONFIG_INCLUDE_DIR ${HEADER_INSTALL_DIR})
-set(CONFIG_RUNTIME_LIBRARY_DIR ${RUNTIME_INSTALL_DIR})
-
-configure_package_config_file(
-  ${US_CMAKE_DIR}/usModuleConfig.cmake.in
-  ${CppMicroServices_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/us${PROJECT_NAME}Config.cmake
-  INSTALL_DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
-  PATH_VARS CONFIG_INCLUDE_DIR CONFIG_RUNTIME_LIBRARY_DIR
-  NO_SET_AND_CHECK_MACRO
-  NO_CHECK_REQUIRED_COMPONENTS_MACRO
-  )
-
-# Version information
-configure_file(
-  ${US_CMAKE_DIR}/usModuleConfigVersion.cmake.in
-  ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}ConfigVersion.cmake
-  @ONLY
-  )
-
-install(FILES ${CppMicroServices_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/us${PROJECT_NAME}Config.cmake
-              ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}ConfigVersion.cmake
-        DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
-        ${US_SDK_INSTALL_COMPONENT})
+if(NOT US_NO_INSTALL)
+  set(CONFIG_INCLUDE_DIR ${HEADER_INSTALL_DIR})
+  set(CONFIG_RUNTIME_LIBRARY_DIR ${RUNTIME_INSTALL_DIR})
+
+  configure_package_config_file(
+    ${US_CMAKE_DIR}/usModuleConfig.cmake.in
+    ${CppMicroServices_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/us${PROJECT_NAME}Config.cmake
+    INSTALL_DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
+    PATH_VARS CONFIG_INCLUDE_DIR CONFIG_RUNTIME_LIBRARY_DIR
+    NO_SET_AND_CHECK_MACRO
+    NO_CHECK_REQUIRED_COMPONENTS_MACRO
+    )
+
+  install(FILES ${CppMicroServices_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/us${PROJECT_NAME}Config.cmake
+                ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}ConfigVersion.cmake
+          DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
+          ${US_SDK_INSTALL_COMPONENT})
+endif()
 
 #-----------------------------------------------------------------------------
 # Build the examples
 #-----------------------------------------------------------------------------
 
 if(US_BUILD_EXAMPLES AND NOT ${PROJECT_NAME}_SKIP_EXAMPLES AND
    EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/examples/CMakeLists.txt)
   set(CppMicroServices_DIR ${CppMicroServices_BINARY_DIR})
   add_subdirectory(examples)
 endif()
 
 endmacro()
diff --git a/Core/CppMicroServices/tools/CMakeLists.txt b/Core/CppMicroServices/tools/CMakeLists.txt
index 0bbc772e7b..c5d3278eda 100644
--- a/Core/CppMicroServices/tools/CMakeLists.txt
+++ b/Core/CppMicroServices/tools/CMakeLists.txt
@@ -1,23 +1,25 @@
 
 enable_language(C)
 
 include_directories(${US_INCLUDE_DIRS})
 
 add_definitions(-DUS_RCC_EXECUTABLE_NAME=\"${US_RCC_EXECUTABLE_NAME}\")
 
 set(srcs usResourceCompiler.c ../third_party/miniz.c)
 
 add_executable(${US_RCC_EXECUTABLE_NAME} ${srcs})
 if(WIN32)
   target_link_libraries(${US_RCC_EXECUTABLE_NAME} Shlwapi)
 endif()
 
 set_property(
   TARGET ${US_RCC_EXECUTABLE_NAME} APPEND PROPERTY
   COMPILE_DEFINITIONS "MINIZ_NO_ARCHIVE_READING_API;MINIZ_NO_ZLIB_COMPATIBLE_NAMES"
   )
 
-install(TARGETS ${US_RCC_EXECUTABLE_NAME}
-        EXPORT ${PROJECT_NAME}Targets
-        FRAMEWORK DESTINATION . ${US_SDK_INSTALL_COMPONENT}
-        RUNTIME DESTINATION bin ${US_SDK_INSTALL_COMPONENT})
+if(NOT US_NO_INSTALL)
+  install(TARGETS ${US_RCC_EXECUTABLE_NAME}
+          EXPORT ${PROJECT_NAME}Targets
+          FRAMEWORK DESTINATION . ${US_SDK_INSTALL_COMPONENT}
+          RUNTIME DESTINATION bin ${US_SDK_INSTALL_COMPONENT})
+endif()