diff --git a/.gitignore b/.gitignore
index 21fae40622..f3d3258053 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,69 +1,70 @@
 CMakeLists.txt.user*
 .clang_complete
 
 ########## Git related
 
 # Patches and similar
 *.patch
 *.diff
 *.rej
 *.orig
 
 !Utilities/qtsingleapplication/*.patch
+!CMakeExternals/*.patch
 
 ########## IDE specific
 
 ## Office
 ~$*
 
 ## vim
 Session.vim
 *.swp
 *.swo
 
 ## Emacs
 \#*\#
 /.emacs.desktop
 /.emacs.desktop.lock
 .elc
 auto-save-list
 tramp
 .\#*
 
 ## Eclipse
 .cproject
 .project
 .settings/
 
 # Org-mode
 .org-id-locations
 *_archive
 
 ########## OS specific
 
 ## Windows files to ignore
 # Windows image file caches
 Thumbs.db
 ehthumbs.db
 
 # Folder config file
 Desktop.ini
 
 # Recycle Bin used on file shares
 $RECYCLE.BIN/
 
 ## OSX specific
 .DS_Store
 .AppleDouble
 .LSOverride
 Icon
 
 # Thumbnails
 ._*
 
 # Files that might appear on external disk
 .Spotlight-V100
 .Trashes
 
 ## Linux
 *~
diff --git a/CMake/PackageDepends/MITK_Redland_Config.cmake b/CMake/PackageDepends/MITK_Redland_Config.cmake
new file mode 100644
index 0000000000..8269c8f356
--- /dev/null
+++ b/CMake/PackageDepends/MITK_Redland_Config.cmake
@@ -0,0 +1,4 @@
+list(APPEND CMAKE_PREFIX_PATH ${REDLAND_INSTALL_DIR})
+find_package(Redland REQUIRED CONFIG)
+list(APPEND ALL_INCLUDE_DIRECTORIES ${Redland_INCLUDE_DIR})
+list(APPEND ALL_LIBRARIES rdf)
diff --git a/CMake/mitkFunctionGetLibrarySearchPaths.cmake b/CMake/mitkFunctionGetLibrarySearchPaths.cmake
index 8ca66499b5..793166780e 100644
--- a/CMake/mitkFunctionGetLibrarySearchPaths.cmake
+++ b/CMake/mitkFunctionGetLibrarySearchPaths.cmake
@@ -1,174 +1,177 @@
 function(mitkFunctionGetLibrarySearchPaths search_path intermediate_dir)
 
   set(_dir_candidates ${MITK_VTK_LIBRARY_DIRS} ${MITK_ITK_LIBRARY_DIRS}
                       "${MITK_BINARY_DIR}/bin" "${MITK_BINARY_DIR}/bin/plugins")
 
   # Determine the Qt4/5 library installation prefix
   set(_qmake_location )
   if(MITK_USE_Qt4)
     set(_qmake_location ${QT_QMAKE_EXECUTABLE})
   elseif(MITK_USE_Qt5 AND TARGET ${Qt5Core_QMAKE_EXECUTABLE})
     get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE}
                  PROPERTY IMPORT_LOCATION)
   endif()
   if(_qmake_location)
     if(NOT _qt_install_libs)
       if(WIN32)
         execute_process(COMMAND ${_qmake_location} -query QT_INSTALL_BINS
                         OUTPUT_VARIABLE _qt_install_libs
                         OUTPUT_STRIP_TRAILING_WHITESPACE)
       else()
         execute_process(COMMAND ${_qmake_location} -query QT_INSTALL_LIBS
                         OUTPUT_VARIABLE _qt_install_libs
                         OUTPUT_STRIP_TRAILING_WHITESPACE)
       endif()
       file(TO_CMAKE_PATH "${_qt_install_libs}" _qt_install_libs)
       set(_qt_install_libs ${_qt_install_libs} CACHE INTERNAL "Qt library installation prefix" FORCE)
     endif()
     if(_qt_install_libs)
       list(APPEND _dir_candidates ${_qt_install_libs})
     endif()
   elseif(MITK_USE_QT)
     message(WARNING "The qmake executable could not be found.")
   endif()
 
   get_property(_additional_paths GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
   if(_additional_paths)
     list(APPEND _dir_candidates ${_additional_paths})
   endif()
 
   if(VTK_DIR)
     find_package(VTK QUIET)
     if(VTK_RUNTIME_LIBRARY_DIRS)
       list(APPEND _dir_candidates ${VTK_RUNTIME_LIBRARY_DIRS})
     endif()
   endif()
 
 
   # The code below is sub-optimal. It makes assumptions about
   # the structure of the build directories, pointed to by
   # the *_DIR variables. Instead, we should rely on package
   # specific "LIBRARY_DIRS" variables, if they exist.
 
   if(WIN32)
     if(DCMTK_DIR)
       list(APPEND _dir_candidates "${DCMTK_DIR}/bin")
     endif()
     if(OpenCV_DIR)
       list(APPEND _dir_candidates "${OpenCV_DIR}/bin")
     endif()
     if(SOFA_DIR)
       list(APPEND _dir_candidates "${SOFA_DIR}/bin")
     endif()
     if(Python_DIR)
       list(APPEND _dir_candidates "${Python_DIR}/bin")
     endif()
     if(SimpleITK_DIR)
       list(APPEND _dir_candidates "${SimpleITK_DIR}/bin")
     endif()
     list(APPEND _dir_candidates "${ITK_DIR}/bin")
   else()
     if(DCMTK_DIR)
       list(APPEND _dir_candidates "${DCMTK_DIR}/lib")
     endif()
     if(OpenCV_DIR)
       list(APPEND _dir_candidates "${OpenCV_DIR}/lib")
     endif()
     if(SOFA_DIR)
       list(APPEND _dir_candidates "${SOFA_DIR}/lib")
     endif()
     if(Python_DIR)
       list(APPEND _dir_candidates "${Python_DIR}/lib")
     endif()
     if(SimpleITK_DIR)
       list(APPEND _dir_candidates "${SimpleITK_DIR}/lib")
     endif()
+    if(REDLAND_INSTALL_DIR)
+      list(APPEND _dir_candidates "${REDLAND_INSTALL_DIR}/lib")
+    endif()
     list(APPEND _dir_candidates "${ITK_DIR}/lib")
   endif()
 
   if(MITK_USE_Python AND CTK_PYTHONQT_INSTALL_DIR)
     list(APPEND _dir_candidates "${CTK_PYTHONQT_INSTALL_DIR}/bin")
   endif()
   if(MITK_USE_Boost AND MITK_USE_Boost_LIBRARIES AND NOT MITK_USE_SYSTEM_Boost)
     list(APPEND _dir_candidates "${Boost_LIBRARY_DIR}")
   endif()
   if(ACVD_DIR)
     list(APPEND _dir_candidates "${ACVD_DIR}/bin")
   endif()
   if(ANN_DIR)
     list(APPEND _dir_candidates "${ANN_DIR}")
   endif()
   if(CppUnit_DIR)
     list(APPEND _dir_candidates "${CppUnit_DIR}")
   endif()
   if(GLUT_DIR)
     list(APPEND _dir_candidates "${GLUT_DIR}")
   endif()
   if(GDCM_DIR)
     list(APPEND _dir_candidates "${GDCM_DIR}/bin")
   endif()
   if(GLEW_DIR)
     list(APPEND _dir_candidates "${GLEW_DIR}")
   endif()
   if(tinyxml_DIR)
     list(APPEND _dir_candidates "${tinyxml_DIR}")
   endif()
   if(Poco_DIR)
     list(APPEND _dir_candidates "${Poco_DIR}/lib")
   endif()
   if(Qwt_DIR)
     list(APPEND _dir_candidates "${Qwt_DIR}")
   endif()
   if(MITK_USE_TOF_PMDO3 OR MITK_USE_TOF_PMDCAMCUBE OR MITK_USE_TOF_PMDCAMBOARD)
     list(APPEND _dir_candidates "${MITK_PMD_SDK_DIR}/plugins" "${MITK_PMD_SDK_DIR}/bin")
   endif()
 
   if(MITK_USE_CTK)
     list(APPEND _dir_candidates "${CTK_LIBRARY_DIRS}")
     foreach(_ctk_library ${CTK_LIBRARIES})
       if(${_ctk_library}_LIBRARY_DIRS)
         list(APPEND _dir_candidates "${${_ctk_library}_LIBRARY_DIRS}")
       endif()
     endforeach()
   endif()
 
   if(MITK_USE_BLUEBERRY)
     if(DEFINED CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY)
       if(IS_ABSOLUTE "${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
         list(APPEND _dir_candidates "${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
       else()
         list(APPEND _dir_candidates "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
       endif()
     endif()
   endif()
 
   if(MITK_LIBRARY_DIRS)
     list(APPEND _dir_candidates ${MITK_LIBRARY_DIRS})
   endif()
 
   list(REMOVE_DUPLICATES _dir_candidates)
 
   set(_search_dirs )
   foreach(_dir ${_dir_candidates})
     if(EXISTS "${_dir}/${intermediate_dir}")
       list(APPEND _search_dirs "${_dir}/${intermediate_dir}")
     else()
       list(APPEND _search_dirs "${_dir}")
     endif()
   endforeach()
 
   # Special handling for "internal" search dirs. The intermediate directory
   # might not have been created yet, so we can't check for its existence.
   # Hence we just add it for Windows without checking.
   set(_internal_search_dirs "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins")
   if(WIN32)
     foreach(_dir ${_internal_search_dirs})
       set(_search_dirs "${_dir}/${intermediate_dir}" ${_search_dirs})
     endforeach()
   else()
     set(_search_dirs ${_internal_search_dirs} ${_search_dirs})
   endif()
   list(REMOVE_DUPLICATES _search_dirs)
 
   set(${search_path} ${_search_dirs} PARENT_SCOPE)
 endfunction()
diff --git a/CMakeExternals/PCRE.cmake b/CMakeExternals/PCRE.cmake
index 6b2dc67d1d..2cd87712e0 100644
--- a/CMakeExternals/PCRE.cmake
+++ b/CMakeExternals/PCRE.cmake
@@ -1,35 +1,37 @@
 #--------------------------------------------------------------------------
 #  PCRE (Perl Compatible Regular Expressions)
 #--------------------------------------------------------------------------
 if(MITK_USE_PCRE)
   if(DEFINED PCRE_DIR AND NOT EXISTS ${PCRE_DIR})
       message(FATAL_ERROR "PCRE_DIR variable is defined but corresponds to non-existing directory")
    endif()
   if(NOT PCRE_DIR)
 
     set(proj PCRE)
     set(${proj}_DEPENDENCIES "")
-    set(PCRE_TARGET_VERSION 8.35)
+    set(${proj}_DEPENDS ${proj})
 
     ExternalProject_add(${proj}
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/pcre-8.35.tar.gz
       URL_MD5 "ed58bcbe54d3b1d59e9f5415ef45ce1c"
       SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-src
       BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build
       INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install
       PREFIX ${proj}-cmake
-      CONFIGURE_COMMAND <SOURCE_DIR>/./configure
-                        CC=${CMAKE_C_COMPILER}${CMAKE_C_COMPILER_ARG1}
-                        LDFLAGS=${CMAKE_LINKER_FLAGS} ${CMAKE_LINKER_FLAGS_RELEASE}
-                        CXX=${CMAKE_CXX_COMPILER}${CMAKE_CXX_COMPILER_ARG1}
-                        --prefix=<INSTALL_DIR>
-                        --disable-shared
+      CMAKE_ARGS
+       ${ep_common_args}
+       "-DCMAKE_C_FLAGS:STRING=${CMAKE_CXX_FLAGS} -fPIC"
+       -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
+       -DBUILD_SHARED_LIBS:BOOL=OFF
+       -DPCRE_BUILD_PCREGREP:BOOL=OFF
+       -DPCRE_BUILD_TESTS:BOOL=OFF
+       -DPCRE_SUPPORT_JIT:BOOL=ON
       DEPENDS "${${proj}_DEPENDENCIES}"
       )
 
     set(PCRE_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install)
 
   else()
     mitkMacroEmptyExternalProject(${proj} "${${proj}_DEPENDENCIES}")
   endif()
 endif()
diff --git a/CMakeExternals/Swig.cmake b/CMakeExternals/Swig.cmake
index 550680dae7..c165b3652b 100644
--- a/CMakeExternals/Swig.cmake
+++ b/CMakeExternals/Swig.cmake
@@ -1,64 +1,64 @@
 #------------------------------------------------------------
 # SWIG (Simple Wrapper Interface Generator)
 #-----------------------------------------------------------
 if(MITK_USE_SWIG)
   if(DEFINED Swig_DIR AND NOT EXISTS ${Swig_DIR})
     message(FATAL_ERROR "Swig_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   if(NOT SWIG_DIR)
     set(SWIG_TARGET_VERSION 3.0.2)
     set(proj Swig)
-    set(Swig_DEPENDENCIES )
+    set(Swig_DEPENDENCIES PCRE)
     set(Swig_DEPENDS )
 
     # binary SWIG for windows
     if(WIN32)
       set(swig_source_dir ${CMAKE_CURRENT_BINARY_DIR}/swigwin-${SWIG_TARGET_VERSION})
 
       # swig.exe available as pre-built binary on Windows:
       ExternalProject_Add(Swig
         URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/swigwin-${SWIG_TARGET_VERSION}.zip
         URL_MD5 "3f18de4fc09ab9abb0d3be37c11fbc8f"
         SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/swigwin-${SWIG_TARGET_VERSION}
         CONFIGURE_COMMAND ""
         BUILD_COMMAND ""
         INSTALL_COMMAND ""
         )
 
       set(SWIG_DIR ${CMAKE_CURRENT_BINARY_DIR}/swigwin-${SWIG_TARGET_VERSION}) # path specified as source in ep
       set(SWIG_EXECUTABLE ${CMAKE_CURRENT_BINARY_DIR}/swigwin-${SWIG_TARGET_VERSION}/swig.exe)
 
     else()
 
       list(APPEND Swig_DEPENDENCIES PCRE)
 
       # swig uses bison find it by cmake and pass it down
       find_package(BISON)
       set(BISON_FLAGS "" CACHE STRING "Flags used by bison")
       mark_as_advanced( BISON_FLAGS)
 
       ExternalProject_add(${proj}
         URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/swig-${SWIG_TARGET_VERSION}.tar.gz
         URL_MD5 "62f9b0d010cef36a13a010dc530d0d41"
         SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-src
         BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build
         INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install
         PREFIX ${proj}-cmake
         CONFIGURE_COMMAND <SOURCE_DIR>/./configure
                           CC=${CMAKE_C_COMPILER}${CMAKE_C_COMPILER_ARG1}
                           LDFLAGS=${CMAKE_LINKER_FLAGS} ${CMAKE_LINKER_FLAGS_RELEASE}
                           CXX=${CMAKE_CXX_COMPILER}${CMAKE_CXX_COMPILER_ARG1}
                             --prefix=<INSTALL_DIR>
                             --with-pcre-prefix=${PCRE_DIR}
                             --without-octave
                             --with-python=${PYTHON_EXECUTABLE}
         DEPENDS ${Swig_DEPENDENCIES}
         )
 
       set(SWIG_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install/share/swig/${SWIG_TARGET_VERSION})
       set(SWIG_EXECUTABLE ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install/bin/swig)
 
     endif()
   endif(NOT SWIG_DIR)
 endif()
diff --git a/CMakeExternals/raptor2-2.0.15.patch b/CMakeExternals/raptor2-2.0.15.patch
new file mode 100644
index 0000000000..baede38078
--- /dev/null
+++ b/CMakeExternals/raptor2-2.0.15.patch
@@ -0,0 +1,493 @@
+diff -urNb raptor2-2.0.15-orig/CMakeLists.txt raptor2-2.0.15-patched/CMakeLists.txt
+--- raptor2-2.0.15-orig/CMakeLists.txt	2014-11-26 00:11:12.836343793 +0100
++++ raptor2-2.0.15-patched/CMakeLists.txt	2014-11-20 01:16:40.168582633 +0100
+@@ -30,12 +30,24 @@
+ FIND_PACKAGE(LibXslt)
+ #FIND_PACKAGE(YAJL)
+ 
+-INCLUDE_DIRECTORIES(
++IF(CURL_FOUND)
++  INCLUDE_DIRECTORIES(
+ 	${CURL_INCLUDE_DIRS}
++  )
++ENDIF()
++
++IF(LIBXML2_FOUND)
++  INCLUDE_DIRECTORIES(
+ 	${EXPAT_INCLUDE_DIRS}
+ 	${LIBXML2_INCLUDE_DIR}
++  )
++ENDIF()
++
++IF(LIBXSLT_FOUND)
++  INCLUDE_DIRECTORIES(
+ 	${LIBXSLT_INCLUDE_DIR}
+-)
++  )
++ENDIF()
+ 
+ ################################################################
+ 
+@@ -89,6 +101,15 @@
+ CHECK_TYPE_SIZE("unsigned long"		SIZEOF_UNSIGNED_LONG)
+ CHECK_TYPE_SIZE("unsigned long long"	SIZEOF_UNSIGNED_LONG_LONG)
+ 
++CHECK_C_SOURCE_COMPILES("
++int main() {char *function_name = __func__; return 0;}"
++ 	HAVE___FUNC__
++)
++CHECK_C_SOURCE_COMPILES("
++int main() {char *function_name = __FUNCTION__; return 0;}"
++  HAVE___FUNCTION__
++)
++
+ IF(LIBXML2_FOUND)
+ 
+ 	SET(CMAKE_REQUIRED_INCLUDES  ${LIBXML2_INCLUDE_DIR})
+@@ -152,103 +173,142 @@
+ SET(BUILD_SHARED_LIBS OFF CACHE BOOL
+ 	"Build shared libraries instead of static ones.")
+ 
++SET(RAPTOR_ENABLE_TESTING TRUE CACHE BOOL
++  "Enable unit tests")
++
+ IF(BUILD_SHARED_LIBS)
+ 	SET(RAPTOR_STATIC FALSE)
+ ELSE(BUILD_SHARED_LIBS)
+ 	SET(RAPTOR_STATIC TRUE)
+ ENDIF(BUILD_SHARED_LIBS)
+ 
+-SET(RAPTOR_XML_INIT none)
+-IF(LIBXML2_FOUND)
+-	SET(RAPTOR_XML_INIT libxml)
+-ENDIF(LIBXML2_FOUND)
+-
+-SET(RAPTOR_XML ${RAPTOR_XML_INIT} CACHE STRING
+-	"Which XML library to use (any of \"libxml\", \"none\").")
++SET(HAVE_RAPTOR_PARSE_DATE 1)
++SET(RAPTOR_PARSEDATE 1)
+ 
+-SET(RAPTOR_XML_DEFINE RAPTOR_XML_NONE)
+-IF(RAPTOR_XML STREQUAL "libxml")
+-	SET(RAPTOR_XML_DEFINE RAPTOR_XML_LIBXML)
+-ENDIF(RAPTOR_XML STREQUAL "libxml")
++# --------------- XML library ----------------
+ 
+-SET(RAPTOR_WWW_INIT none)
+-IF(LIBXML2_FOUND)
+-	SET(RAPTOR_WWW_INIT xml)
+-ENDIF(LIBXML2_FOUND)
+-IF(CURL_FOUND)
+-	SET(RAPTOR_WWW_INIT curl)
+-ENDIF(CURL_FOUND)
++set(RAPTOR_XML_INIT none)
++if(LIBXML2_FOUND)
++  set(RAPTOR_XML_INIT libxml)
++endif()
+ 
+-SET(RAPTOR_WWW ${RAPTOR_WWW_INIT} CACHE STRING
+-	"Which WWW library to use (any of \"curl\", \"xml\", \"none\").")
++set(RAPTOR_XML ${RAPTOR_XML_INIT} CACHE STRING
++  "Which XML library to use (any of \"libxml\", \"none\").")
+ 
+-SET(RAPTOR_WWW_DEFINE RAPTOR_WWW_NONE)
+-IF(RAPTOR_WWW STREQUAL "curl")
+-	SET(RAPTOR_WWW_DEFINE RAPTOR_WWW_LIBCURL)
+-ELSEIF(RAPTOR_WWW STREQUAL "xml")
+-	SET(RAPTOR_WWW_DEFINE RAPTOR_WWW_LIBXML)
+-ENDIF(RAPTOR_WWW STREQUAL "curl")
++set(RAPTOR_XML_DEFINE RAPTOR_XML_NONE)
++if(RAPTOR_XML STREQUAL "libxml")
++  set(RAPTOR_XML_DEFINE RAPTOR_XML_LIBXML)
++endif()
+ 
+-SET(RAPTOR_XML_1_1 FALSE CACHE BOOL
++set(RAPTOR_XML_1_1 FALSE CACHE BOOL
+ 	"Use XML version 1.1 name checking.")
+ 
+-SET(HAVE_RAPTOR_PARSE_DATE 1)
+-SET(RAPTOR_PARSEDATE 1)
+-
+-SET(RAPTOR_PARSER_RDFXML_INIT FALSE)
+-IF(LIBXML2_FOUND)
+-	SET(RAPTOR_PARSER_RDFXML_INIT TRUE)
+-ENDIF(LIBXML2_FOUND)
++# --------------- WWW library ----------------
+ 
+-SET(RAPTOR_PARSER_GRDDL_INIT FALSE)
+-IF(LIBXML2_FOUND AND LIBXSLT_FOUND)
+-	SET(RAPTOR_PARSER_GRDDL_INIT TRUE)
+-ENDIF(LIBXML2_FOUND AND LIBXSLT_FOUND)
+-
+-SET(RAPTOR_PARSER_RDFXML ${RAPTOR_PARSER_RDFXML_INIT}
+-	CACHE BOOL "Build RDF/XML parser.")
+-SET(RAPTOR_PARSER_NTRIPLES TRUE
+-	CACHE BOOL "Build N-Triples parser.")
+-SET(RAPTOR_PARSER_TURTLE TRUE
+-	CACHE BOOL "Build Turtle parser.")
+-SET(RAPTOR_PARSER_TRIG TRUE
+-	CACHE BOOL "Build TRiG parser.")
+-SET(RAPTOR_PARSER_RSS ${LIBXML2_FOUND}
+-	CACHE BOOL "Build RSS Tag Soup parser.")
+-SET(RAPTOR_PARSER_GRDDL ${RAPTOR_PARSER_GRDDL_INIT}
+-	CACHE BOOL "Build GRDDL parser.")
+-SET(RAPTOR_PARSER_GUESS TRUE
+-	CACHE BOOL "Build guess parser.")
+-SET(RAPTOR_PARSER_RDFA ${LIBXML2_FOUND}
+-	CACHE BOOL "Build RDFA parser.")
+-SET(RAPTOR_PARSER_JSON ${YAJL_FOUND}
+-	CACHE BOOL "Build JSON parser.")
+-SET(RAPTOR_PARSER_NQUADS TRUE
+-	CACHE BOOL "Build N-Quads parser.")
+-
+-SET(RAPTOR_SERIALIZER_RDFXML TRUE
+-	CACHE BOOL "Build RDF/XML serializer.")
+-SET(RAPTOR_SERIALIZER_NTRIPLES TRUE
+-	CACHE BOOL "Build N-Triples serializer.")
+-SET(RAPTOR_SERIALIZER_RDFXML_ABBREV TRUE
+-	CACHE BOOL "Build RDF/XML-abbreviated serializer.")
+-SET(RAPTOR_SERIALIZER_TURTLE TRUE
+-	CACHE BOOL "Build Turtle serializer.")
+-SET(RAPTOR_SERIALIZER_RSS_1_0 TRUE
+-	CACHE BOOL "Build RSS 1.0 serializer.")
+-SET(RAPTOR_SERIALIZER_ATOM TRUE
+-	CACHE BOOL "Build Atom 1.0 serializer.")
+-SET(RAPTOR_SERIALIZER_DOT TRUE
+-	CACHE BOOL "Build GraphViz DOT serializer.")
+-SET(RAPTOR_SERIALIZER_HTML TRUE
+-	CACHE BOOL "Build HTML Table serializer.")
+-SET(RAPTOR_SERIALIZER_JSON TRUE
+-	CACHE BOOL "Build JSON serializer.")
+-SET(RAPTOR_SERIALIZER_NQUADS TRUE
+-	CACHE BOOL "Build N-Quads serializer.")
++set(RAPTOR_WWW_INIT none)
++if(LIBXML2_FOUND)
++  set(RAPTOR_WWW_INIT xml)
++endif()
++if(CURL_FOUND)
++  set(RAPTOR_WWW_INIT curl)
++endif()
++if(FETCH_FOUND)
++  set(RAPTOR_WWW_INIT fetch)
++endif()
++
++set(RAPTOR_WWW ${RAPTOR_WWW_INIT} CACHE STRING
++  "Which WWW library to use (any of \"curl\", \"xml\", \"fetch\", \"none\").")
++
++set(RAPTOR_WWW_DEFINE RAPTOR_WWW_NONE)
++if(RAPTOR_WWW STREQUAL "curl")
++  set(RAPTOR_WWW_DEFINE RAPTOR_WWW_LIBCURL)
++elseif(RAPTOR_WWW STREQUAL "xml")
++  set(RAPTOR_WWW_DEFINE RAPTOR_WWW_LIBXML)
++elseif(RAPTOR_WWW STREQUAL "fetch")
++  set(RAPTOR_WWW_DEFINE RAPTOR_WWW_FETCH)
++endif()
++
++if(RAPTOR_WWW STREQUAL "none")
++  message(WARNING "No WWW library in use - only file: URLs will work")
++  message(WARNING "Install libcurl, libxml2 or BSD libfetch for WWW access")
++endif()
++
++# --------------- RDF parsers ----------------
++
++set(rdf_parsers_available ntriples turtle trig guess nquads)
++set(rdfxml_name "RDF/XML")
++set(ntriples_name "N-Triples")
++set(turtle_name "Turtle")
++set(trig_name "TRiG")
++set(guess_name "guess")
++set(rss_name "RSS Tag Soup")
++set(rdfa_name "RDFA")
++set(nquads_name "N-Quads")
++set(grddl_name "GRDDL")
++set(json_name "JSON")
++
++if(LIBXML2_FOUND)
++  list(APPEND rdf_parsers_available rdfxml rss rdfa grddl)
++endif()
++if(YAJL_FOUND)
++  list(APPEND rdf_parsers_available json)
++endif()
++
++set(RAPTOR_PARSER_RDFXML_INIT ${LIBXML2_FOUND})
++
++set(RAPTOR_PARSER_GRDDL_INIT FALSE)
++if(LIBXML2_FOUND AND LIBXSLT_FOUND)
++  set(RAPTOR_PARSER_GRDDL_INIT TRUE)
++endif()
++
++set(rdf_parsers_enabled )
++foreach(parser ${rdf_parsers_available})
++  string(TOUPPER ${parser} parser_uc)
++  if(DEFINED RAPTOR_PARSER_${parser_uc}_INIT)
++    set(parser_init ${RAPTOR_PARSER_${parser_uc}_INIT})
++  else()
++    set(parser_init TRUE)
++  endif()
++  set(RAPTOR_PARSER_${parser_uc} ${parser_init}
++    CACHE BOOL "Build ${${parser}_name} parser.")
++  if(RAPTOR_PARSER_${parser_uc})
++    list(APPEND rdf_parsers_enabled ${parser})
++  endif()
++endforeach()
++
++# --------------- RDF serializers ----------------
++
++set(rdf_serializers_available rdfxml rdfxml-abbrev turtle ntriples rss-1.0 dot html json atom nquads)
++set(rdfxml-abbrev_name "RDF/XML-abbreviated")
++set(rss-1.0_name "RSS 1.0")
++set(dot_name "GraphViz DOT")
++set(html_name "HTML Table")
++set(atom_name "Atom 1.0")
++
++set(rdf_serializers_enabled )
++foreach(serializer ${rdf_serializers_available})
++  string(TOUPPER ${serializer} serializer_uc)
++  string(REGEX REPLACE "[-\\.]" "_" serializer_uc ${serializer_uc})
++  set(RAPTOR_SERIALIZER_${serializer_uc} TRUE
++    CACHE BOOL "Build ${${serializer}_name} serializer.")
++  if(RAPTOR_SERIALIZER_${serializer_uc})
++    list(APPEND rdf_serializers_enabled ${serializer})
++  endif()
++endforeach()
++
++# --------------- NFC library ----------------
++
++set(use_nfc FALSE)
++if(RAPTOR_PARSER_RDFXML AND LIBXML2_FOUND)
++  set(use_nfc TRUE)
++endif()
++# TODO
++set(nfc_library none)
+ 
+ ################################################################
+ 
++INCLUDE(CMakePackageConfigHelpers)
++
+ CONFIGURE_FILE(
+ 	src/raptor_config_cmake.h.in
+ 	src/raptor_config.h
+@@ -263,6 +323,11 @@
+ 	@ONLY
+ )
+ 
++set(INCLUDE_INSTALL_DIR include/raptor2)
++set(LIB_INSTALL_DIR lib)
++set(BIN_INSTALL_DIR bin)
++set(CMAKE_INSTALL_DIR lib/raptor2/cmake)
++
+ # On Windows, the test/utility programs usually have DLL dependencies that
+ # make them cumbersome to invoke within IDE environments, so we enable the
+ # test suite only when makefiles are being used.
+@@ -273,13 +338,30 @@
+ #
+ # but we don't have a good way of knowing where the third-party DLLs are.
+ #
+-IF(CMAKE_GENERATOR MATCHES "Makefiles")
++IF(RAPTOR_ENABLE_TESTING AND CMAKE_GENERATOR MATCHES "Makefiles")
+ 	ENABLE_TESTING()
+-ENDIF(CMAKE_GENERATOR MATCHES "Makefiles")
++ENDIF(RAPTOR_ENABLE_TESTING AND CMAKE_GENERATOR MATCHES "Makefiles")
+ 
+ SUBDIRS(src)
+ SUBDIRS(utils)
+ 
++configure_package_config_file(Raptor2Config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/Raptor2Config.cmake
++  INSTALL_DESTINATION ${CMAKE_INSTALL_DIR}
++  PATH_VARS INCLUDE_INSTALL_DIR
++  NO_CHECK_REQUIRED_COMPONENTS_MACRO
++)
++
++write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/Raptor2ConfigVersion.cmake
++  VERSION ${VERSION}
++  COMPATIBILITY AnyNewerVersion
++)
++
++install(FILES
++  ${CMAKE_CURRENT_BINARY_DIR}/Raptor2Config.cmake
++  ${CMAKE_CURRENT_BINARY_DIR}/Raptor2ConfigVersion.cmake
++  DESTINATION ${CMAKE_INSTALL_DIR}
++)
++
+ ################################################################
+ 
+ FIND_PROGRAM(JING jing)
+@@ -335,21 +417,33 @@
+ ENDIF(rapper_status EQUAL 0 OR rapper_status EQUAL 2)
+ 
+ IF(NOT rdfdiff_status EQUAL 0)
+-	MESSAGE(FATAL_ERROR "Test failed.")
++	MESSAGE(FATAL_ERROR \"Test failed.\")
+ ENDIF(NOT rdfdiff_status EQUAL 0)
+ ")
+ 
+ 	ADD_TEST(${NAME} ${CMAKE_COMMAND} -P test-${NAME}.cmake)
+ ENDMACRO(RAPPER_RDFDIFF_TEST NAME RAPPER_COMMAND RAPPER_OUTPUT RDFDIFF_COMMAND)
+ 
+-SUBDIRS(tests/feeds)
+-SUBDIRS(tests/grddl)
+-SUBDIRS(tests/json)
+-SUBDIRS(tests/ntriples)
+-SUBDIRS(tests/rdfa)
+-SUBDIRS(tests/rdfa11)
+-SUBDIRS(tests/rdfxml)
+-SUBDIRS(tests/trig)
+-#SUBDIRS(tests/turtle)	# TODO
++IF(RAPTOR_ENABLE_TESTING)
++  SUBDIRS(tests/feeds)
++  SUBDIRS(tests/grddl)
++  SUBDIRS(tests/json)
++  SUBDIRS(tests/ntriples)
++  SUBDIRS(tests/rdfa)
++  SUBDIRS(tests/rdfa11)
++  SUBDIRS(tests/rdfxml)
++  SUBDIRS(tests/trig)
++  #SUBDIRS(tests/turtle)	# TODO
++ENDIF(RAPTOR_ENABLE_TESTING)
++
++message("Raptor build summary:
++  RDF parsers available     : ${rdf_parsers_available}
++  RDF parsers enabled       : ${rdf_parsers_enabled}
++  RDF serializers available : ${rdf_serializers_available}
++  RDF serializers enabled   : ${rdf_serializers_enabled}
++  XML parser                : ${RAPTOR_XML}
++  WWW library               : ${RAPTOR_WWW}
++  NFC check library         : ${nfc_library}"
++)
+ 
+ # end raptor/CMakeLists.txt
+diff -urNb raptor2-2.0.15-orig/Raptor2Config.cmake.in raptor2-2.0.15-patched/Raptor2Config.cmake.in
+--- raptor2-2.0.15-orig/Raptor2Config.cmake.in	1970-01-01 01:00:00.000000000 +0100
++++ raptor2-2.0.15-patched/Raptor2Config.cmake.in	2014-11-17 02:26:45.384582192 +0100
+@@ -0,0 +1,9 @@
++set(Raptor2_VERSION @VERSION@)
++
++@PACKAGE_INIT@
++
++set_and_check(Raptor2_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
++
++if(NOT TARGET raptor2 AND EXISTS ${CMAKE_CURRENT_LIST_DIR}/Raptor2Targets.cmake)
++  include(${CMAKE_CURRENT_LIST_DIR}/Raptor2Targets.cmake)
++endif()
+diff -urNb raptor2-2.0.15-orig/src/CMakeLists.txt raptor2-2.0.15-patched/src/CMakeLists.txt
+--- raptor2-2.0.15-orig/src/CMakeLists.txt	2014-11-26 00:11:12.844343793 +0100
++++ raptor2-2.0.15-patched/src/CMakeLists.txt	2014-11-18 01:23:15.200582940 +0100
+@@ -118,6 +118,7 @@
+ ADD_LIBRARY(raptor2
+ 	raptor_avltree.c
+ 	raptor_concepts.c
++  raptor_escaped.c
+ 	raptor_general.c
+ 	raptor_iostream.c
+ 	raptor_json_writer.c
+@@ -125,6 +126,7 @@
+ 	raptor_log.c
+ 	raptor_memstr.c
+ 	raptor_namespace.c
++  raptor_ntriples.c
+ 	raptor_option.c
+ 	raptor_parse.c
+ 	raptor_qname.c
+@@ -144,6 +146,9 @@
+ 	raptor_xml.c
+ 	raptor_xml_writer.c
+ 	snprintf.c
++	sort_r.c
++	sort_r.h
++	ssort.h
+ 	turtle_common.c
+ 	${raptor_parser_rdfxml_sources}
+ 	${raptor_parser_ntriples_nquads_sources}
+@@ -183,6 +188,8 @@
+ 	COMPILE_DEFINITIONS "LIBRDFA_IN_RAPTOR;RAPTOR_INTERNAL;${LIBXML2_DEFINITIONS};${LIBXSLT_DEFINITIONS}"
+ )
+ 
++IF(RAPTOR_ENABLE_TESTING)
++
+ ADD_EXECUTABLE(turtle_lexer_test turtle_lexer.c)
+ TARGET_LINK_LIBRARIES(turtle_lexer_test raptor2)
+ 
+@@ -291,13 +298,15 @@
+ 	)
+ ENDIF(RAPTOR_PARSER_RDFXML)
+ 
++ENDIF(RAPTOR_ENABLE_TESTING)
++
+ # Generate pkg-config metadata file
+ #
+ FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/raptor2.pc
+ "prefix=${CMAKE_INSTALL_PREFIX}
+ exec_prefix=\${prefix}
+-libdir=\${exec_prefix}/lib
+-includedir=\${prefix}/include/raptor2
++libdir=\${exec_prefix}/${LIB_INSTALL_DIR}
++includedir=\${prefix}/${INCLUDE_INSTALL_DIR}
+ 
+ Name: Raptor RDF Parsing Library
+ Description: RDF Parser Toolkit Library
+@@ -310,22 +319,22 @@
+ INSTALL(FILES
+ 	raptor.h
+ 	${CMAKE_CURRENT_BINARY_DIR}/raptor2.h
+-	DESTINATION include/raptor2
++	DESTINATION ${INCLUDE_INSTALL_DIR}
+ )
+ 
+ INSTALL(FILES
+ 	${CMAKE_CURRENT_BINARY_DIR}/raptor2.pc
+-	DESTINATION lib/pkgconfig
++	DESTINATION ${LIB_INSTALL_DIR}/pkgconfig
+ )
+ 
+ INSTALL(
+ 	TARGETS raptor2
+-	EXPORT  Raptor2Config
+-	ARCHIVE DESTINATION lib
+-	LIBRARY DESTINATION lib
+-	RUNTIME DESTINATION bin
++	EXPORT  Raptor2Targets
++	ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
++	LIBRARY DESTINATION ${LIB_INSTALL_DIR}
++	RUNTIME DESTINATION ${BIN_INSTALL_DIR}
+ )
+ 
+-INSTALL(EXPORT Raptor2Config DESTINATION lib/cmake)
++INSTALL(EXPORT Raptor2Targets DESTINATION ${CMAKE_INSTALL_DIR})
+ 
+ # end raptor/src/CMakeLists.txt
+diff -urNb raptor2-2.0.15-orig/src/raptor_config_cmake.h.in raptor2-2.0.15-patched/src/raptor_config_cmake.h.in
+--- raptor2-2.0.15-orig/src/raptor_config_cmake.h.in	2014-11-26 00:11:12.848343793 +0100
++++ raptor2-2.0.15-patched/src/raptor_config_cmake.h.in	2014-11-16 22:17:24.896583977 +0100
+@@ -44,6 +44,9 @@
+ #define SIZEOF_UNSIGNED_LONG		@SIZEOF_UNSIGNED_LONG@
+ #define SIZEOF_UNSIGNED_LONG_LONG	@SIZEOF_UNSIGNED_LONG_LONG@
+ 
++#cmakedefine HAVE___FUNC__
++#cmakedefine HAVE___FUNCTION__
++
+ #cmakedefine HAVE_XMLCTXTUSEOPTIONS
+ #cmakedefine HAVE_XMLSAX2INTERNALSUBSET
+ #cmakedefine RAPTOR_LIBXML_ENTITY_ETYPE
+@@ -87,8 +90,9 @@
+ #  define _CRT_SECURE_NO_DEPRECATE
+ 
+ #  ifdef _MSC_VER
+-#    if _MSC_VER >= 1300
++#    if (_MSC_VER >= 1300) && !defined(__func__)
+ #      define __func__		__FUNCTION__
++#      define HAVE___FUNC__
+ #    else
+        /* better than nothing */
+ #      define raptor_str(s)	#s
+@@ -126,6 +130,11 @@
+    /* These prevent parsedate.c from declaring malloc() and free() */
+ #  define YYMALLOC malloc
+ #  define YYFREE   free
++
++#  if !defined(YY_NO_UNISTD_H)
++#    define YY_NO_UNISTD_H
++#  endif
++
+ #endif
+ 
+ /* end raptor_config.h */
diff --git a/CMakeExternals/raptor2.cmake b/CMakeExternals/raptor2.cmake
new file mode 100644
index 0000000000..9182e86fcf
--- /dev/null
+++ b/CMakeExternals/raptor2.cmake
@@ -0,0 +1,63 @@
+#-----------------------------------------------------------------------------
+# raptor2
+#-----------------------------------------------------------------------------
+
+if(MITK_USE_raptor2)
+
+# Sanity checks
+if(DEFINED raptor2_DIR AND NOT EXISTS ${raptor2_DIR})
+  message(FATAL_ERROR "raptor2_DIR variable is defined but corresponds to non-existing directory")
+endif()
+
+set(proj raptor2)
+set(proj_DEPENDENCIES )
+set(${proj}_DEPENDS ${proj})
+
+if(NOT DEFINED raptor2_DIR)
+
+  ExternalProject_Add(${proj}
+     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
+     BINARY_DIR ${proj}-build
+     INSTALL_DIR ${REDLAND_INSTALL_DIR}
+     PREFIX ${proj}-cmake
+     URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/raptor2-2.0.15.tar.gz
+     URL_MD5 a39f6c07ddb20d7dd2ff1f95fa21e2cd
+     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_LIST_DIR}/raptor2-2.0.15.patch
+     CMAKE_GENERATOR ${gen}
+     CMAKE_ARGS
+       ${ep_common_args}
+       -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
+       -DBUILD_SHARED_LIBS:BOOL=ON
+       -DRAPTOR_ENABLE_TESTING:BOOL=OFF
+       -DRAPTOR_PARSER_GRDDL:BOOL=OFF
+       -DRAPTOR_PARSER_GUESS:BOOL=OFF
+       -DRAPTOR_PARSER_JSON:BOOL=OFF
+       -DRAPTOR_PARSER_NQUADS:BOOL=ON
+       -DRAPTOR_PARSER_NTRIPLES:BOOL=ON
+       -DRAPTOR_PARSER_RDFA:BOOL=OFF
+       -DRAPTOR_PARSER_RDFXML:BOOL=OFF
+       -DRAPTOR_PARSER_RSS:BOOL=OFF
+       -DRAPTOR_PARSER_TRIG:BOOL=OFF
+       -DRAPTOR_PARSER_TURTLE:BOOL=ON
+       -DRAPTOR_SERIALIZER_ATOM:BOOL=OFF
+       -DRAPTOR_SERIALIZER_DOT:BOOL=OFF
+       -DRAPTOR_SERIALIZER_HTML:BOOL=OFF
+       -DRAPTOR_SERIALIZER_JSON:BOOL=OFF
+       -DRAPTOR_SERIALIZER_NQUADS:BOOL=ON
+       -DRAPTOR_SERIALIZER_NTRIPLES:BOOL=ON
+       -DRAPTOR_SERIALIZER_RDFXML:BOOL=OFF
+       -DRAPTOR_SERIALIZER_RDFXML_ABBREV:BOOL=OFF
+       -DRAPTOR_SERIALIZER_RSS_1_0:BOOL=OFF
+       -DRAPTOR_SERIALIZER_TURTLE:BOOL=ON
+     DEPENDS ${proj_DEPENDENCIES}
+    )
+
+  set(${proj}_DIR ${REDLAND_INSTALL_DIR}/lib/raptor2/cmake/)
+
+else()
+
+  mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+
+endif()
+
+endif()
diff --git a/CMakeExternals/rasqal-0.9.32.patch b/CMakeExternals/rasqal-0.9.32.patch
new file mode 100644
index 0000000000..00be2e45ed
--- /dev/null
+++ b/CMakeExternals/rasqal-0.9.32.patch
@@ -0,0 +1,1014 @@
+diff -urNb rasqal-0.9.32-orig/CMakeLists.txt rasqal-0.9.32-patched/CMakeLists.txt
+--- rasqal-0.9.32-orig/CMakeLists.txt	1970-01-01 01:00:00.000000000 +0100
++++ rasqal-0.9.32-patched/CMakeLists.txt	2014-11-26 03:43:49.708342271 +0100
+@@ -0,0 +1,395 @@
++# rasqal/CMakeLists.txt
++#
++# This file allows building rasqal with the CMake configuration tool.
++# Download CMake in source or binary form from http://www.cmake.org/
++#
++# Based on the CMakeLists.txt file from Raptor.
++# This file is in the public domain.
++#
++
++set(RASQAL_VERSION_MAJOR 0)
++set(RASQAL_VERSION_MINOR 9)
++set(RASQAL_VERSION_RELEASE 32)
++set(RASQAL_MIN_VERSION_DECIMAL 00932)
++
++set(VERSION "${RASQAL_VERSION_MAJOR}.${RASQAL_VERSION_MINOR}.${RASQAL_VERSION_RELEASE}")
++math(EXPR RASQAL_VERSION_DECIMAL "${RASQAL_VERSION_MAJOR} * 10000 + ${RASQAL_VERSION_MINOR} * 100 + ${RASQAL_VERSION_RELEASE}")
++
++project(rasqal C)
++
++cmake_minimum_required(VERSION 2.8.9)
++
++set(CMAKE_include_CURRENT_DIR 1)
++
++set(PROJECT_DESCRIPTION "Rasqal RDF Query Library")
++
++################################################################
++
++# Third-party libraries
++
++set(RAPTOR_MIN_VERSION 2.0.7)
++find_package(Raptor2 ${RAPTOR_MIN_VERSION} REQUIRED)
++include_directories(${Raptor2_INCLUDE_DIR})
++
++find_package(LibXml2)
++
++if(LIBXML2_FOUND)
++  include_directories(
++    ${EXPAT_include_DIRS}
++    ${LIBXML2_include_DIR}
++  )
++endif()
++
++################################################################
++
++# Configuration checks
++
++include(CheckIncludeFile)
++include(CheckIncludeFiles)
++include(CheckFunctionExists)
++include(CheckTypeSize)
++include(CheckStructHasMember)
++include(CheckCSourceCompiles)
++
++check_include_file(dlfcn.h HAVE_DLFCN_H)
++check_include_file(errno.h HAVE_ERRNO_H)
++check_include_file(stddef.h HAVE_STDDEF_H)
++check_include_file(stdlib.h HAVE_STDLIB_H)
++check_include_file(stdint.h HAVE_STDINT_H)
++check_include_file(unistd.h HAVE_UNISTD_H)
++check_include_file(string.h HAVE_STRING_H)
++check_include_file(strings.h HAVE_STRINGS_H)
++check_include_file(getopt.h HAVE_GETOPT_H)
++check_include_file(regex.h HAVE_REGEX_H)
++check_include_file(uuid/uuid.h HAVE_UUID_UUID_H)
++
++check_include_file(sys/time.h HAVE_SYS_TIME_H)
++check_include_file(time.h HAVE_TIME_H)
++CHECK_include_FILES("sys/time.h;time.h" TIME_WITH_SYS_TIME)
++
++# Make sure these variables are set to a specific value
++# because they are substituted in rasqal.h.in
++if(NOT HAVE_SYS_TIME_H)
++  set(HAVE_SYS_TIME_H 0)
++endif()
++if(NOT HAVE_TIME_H)
++  set(HAVE_TIME_H 0)
++endif()
++
++check_include_file(math.h HAVE_MATH_H)
++check_include_file(limits.h HAVE_LIMITS_H)
++check_include_file(float.h HAVE_FLOAT_H)
++check_include_file(memory.h HAVE_MEMORY_H)
++check_include_file(sys/stat.h HAVE_SYS_STAT_H)
++check_include_file(sys/types.h HAVE_SYS_TYPES_H)
++check_include_file(inttypes.h HAVE_INTTYPES_H)
++
++if(LIBXML2_FOUND)
++  check_include_file(libxml/xmlschemas.h HAVE_LIBXML_XMLSCHEMAS_H)
++  check_include_file(libxml/xmlschemastypes.h HAVE_LIBXML_XMLSCHEMASTYPES_H)
++  check_include_file(libxml/schemasInternals.h HAVE_LIBXML_SCHEMASINTERNALS_H)
++endif()
++
++CHECK_FUNCTION_EXISTS(access HAVE_ACCESS)
++CHECK_FUNCTION_EXISTS(_access HAVE__ACCESS)
++CHECK_FUNCTION_EXISTS(getopt HAVE_GETOPT)
++CHECK_FUNCTION_EXISTS(getopt_long HAVE_GETOPT_LONG)
++CHECK_FUNCTION_EXISTS(gettimeofday HAVE_GETTIMEOFDAY)
++CHECK_FUNCTION_EXISTS(getmtime_r HAVE_GETMTIME_R)
++CHECK_FUNCTION_EXISTS(snprintf HAVE_SNPRINTF)
++CHECK_FUNCTION_EXISTS(_snprintf HAVE__SNPRINTF)
++CHECK_FUNCTION_EXISTS(initstate HAVE_INITSTATE)
++CHECK_FUNCTION_EXISTS(initstate_r HAVE_INITSTATE_R)
++CHECK_FUNCTION_EXISTS(rand HAVE_RAND)
++CHECK_FUNCTION_EXISTS(random HAVE_RANDOM)
++CHECK_FUNCTION_EXISTS(random_r HAVE_RANDOM_R)
++CHECK_FUNCTION_EXISTS(rand_r HAVE_RAND_R)
++CHECK_FUNCTION_EXISTS(srand HAVE_SRAND)
++CHECK_FUNCTION_EXISTS(strcasecmp HAVE_STRCASECMP)
++CHECK_FUNCTION_EXISTS(stricmp HAVE_STRICMP)
++CHECK_FUNCTION_EXISTS(_stricmp HAVE__STRICMP)
++CHECK_FUNCTION_EXISTS(strnicmp HAVE_STRNICMP)
++CHECK_FUNCTION_EXISTS(_strnicmp HAVE__STRNICMP)
++CHECK_FUNCTION_EXISTS(timegm HAVE_TIMEGM)
++CHECK_FUNCTION_EXISTS(vasprintf HAVE_VASPRINTF)
++CHECK_FUNCTION_EXISTS(vsnprintf HAVE_VSNPRINTF)
++CHECK_FUNCTION_EXISTS(_vsnprintf HAVE__VSNPRINTF)
++
++CHECK_C_SOURCE_COMPILES("
++\#include <time.h>
++int main() {struct tm x; x.tm_gmtoff = 0; return 0;}"
++   HAVE_TM_GMTOFF
++)
++
++CHECK_C_SOURCE_COMPILES("
++int main() {char *function_name = __func__; return 0;}"
++   HAVE___FUNC__
++)
++CHECK_C_SOURCE_COMPILES("
++int main() {char *function_name = __FUNCTION__; return 0;}"
++  HAVE___FUNCTION__
++)
++
++CHECK_C_SOURCE_COMPILES("
++\#include <sys/types.h>
++\#include <regex.h>
++int main() {regex_t reg; char *pat=\"abc\"; regcomp(&reg, pat, 0); return 0;}"
++  HAVE_REGEX_POSIX
++)
++
++find_library(PCRE_LIBRARY_DEBUG NAMES libpcred libpcre pcred pcre)
++find_library(PCRE_LIBRARY_RELEASE NAMES libpcre pcre)
++find_path(PCRE_INCLUDE_DIR pcre.h)
++if((PCRE_LIBRARY_DEBUG OR PCRE_LIBRARY_RELEASE) AND PCRE_INCLUDE_DIR)
++  set(HAVE_REGEX_PCRE 1)
++  set(PCRE_LIBRARY )
++  if(PCRE_LIBRARY_DEBUG)
++    list(APPEND PCRE_LIBRARY debug ${PCRE_LIBRARY_DEBUG})
++  endif()
++  if(PCRE_LIBRARY_RELEASE)
++    list(APPEND PCRE_LIBRARY optimized ${PCRE_LIBRARY_RELEASE})
++  endif()
++endif()
++
++################################################################
++
++# User-configurable options
++#
++# (Note: The CMake GUI displays these in alphabetical order, regardless of
++# the order we use here)
++
++set(BUILD_SHARED_LIBS OFF CACHE BOOL
++    "Build shared libraries instead of static ones.")
++
++#set(RASQAL_ENABLE_TESTING TRUE CACHE BOOL
++#    "Enable unit tests")
++
++if(BUILD_SHARED_LIBS)
++  set(RASQAL_STATIC FALSE)
++else()
++  set(RASQAL_STATIC TRUE)
++endif()
++
++# ----------------------- REGEX library -----------------------
++
++set(RASQAL_REGEX_INIT none)
++if(HAVE_REGEX_POSIX)
++  set(RASQAL_REGEX_INIT posix)
++elseif(PCRE_LIBRARY)
++  set(RASQAL_REGEX_INIT pcre)
++endif()
++
++set(RASQAL_REGEX ${RASQAL_REGEX_INIT} CACHE STRING
++    "Which regular expression library to use (any of \"posix\", \"pcre\", \"none\").")
++
++set(RASQAL_REGEX_LIBRARY )
++if(RASQAL_REGEX STREQUAL "none")
++  set(RASQAL_REGEX_NONE 1)
++  set(RASQAL_REGEX_POSIX 0)
++  set(RASQAL_REGEX_PCRE 0)
++elseif(RASQAL_REGEX STREQUAL "posix")
++  set(RASQAL_REGEX_NONE 0)
++  set(RASQAL_REGEX_POSIX 1)
++  set(RASQAL_REGEX_PCRE 0)
++elseif(RASQAL_REGEX STREQUAL "pcre")
++  set(RASQAL_REGEX_NONE 0)
++  set(RASQAL_REGEX_POSIX 0)
++  set(RASQAL_REGEX_PCRE 1)
++  set(RASQAL_REGEX_LIBRARY ${PCRE_LIBRARY})
++  include_directories(${PCRE_INCLUDE_DIR})
++else()
++  set(RASQAL_REGEX_NONE 0)
++  set(RASQAL_REGEX_POSIX 0)
++  set(RASQAL_REGEX_PCRE 0)
++endif()
++
++# ----------------------- Decimal number library -----------------------
++
++set(RASQAL_DECIMAL_INIT none)
++
++set(RASQAL_DECIMAL ${RASQAL_DECIMAL_INIT} CACHE STRING
++    "Which decimal number library to use (any of \"gmp\", \"mpfr\", \"none\").")
++
++if(RASQAL_DECIMAL STREQUAL "none")
++  set(RASQAL_DECIMAL_NONE 1)
++  set(RASQAL_DECIMAL_GMP 0)
++  set(RASQAL_DECIMAL_MPFR 0)
++elseif(RASQAL_DECIMAL STREQUAL "gmp")
++  set(RASQAL_DECIMAL_NONE 0)
++  set(RASQAL_DECIMAL_GMP 1)
++  set(RASQAL_DECIMAL_MPFR 0)
++elseif(RASQAL_DECIMAL STREQUAL "mpfr")
++  set(RASQAL_DECIMAL_NONE 0)
++  set(RASQAL_DECIMAL_GMP 0)
++  set(RASQAL_DECIMAL_MPFR 1)
++ELSE()
++  set(RASQAL_DECIMAL_NONE 0)
++  set(RASQAL_DECIMAL_GMP 0)
++  set(RASQAL_DECIMAL_MPFR 0)
++endif()
++
++# ----------------------- Digest library -----------------------
++
++set(RASQAL_DIGEST_INIT internal)
++
++set(RASQAL_DIGEST ${RASQAL_DIGEST_INIT} CACHE STRING
++    "Which message digest library to use (any of \"gcrypt\", \"internal\", \"mhash\", \"none\").")
++
++if(RASQAL_DIGEST STREQUAL "none")
++  set(RASQAL_DIGEST_NONE 1)
++  set(RASQAL_DIGEST_GCRYPT 0)
++  set(RASQAL_DIGEST_INTERNAL 0)
++  set(RASQAL_DIGEST_MHASH 0)
++elseif(RASQAL_DIGEST STREQUAL "gcrypt")
++  set(RASQAL_DIGEST_NONE 0)
++  set(RASQAL_DIGEST_GCRYPT 1)
++  set(RASQAL_DIGEST_INTERNAL 0)
++  set(RASQAL_DIGEST_MHASH 0)
++elseif(RASQAL_DIGEST STREQUAL "internal")
++  set(RASQAL_DIGEST_NONE 0)
++  set(RASQAL_DIGEST_GCRYPT 0)
++  set(RASQAL_DIGEST_INTERNAL 1)
++  set(RASQAL_DIGEST_MHASH 0)
++elseif(RASQAL_DIGEST STREQUAL "mhash")
++  set(RASQAL_DIGEST_NONE 0)
++  set(RASQAL_DIGEST_GCRYPT 0)
++  set(RASQAL_DIGEST_INTERNAL 0)
++  set(RASQAL_DIGEST_MHASH 1)
++else()
++  set(RASQAL_DIGEST_NONE 0)
++  set(RASQAL_DIGEST_GCRYPT 0)
++  set(RASQAL_DIGEST_INTERNAL 0)
++  set(RASQAL_DIGEST_MHASH 0)
++endif()
++
++# ----------------------- uuid library -----------------------
++
++set(RASQAL_UUID_INIT internal)
++
++set(RASQAL_UUID ${RASQAL_UUID_INIT} CACHE STRING
++    "Which uuid library to use (any of \"internal\", \"libc\", \"libuuid\", \"none\").")
++
++if(RASQAL_UUID STREQUAL "none")
++  set(RASQAL_UUID_NONE 1)
++  set(RASQAL_UUID_LIBC 0)
++  set(RASQAL_UUID_INTERNAL 0)
++  set(RASQAL_UUID_LIBUUID 0)
++elseif(RASQAL_UUID STREQUAL "libc")
++  set(RASQAL_UUID_NONE 0)
++  set(RASQAL_UUID_LIBC 1)
++  set(RASQAL_UUID_INTERNAL 0)
++  set(RASQAL_UUID_LIBUUID 0)
++elseif(RASQAL_UUID STREQUAL "internal")
++  set(RASQAL_UUID_NONE 0)
++  set(RASQAL_UUID_LIBC 0)
++  set(RASQAL_UUID_INTERNAL 1)
++  set(RASQAL_UUID_LIBUUID 0)
++elseif(RASQAL_UUID STREQUAL "libuuid")
++  set(RASQAL_UUID_NONE 0)
++  set(RASQAL_UUID_LIBC 0)
++  set(RASQAL_UUID_INTERNAL 0)
++  set(RASQAL_UUID_LIBUUID 1)
++else()
++  set(RASQAL_UUID_NONE 0)
++  set(RASQAL_UUID_LIBC 0)
++  set(RASQAL_UUID_INTERNAL 0)
++  set(RASQAL_UUID_LIBUUID 0)
++endif()
++
++# ----------------------- random number generator -----------------------
++
++set(RASQAL_RANDOM_ALGO_INIT rand)
++
++set(RASQAL_RANDOM_ALGO ${RASQAL_RANDOM_ALGO_INIT} CACHE STRING
++    "Which random number generator to use (any of \"gmp_rand\", \"mtwist\", \"rand\", \"random\", \"random_r\", \"rand_r\").")
++
++set(RANDOM_ALGO_GMP_RAND 0)
++set(RANDOM_ALGO_MTWIST 0)
++set(RANDOM_ALGO_RAND 0)
++set(RANDOM_ALGO_RANDOM 0)
++set(RANDOM_ALGO_RANDOM_R 0)
++set(RANDOM_ALGO_RAND_R 0)
++
++string(TOUPPER ${RASQAL_RANDOM_ALGO} _random_algo_uc)
++set(RANDOM_ALGO_${_random_algo_uc} 1)
++
++# ----------------------- Query language -----------------------
++
++set(RASQAL_QUERY_INIT all)
++
++set(RASQAL_QUERY ${RASQAL_QUERY_INIT} CACHE STRING
++    "Which query languages to enable (semi-colon separated list of \"sparql\", \"laqrs\", or just \"all\").")
++
++set(_query_languages SPARQL LAQRS)
++set(_query_lang_default 0)
++list(FIND RASQAL_QUERY all _result)
++if(NOT _result EQUAL -1)
++  set(_query_lang_default 1)
++endif()
++foreach(_lang ${_query_languages})
++  set(RASQAL_QUERY_${_lang} ${_query_lang_default})
++  string(TOLOWER ${_lang} _lang_lc)
++  list(FIND RASQAL_QUERY ${_lang_lc} _result)
++  if(NOT _result EQUAL -1)
++    set(RASQAL_QUERY_${_lang} 1)
++  endif()
++endforeach()
++
++
++################################################################
++
++include(CMakePackageConfigHelpers)
++
++configure_file(
++  src/rasqal_config_cmake.h.in
++  src/rasqal_config.h
++  @ONLY
++)
++
++add_definitions(-DHAVE_CONFIG_H)
++
++configure_file(
++  src/rasqal.h.in
++  src/rasqal.h
++  @ONLY
++)
++
++set(INCLUDE_INSTALL_DIR include/rasqal)
++set(LIB_INSTALL_DIR lib)
++set(BIN_INSTALL_DIR bin)
++set(CMAKE_INSTALL_DIR lib/rasqal/cmake)
++
++add_subdirectory(libsv)
++add_subdirectory(src)
++#SUBDIRS(utils)
++
++configure_package_config_file(RasqalConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/RasqalConfig.cmake
++  INSTALL_DESTINATION ${CMAKE_INSTALL_DIR}
++  PATH_VARS INCLUDE_INSTALL_DIR
++  NO_CHECK_REQUIRED_COMPONENTS_MACRO
++)
++
++write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/RasqalConfigVersion.cmake
++  VERSION ${VERSION}
++  COMPATIBILITY AnyNewerVersion
++)
++
++install(FILES
++  ${CMAKE_CURRENT_BINARY_DIR}/RasqalConfig.cmake
++  ${CMAKE_CURRENT_BINARY_DIR}/RasqalConfigVersion.cmake
++  DESTINATION ${CMAKE_INSTALL_DIR}
++)
++
++
++message("Rasqal configuration:
++  RDF query languages available : ${_query_languages}
++  RDF query languages enabled   : ${RASQAL_QUERY}
++  Raptor version                : ${Raptor2_VERSION}
++  Decimal library               : ${RASQAL_DECIMAL}
++  Regex library                 : ${RASQAL_REGEX}
++  Message digest library        : ${RASQAL_DIGEST}
++  UUID library                  : ${RASQAL_UUID}
++  Random approach               : ${RASQAL_RANDOM_ALGO}"
++)
++
++# end rasqal/CMakeLists.txt
+diff -urNb rasqal-0.9.32-orig/libsv/CMakeLists.txt rasqal-0.9.32-patched/libsv/CMakeLists.txt
+--- rasqal-0.9.32-orig/libsv/CMakeLists.txt	1970-01-01 01:00:00.000000000 +0100
++++ rasqal-0.9.32-patched/libsv/CMakeLists.txt	2014-11-26 00:50:20.188343513 +0100
+@@ -0,0 +1,12 @@
++include_directories(${CMAKE_CURRENT_SOURCE_DIR})
++include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../src)
++include_directories(${CMAKE_CURRENT_BINARY_DIR}/../src)
++
++add_library(sv STATIC sv.c sv.h)
++
++set_target_properties(
++  sv
++  PROPERTIES
++  COMPILE_DEFINITIONS "SV_CONFIG"
++  POSITION_INDEPENDENT_CODE ON
++)
+diff -urNb rasqal-0.9.32-orig/RasqalConfig.cmake.in rasqal-0.9.32-patched/RasqalConfig.cmake.in
+--- rasqal-0.9.32-orig/RasqalConfig.cmake.in	1970-01-01 01:00:00.000000000 +0100
++++ rasqal-0.9.32-patched/RasqalConfig.cmake.in	2014-11-17 02:35:41.080582128 +0100
+@@ -0,0 +1,9 @@
++set(Rasqal_VERSION @VERSION@)
++
++@PACKAGE_INIT@
++
++set_and_check(Rasqal_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
++
++if(NOT TARGET rasqal AND EXISTS ${CMAKE_CURRENT_LIST_DIR}/RasqalTargets.cmake)
++  include(${CMAKE_CURRENT_LIST_DIR}/RasqalTargets.cmake)
++endif()
+diff -urNb rasqal-0.9.32-orig/src/CMakeLists.txt rasqal-0.9.32-patched/src/CMakeLists.txt
+--- rasqal-0.9.32-orig/src/CMakeLists.txt	1970-01-01 01:00:00.000000000 +0100
++++ rasqal-0.9.32-patched/src/CMakeLists.txt	2014-11-26 01:52:37.032343067 +0100
+@@ -0,0 +1,159 @@
++# rasqal/src/CMakeLists.txt
++#
++# Based on the src/CMakeLists.txt file from Raptor
++# This file is in the public domain.
++#
++
++set(rasqal_srcs
++  rasqal_algebra.c
++  rasqal_bindings.c
++  rasqal_data_graph.c
++  rasqal_dataset.c
++  rasqal_datetime.c
++  rasqal_decimal.c
++  rasqal_digest.c
++  rasqal_double.c
++  rasqal_engine_algebra.c
++  rasqal_engine.c
++  rasqal_engine_sort.c
++  rasqal_expr.c
++  rasqal_expr_datetimes.c
++  rasqal_expr_evaluate.c
++  rasqal_expr_numerics.c
++  rasqal_expr_strings.c
++  rasqal_feature.c
++  rasqal_format_html.c
++  rasqal_format_json.c
++  rasqal_format_rdf.c
++  rasqal_format_sparql_xml.c
++  rasqal_format_sv.c
++  rasqal_format_table.c
++  rasqal_formula.c
++  rasqal_general.c
++  rasqal_graph_pattern.c
++  rasqal_iostream.c
++  rasqal_literal.c
++  rasqal_map.c
++  rasqal_ntriples.c
++  rasqal_prefix.c
++  rasqal_projection.c
++  rasqal_query.c
++  rasqal_query_results.c
++  rasqal_query_transform.c
++  rasqal_query_write.c
++  rasqal_random.c
++  rasqal_raptor.c
++  rasqal_regex.c
++  rasqal_result_formats.c
++  rasqal_row.c
++  rasqal_row_compatible.c
++  rasqal_rowsource_aggregation.c
++  rasqal_rowsource_assignment.c
++  rasqal_rowsource_bindings.c
++  rasqal_rowsource.c
++  rasqal_rowsource_distinct.c
++  rasqal_rowsource_empty.c
++  rasqal_rowsource_filter.c
++  rasqal_rowsource_graph.c
++  rasqal_rowsource_groupby.c
++  rasqal_rowsource_having.c
++  rasqal_rowsource_join.c
++  rasqal_rowsource_project.c
++  rasqal_rowsource_rowsequence.c
++  rasqal_rowsource_service.c
++  rasqal_rowsource_slice.c
++  rasqal_rowsource_sort.c
++  rasqal_rowsource_triples.c
++  rasqal_rowsource_union.c
++  rasqal_service.c
++  rasqal_solution_modifier.c
++  rasqal_triple.c
++  rasqal_triples_source.c
++  rasqal_update.c
++  rasqal_variable.c
++  rasqal_xsd_datatypes.c
++  snprintf.c
++)
++
++if(RASQAL_QUERY_SPARQL)
++  list(APPEND rasqal_srcs
++    sparql_lexer.c
++    sparql_lexer.h
++    sparql_parser.c
++    sparql_parser.h
++    sparql_common.h
++  )
++endif()
++
++if(NOT HAVE_STRCASECMP AND NOT HAVE_STRICMP)
++  list(APPEND rasqal_srcs strcasecmp.c)
++endif()
++
++if(NOT HAVE_TIMEGM)
++  list(APPEND rasqal_srcs timegm.c)
++endif()
++
++if(NOT HAVE_GETTIMEOFDAY)
++  list(APPEND rasqal_srcs gettimeofday.c)
++endif()
++
++if(RASQAL_DIGEST_INTERNAL)
++  list(APPEND rasqal_srcs
++    rasqal_digest_md5.c
++    rasqal_digest_sha1.c
++  )
++endif()
++
++include_directories(${CMAKE_CURRENT_SOURCE_DIR})
++include_directories(${CMAKE_CURRENT_BINARY_DIR})
++include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../libsv)
++add_library(rasqal ${rasqal_srcs})
++
++target_link_libraries(rasqal LINK_PRIVATE sv ${RASQAL_REGEX_LIBRARY})
++target_link_libraries(rasqal LINK_PUBLIC raptor2)
++
++set_target_properties(
++  rasqal
++  PROPERTIES
++  COMPILE_DEFINITIONS "RASQAL_INTERNAL;SV_CONFIG" #;${LIBXML2_DEFINITIONS};${LIBXSLT_DEFINITIONS}"
++)
++
++# Generate pkg-config metadata file
++#
++file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/rasqal.pc
++"prefix=${CMAKE_INSTALL_PREFIX}
++exec_prefix=\${prefix}
++libdir=\${exec_prefix}/${LIB_INSTALL_DIR}
++includedir=\${prefix}/${INCLUDE_INSTALL_DIR}
++
++have_raptor2_api=1
++
++Name: ${PROJECT_DESCRIPTION}
++Description: Rasqal RDF Query parsing and execution library
++Requires: raptor2 >= ${RAPTOR_MIN_VERSION}
++Version: ${VERSION}
++Libs: -L\${libdir} -lrasqal
++Cflags: -I\${includedir}
++")
++
++install(FILES
++  ${CMAKE_CURRENT_BINARY_DIR}/rasqal.h
++  DESTINATION ${INCLUDE_INSTALL_DIR}
++)
++
++install(FILES
++  ${CMAKE_CURRENT_BINARY_DIR}/rasqal.pc
++  DESTINATION ${LIB_INSTALL_DIR}/pkgconfig
++)
++
++install(
++  TARGETS rasqal
++  EXPORT  RasqalTargets
++  ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
++  LIBRARY DESTINATION ${LIB_INSTALL_DIR}
++  RUNTIME DESTINATION ${BIN_INSTALL_DIR}
++)
++
++install(EXPORT RasqalTargets DESTINATION ${CMAKE_INSTALL_DIR})
++
++# end rasqal/src/CMakeLists.txt
+diff -urNb rasqal-0.9.32-orig/src/gettimeofday.c rasqal-0.9.32-patched/src/gettimeofday.c
+--- rasqal-0.9.32-orig/src/gettimeofday.c	2011-08-22 23:20:56.000000000 +0200
++++ rasqal-0.9.32-patched/src/gettimeofday.c	2014-11-19 03:53:51.512582102 +0100
+@@ -7,7 +7,7 @@
+  */
+ 
+ #ifdef WIN32
+-#include <win32_rasqal_config.h>
++#include <rasqal_config.h>
+ 
+ #include <time.h>
+ #include <windows.h>
+diff -urNb rasqal-0.9.32-orig/src/rasqal_config_cmake.h.in rasqal-0.9.32-patched/src/rasqal_config_cmake.h.in
+--- rasqal-0.9.32-orig/src/rasqal_config_cmake.h.in	1970-01-01 01:00:00.000000000 +0100
++++ rasqal-0.9.32-patched/src/rasqal_config_cmake.h.in	2014-11-19 04:56:07.408581656 +0100
+@@ -0,0 +1,337 @@
++/* rasqal_config.h */
++
++#ifndef RASQAL_CONFIG_H
++
++/* Release version as a decimal */
++#define RASQAL_VERSION_DECIMAL @RASQAL_VERSION_DECIMAL@
++
++/* Major version number */
++#define RASQAL_VERSION_MAJOR @RASQAL_VERSION_MAJOR@
++
++/* Minor version number */
++#define RASQAL_VERSION_MINOR @RASQAL_VERSION_MINOR@
++
++/* Release version number */
++#define RASQAL_VERSION_RELEASE @RASQAL_VERSION_RELEASE@
++
++/* ---------- package information ------------ */
++
++/* Name of package */
++#define PACKAGE "@PROJECT_NAME@"
++
++/* Define to the address where bug reports for this package should be sent. */
++#define PACKAGE_BUGREPORT "http://bugs.librdf.org/"
++
++/* Define to the full name of this package. */
++#define PACKAGE_NAME "@PROJECT_DESCRIPTION@"
++
++/* Define to the full name and version of this package. */
++#define PACKAGE_STRING "@PROJECT_DESCRIPTION@ @VERSION@"
++
++/* Define to the one symbol short name of this package. */
++#define PACKAGE_TARNAME "@PROJECT_NAME@"
++
++/* Define to the home page for this package. */
++#define PACKAGE_URL ""
++
++/* Define to the version of this package. */
++#define PACKAGE_VERSION "@VERSION@"
++
++/* Version number of package */
++#define VERSION "@VERSION@"
++
++/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
++   significant byte first (like Motorola and SPARC, unlike Intel). */
++#if defined AC_APPLE_UNIVERSAL_BUILD
++# if defined __BIG_ENDIAN__
++#  define WORDS_BIGENDIAN 1
++# endif
++#else
++# ifndef WORDS_BIGENDIAN
++#  undef WORDS_BIGENDIAN
++# endif
++#endif
++
++/* Define to the sub-directory in which libtool stores uninstalled libraries. */
++#cmakedefine LT_OBJDIR
++
++/* ------------ header availability --------------- */
++
++#cmakedefine HAVE_DLFCN_H
++#cmakedefine HAVE_ERRNO_H
++#cmakedefine HAVE_STDDEF_H
++#cmakedefine HAVE_STDLIB_H
++#cmakedefine HAVE_STDINT_H
++#cmakedefine HAVE_UNISTD_H
++#cmakedefine HAVE_STRING_H
++#cmakedefine HAVE_STRINGS_H
++#cmakedefine HAVE_GETOPT_H
++#cmakedefine HAVE_REGEX_H
++#cmakedefine HAVE_UUID_UUID_H
++
++#cmakedefine HAVE_SYS_TIME_H
++#cmakedefine HAVE_TIME_H
++
++#cmakedefine HAVE_MATH_H
++#cmakedefine HAVE_LIMITS_H
++#cmakedefine HAVE_FLOAT_H
++#cmakedefine HAVE_MEMORY_H
++#cmakedefine HAVE_SYS_STAT_H
++#cmakedefine HAVE_SYS_TYPES_H
++#cmakedefine HAVE_INTTYPES_H
++
++#cmakedefine HAVE_MHASH_H
++#cmakedefine HAVE_MPFR_H
++#cmakedefine HAVE_GCRYPT_H
++#cmakedefine HAVE_GMP_H
++
++#cmakedefine HAVE_LIBXML_SCHEMASINTERNALS_H
++#cmakedefine HAVE_LIBXML_XMLSCHEMASTYPES_H
++#cmakedefine HAVE_LIBXML_XMLSCHEMAS_H
++
++
++/* --------- feature availability ------------ */
++
++#cmakedefine HAVE_GMP_VERSION
++
++#cmakedefine HAVE_REGEX_PCRE
++#cmakedefine HAVE_REGEX_POSIX
++
++/* need 'extern int optind' declaration? */
++#cmakedefine NEED_OPTIND_DECLARATION
++
++/* Define to 1 if your C compiler doesn't accept -c and -o together. */
++#cmakedefine NO_MINUS_C_MINUS_O
++
++/* Use GMP gmp_randseed_ui() and mpz_urandomm() */
++#cmakedefine RANDOM_ALGO_GMP_RAND
++
++/* Use internal Mersenne Twister */
++#cmakedefine RANDOM_ALGO_MTWIST
++
++/* Use POSIX srand() and rand() */
++#cmakedefine RANDOM_ALGO_RAND
++
++/* Use BSD initstate() and random() */
++#cmakedefine RANDOM_ALGO_RANDOM
++
++/* Use glibc initstate_r() and random_r() */
++#cmakedefine RANDOM_ALGO_RANDOM_R
++
++/* Use POSIX rand_r() */
++#cmakedefine RANDOM_ALGO_RAND_R
++
++/* Decimal from GNU MP library */
++#cmakedefine RASQAL_DECIMAL_GMP
++
++/* Decimal from MPFR library */
++#cmakedefine RASQAL_DECIMAL_MPFR
++
++/* Decimal without a library */
++#cmakedefine RASQAL_DECIMAL_NONE
++
++/* Use gcrypt library for message digests */
++#cmakedefine RASQAL_DIGEST_GCRYPT
++
++/* Use internal routines for message digests */
++#cmakedefine RASQAL_DIGEST_INTERNAL
++
++/* Use mhash library for message digests */
++#cmakedefine RASQAL_DIGEST_MHASH
++
++/* Use no message digest library */
++#cmakedefine RASQAL_DIGEST_NONE
++
++/* Building LAQRS query */
++#cmakedefine RASQAL_QUERY_LAQRS
++
++/* Building SPARQL query */
++#cmakedefine RASQAL_QUERY_SPARQL
++
++/* Use no regex library */
++#cmakedefine RASQAL_REGEX_NONE
++
++/* Use PCRE regex library */
++#cmakedefine RASQAL_REGEX_PCRE
++
++/* Use POSIX regex library */
++#cmakedefine RASQAL_REGEX_POSIX
++
++/* Use internal routines for UUID */
++#cmakedefine RASQAL_UUID_INTERNAL
++
++/* Use UUID in libc library for UUID */
++#cmakedefine RASQAL_UUID_LIBC
++
++/* Use libuuid library for UUID */
++#cmakedefine RASQAL_UUID_LIBUUID
++
++/* Use no UUID library */
++#cmakedefine RASQAL_UUID_NONE
++
++/* Use OSSP library for UUID */
++#cmakedefine RASQAL_UUID_OSSP
++
++/* Define to 1 if you have the ANSI C header files. */
++#cmakedefine STDC_HEADERS
++
++/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
++#cmakedefine TIME_WITH_SYS_TIME
++
++/* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a
++   `char[]'. */
++#cmakedefine YYTEXT_POINTER
++
++/* Define to empty if `const' does not conform to ANSI C. */
++// #cmakedefine const
++
++/* --------- function availability ----------- */
++
++#cmakedefine HAVE_ACCESS
++#cmakedefine HAVE__ACCESS
++#cmakedefine HAVE_GETOPT
++#cmakedefine HAVE_GETOPT_LONG
++#cmakedefine HAVE_GETTIMEOFDAY
++#cmakedefine HAVE_GMTIME_R
++#cmakedefine HAVE_SNPRINTF
++#cmakedefine HAVE__SNPRINTF
++#cmakedefine HAVE_INITSTATE
++#cmakedefine HAVE_INITSTATE_R
++#cmakedefine HAVE_RAND
++#cmakedefine HAVE_RANDOM
++#cmakedefine HAVE_RANDOM_R
++#cmakedefine HAVE_RAND_R
++#cmakedefine HAVE_SRAND
++#cmakedefine HAVE_STRCASECMP
++#cmakedefine HAVE_STRICMP
++#cmakedefine HAVE__STRICMP
++#cmakedefine HAVE_STRNICMP
++#cmakedefine HAVE__STRNICMP
++#cmakedefine HAVE_TIMEGM
++#cmakedefine HAVE_VASPRINTF
++#cmakedefine HAVE_VSNPRINTF
++#cmakedefine HAVE__VSNPRINTF
++
++/* struct tm has tm_gmtoff field */
++#cmakedefine HAVE_TM_GMTOFF
++#cmakedefine HAVE___FUNC__
++
++
++/* --------- WIN32 config ----------- */
++
++#ifdef WIN32
++
++# ifdef __cplusplus
++  extern "C" {
++# endif
++
++# define WIN32_LEAN_AND_MEAN 1
++# define _CRT_NONSTDC_NO_DEPRECATE
++# define _CRT_SECURE_NO_DEPRECATE
++# include <windows.h>
++
++  /* MS names for these functions */
++  // next line breaks build on wntmsci12
++  //#define vsnprintf _vsnprintf
++# if !defined(HAVE_SNPRINTF) && defined(HAVE__SNPRINTF)
++#   define snprintf _snprintf
++# endif
++# if !defined(HAVE_STRICMP) && defined(HAVE__STRICMP)
++#   define stricmp _stricmp
++# endif
++# if !defined(HAVE_STRNICMP) && defined(HAVE__STRNICMP)
++#   define strnicmp _strnicmp
++# endif
++
++  /* definition from winsock2.h */
++# ifndef _TIMEVAL_DEFINED
++# define _TIMEVAL_DEFINED
++  typedef struct timeval {
++    long tv_sec;
++    long tv_usec;
++  } timeval;
++# endif
++
++# ifndef _TIMEZONE_DEFINED
++# define _TIMEZONE_DEFINED
++  struct timezone
++  {
++    int tz_minuteswest; /* minutes West of Greenwich */
++    int tz_dsttime;     /* type of dst correction */
++  };
++# endif
++
++# ifndef HAVE_GETTIMEOFDAY
++  int rasqal_gettimeofday(struct timeval *tv, struct timezone *tz);
++# endif
++
++# include <float.h>
++# define isnan(n) _isnan(n)
++  /* no round function available */
++# define round(x) floor(x+0.5)
++
++  /* These are SPARQL token definitions */
++# ifdef OPTIONAL
++# undef OPTIONAL
++# endif
++
++# ifdef DELETE
++# undef DELETE
++# endif
++
++# ifdef IN
++# undef IN
++# endif
++
++# ifdef GROUP
++# undef GROUP
++# endif
++
++  /* for access() which is POSIX but doesn't seem to have the defines in VC */
++# ifndef R_OK
++# define R_OK 4
++# endif
++
++# ifndef W_OK
++# define W_OK 2
++# endif
++
++  /* bison: output uses ERROR in an enum which breaks if this is defined */
++# ifdef ERROR
++# undef ERROR
++# endif
++
++# ifdef _MSC_VER
++#   if (_MSC_VER >= 1300) && !defined(__func__)
++#     define __func__ __FUNCTION__
++#     define HAVE___FUNC__
++#   elif !defined(__func__)
++      /* better than nothing */
++#     define rasqal_str(s) #s
++#     define __func__ "func@" __FILE__ ":" rasqal_str(__LINE__)
++#   endif
++# endif
++
++# if !defined(HAVE_ACCESS) && defined(HAVE__ACCESS)
++#   define access(p,m) _access(p,m)
++# endif
++
++  /* flex: const is available */
++# define YY_USE_CONST
++  /* looks like the .c files define this anyway */
++  /* #define YY_NO_UNISTD_H */
++
++# undef RASQAL_INLINE
++# define RASQAL_INLINE __inline
++
++# ifdef _DEBUG
++# define RASQAL_DEBUG 1
++# endif
++
++# ifdef __cplusplus
++  }
++# endif
++
++#endif
++
++#endif
+diff -urNb rasqal-0.9.32-orig/src/rasqal_config.h.in rasqal-0.9.32-patched/src/rasqal_config.h.in
+--- rasqal-0.9.32-orig/src/rasqal_config.h.in	2014-02-23 16:22:21.000000000 +0100
++++ rasqal-0.9.32-patched/src/rasqal_config.h.in	2014-11-18 02:32:39.740582443 +0100
+@@ -245,16 +245,16 @@
+ #undef RASQAL_UUID_OSSP
+ 
+ /* Release version as a decimal */
+-#undef RASQAL_VERSION_DECIMAL
++#define RASQAL_VERSION_DECIMAL @RASQAL_VERSION_DECIMAL@
+ 
+ /* Major version number */
+-#undef RASQAL_VERSION_MAJOR
++#define RASQAL_VERSION_MAJOR @RASQAL_VERSION_MAJOR@
+ 
+ /* Minor version number */
+-#undef RASQAL_VERSION_MINOR
++#define RASQAL_VERSION_MINOR @RASQAL_VERSION_MINOR@
+ 
+ /* Release version number */
+-#undef RASQAL_VERSION_RELEASE
++#define RASQAL_VERSION_RELEASE @RASQAL_VERSION_RELEASE@
+ 
+ /* Define to 1 if you have the ANSI C header files. */
+ #undef STDC_HEADERS
+diff -urNb rasqal-0.9.32-orig/src/rasqal_regex.c rasqal-0.9.32-patched/src/rasqal_regex.c
+--- rasqal-0.9.32-orig/src/rasqal_regex.c	2014-02-20 06:00:40.000000000 +0100
++++ rasqal-0.9.32-patched/src/rasqal_regex.c	2014-11-19 02:55:04.604582523 +0100
+@@ -161,7 +161,7 @@
+ #ifdef RASQAL_REGEX_NONE
+   rasqal_log_warning_simple(world, RASQAL_WARNING_LEVEL_MISSING_SUPPORT, locator,
+                             "Regex support missing, cannot compare '%s' to '%s'",
+-                            match_string, pattern);
++                            subject, pattern);
+   rc = -1;
+ #endif
+ 
+diff -urNb rasqal-0.9.32-orig/src/win32_rasqal_config.h rasqal-0.9.32-patched/src/win32_rasqal_config.h
+--- rasqal-0.9.32-orig/src/win32_rasqal_config.h	2014-02-23 17:39:47.000000000 +0100
++++ rasqal-0.9.32-patched/src/win32_rasqal_config.h	2014-11-19 02:34:19.852582671 +0100
+@@ -21,7 +21,7 @@
+  * 
+  */
+ 
+-
++#if 0
+ #ifndef WIN32_CONFIG_H
+ #define WIN32_CONFIG_H
+ 
+@@ -171,3 +171,4 @@
+ #endif
+ 
+ #endif
++#endif
+diff -urNb rasqal-0.9.32-orig/src/win32_rasqal_config.h.in rasqal-0.9.32-patched/src/win32_rasqal_config.h.in
+--- rasqal-0.9.32-orig/src/win32_rasqal_config.h.in	2013-04-05 19:17:36.000000000 +0200
++++ rasqal-0.9.32-patched/src/win32_rasqal_config.h.in	2014-11-19 02:34:14.668582672 +0100
+@@ -21,7 +21,7 @@
+  * 
+  */
+ 
+-
++#if 0
+ #ifndef WIN32_CONFIG_H
+ #define WIN32_CONFIG_H
+ 
+@@ -171,3 +171,4 @@
+ #endif
+ 
+ #endif
++#endif
diff --git a/CMakeExternals/rasqal.cmake b/CMakeExternals/rasqal.cmake
new file mode 100644
index 0000000000..055d18877c
--- /dev/null
+++ b/CMakeExternals/rasqal.cmake
@@ -0,0 +1,47 @@
+#-----------------------------------------------------------------------------
+# rasqal
+#-----------------------------------------------------------------------------
+
+if(MITK_USE_rasqal)
+
+# Sanity checks
+if(DEFINED rasqal_DIR AND NOT EXISTS ${rasqal_DIR})
+  message(FATAL_ERROR "rasqal_DIR variable is defined but corresponds to non-existing directory")
+endif()
+
+set(proj rasqal)
+set(proj_DEPENDENCIES ${raptor2_DEPENDS} ${PCRE_DEPENDS})
+set(${proj}_DEPENDS ${proj})
+
+if(NOT DEFINED rasqal_DIR)
+
+  ExternalProject_Add(${proj}
+     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
+     BINARY_DIR ${proj}-build
+     INSTALL_DIR ${REDLAND_INSTALL_DIR}
+     PREFIX ${proj}-cmake
+     URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/rasqal-0.9.32.tar.gz
+     URL_MD5 dc7c6107de00c47f85f6ab7db164a136
+     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_LIST_DIR}/rasqal-0.9.32.patch
+     LIST_SEPARATOR ^^
+     CMAKE_GENERATOR ${gen}
+     CMAKE_ARGS
+       ${ep_common_args}
+       -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
+       -DBUILD_SHARED_LIBS:BOOL=ON
+       "-DCMAKE_C_FLAGS:STRING=-DPCRE_STATIC ${CMAKE_C_FLAGS}"
+       -DRASQAL_REGEX:STRING=pcre
+       -DCMAKE_PREFIX_PATH:STRING=${PCRE_DIR}^^${REDLAND_INSTALL_DIR}
+       -DPCRE_INCLUDE_DIR:PATH=${PCRE_DIR}/include
+     DEPENDS ${proj_DEPENDENCIES}
+    )
+
+  set(${proj}_DIR ${REDLAND_INSTALL_DIR}/lib/rasqal/cmake/)
+
+else()
+
+  mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+
+endif()
+
+endif()
diff --git a/CMakeExternals/redland-1.0.17.patch b/CMakeExternals/redland-1.0.17.patch
new file mode 100644
index 0000000000..fc7d457c18
--- /dev/null
+++ b/CMakeExternals/redland-1.0.17.patch
@@ -0,0 +1,1051 @@
+diff -burN redland-1.0.17-orig/CMakeLists.txt redland-1.0.17-patched/CMakeLists.txt
+--- redland-1.0.17-orig/CMakeLists.txt	1970-01-01 01:00:00.000000000 +0100
++++ redland-1.0.17-patched/CMakeLists.txt	2014-11-26 14:03:18.518283855 +0100
+@@ -0,0 +1,298 @@
++# redland/CMakeLists.txt
++#
++# This file allows building Redland with the CMake configuration tool.
++# Download CMake in source or binary form from http://www.cmake.org/
++#
++# Based on the CMakeLists.txt file from Raptor.
++# This file is in the public domain.
++#
++
++SET(REDLAND_VERSION_MAJOR 1)
++SET(REDLAND_VERSION_MINOR 0)
++SET(REDLAND_VERSION_RELEASE 17)
++SET(REDLAND_MIN_VERSION_DECIMAL 10017)
++
++SET(VERSION "${REDLAND_VERSION_MAJOR}.${REDLAND_VERSION_MINOR}.${REDLAND_VERSION_RELEASE}")
++MATH(EXPR REDLAND_VERSION_DECIMAL "${REDLAND_VERSION_MAJOR} * 10000 + ${REDLAND_VERSION_MINOR} * 100 + ${REDLAND_VERSION_RELEASE}")
++
++PROJECT(redland C)
++
++CMAKE_MINIMUM_REQUIRED(VERSION 2.8.9)
++
++SET(CMAKE_INCLUDE_CURRENT_DIR 1)
++
++SET(PROJECT_DESCRIPTION "Redland RDF API Library")
++
++################################################################
++
++# Third-party libraries
++
++SET(RAPTOR_MIN_VERSION 2.0.7)
++FIND_PACKAGE(Raptor2 ${RAPTOR_MIN_VERSION} REQUIRED)
++include_directories(${Raptor2_INCLUDE_DIR})
++
++set(rdf_parsers_available "raptor(${Raptor2_VERSION})")
++
++find_package(Rasqal REQUIRED)
++include_directories(${Rasqal_INCLUDE_DIR})
++
++set(rdf_query "rasqal(${Rasqal_VERSION})")
++
++################################################################
++
++# Configuration checks
++
++INCLUDE(CheckIncludeFile)
++INCLUDE(CheckIncludeFiles)
++INCLUDE(CheckFunctionExists)
++INCLUDE(CheckTypeSize)
++INCLUDE(CheckStructHasMember)
++INCLUDE(CheckCSourceCompiles)
++
++CHECK_INCLUDE_FILE(errno.h HAVE_ERRNO_H)
++CHECK_INCLUDE_FILE(stdlib.h HAVE_STDLIB_H)
++CHECK_INCLUDE_FILE(unistd.h HAVE_UNISTD_H)
++CHECK_INCLUDE_FILE(string.h HAVE_STRING_H)
++CHECK_INCLUDE_FILE(fcntl.h HAVE_FCNTL_H)
++CHECK_INCLUDE_FILE(getopt.h HAVE_GETOPT_H)
++CHECK_INCLUDE_FILE(stddef.h HAVE_STDDEF_H)
++CHECK_INCLUDE_FILE(memory.h HAVE_MEMORY_H)
++CHECK_INCLUDE_FILE(pthread.h HAVE_PTHREAD_H)
++
++CHECK_INCLUDE_FILE(sys/time.h HAVE_SYS_TIME_H)
++CHECK_INCLUDE_FILE(time.h HAVE_TIME_H)
++CHECK_INCLUDE_FILES("sys/time.h;time.h" TIME_WITH_SYS_TIME)
++
++CHECK_INCLUDE_FILE(sys/stat.h HAVE_SYS_STAT_H)
++
++CHECK_FUNCTION_EXISTS(access HAVE_ACCESS)
++CHECK_FUNCTION_EXISTS(_access HAVE__ACCESS)
++CHECK_FUNCTION_EXISTS(getopt HAVE_GETOPT)
++CHECK_FUNCTION_EXISTS(getopt_long HAVE_GETOPT_LONG)
++CHECK_FUNCTION_EXISTS(gettimeofday HAVE_GETTIMEOFDAY)
++CHECK_FUNCTION_EXISTS(snprintf HAVE_SNPRINTF)
++CHECK_FUNCTION_EXISTS(_snprintf HAVE__SNPRINTF)
++CHECK_FUNCTION_EXISTS(strcasecmp HAVE_STRCASECMP)
++CHECK_FUNCTION_EXISTS(stricmp HAVE_STRICMP)
++CHECK_FUNCTION_EXISTS(_stricmp HAVE__STRICMP)
++CHECK_FUNCTION_EXISTS(strnicmp HAVE_STRNICMP)
++CHECK_FUNCTION_EXISTS(_strnicmp HAVE__STRNICMP)
++CHECK_FUNCTION_EXISTS(vasprintf HAVE_VASPRINTF)
++CHECK_FUNCTION_EXISTS(vsnprintf HAVE_VSNPRINTF)
++CHECK_FUNCTION_EXISTS(_vsnprintf HAVE__VSNPRINTF)
++CHECK_FUNCTION_EXISTS(opendir HAVE_OPENDIR)
++CHECK_FUNCTION_EXISTS(readdir HAVE_READDIR)
++CHECK_FUNCTION_EXISTS(shl_load HAVE_SHL_LOAD)
++CHECK_FUNCTION_EXISTS(strlcat HAVE_STRLCAT)
++CHECK_FUNCTION_EXISTS(strlcpy HAVE_STRLCPY)
++
++CHECK_FUNCTION_EXISTS(memcmp HAVE_MEMCMP)
++CHECK_FUNCTION_EXISTS(mkstemp HAVE_MKSTEMP)
++CHECK_FUNCTION_EXISTS(mktemp HAVE_MKTEMP)
++CHECK_FUNCTION_EXISTS(mktemp HAVE__MKTEMP)
++CHECK_FUNCTION_EXISTS(tmpnam HAVE_TMPNAM)
++CHECK_FUNCTION_EXISTS(getenv HAVE_GETENV)
++CHECK_FUNCTION_EXISTS(close HAVE_CLOSE)
++CHECK_FUNCTION_EXISTS(_close HAVE__CLOSE)
++CHECK_FUNCTION_EXISTS(unlink HAVE_UNLINK)
++CHECK_FUNCTION_EXISTS(_unlink HAVE__UNLINK)
++
++CHECK_TYPE_SIZE(byte BYTE)
++CHECK_TYPE_SIZE(u32 U32)
++CHECK_TYPE_SIZE(u64 U64)
++
++CHECK_TYPE_SIZE("unsigned char" SIZEOF_UNSIGNED_CHAR)
++CHECK_TYPE_SIZE("unsigned int" SIZEOF_UNSIGNED_INT)
++CHECK_TYPE_SIZE("unsigned long" SIZEOF_UNSIGNED_LONG)
++CHECK_TYPE_SIZE("unsigned long long" SIZEOF_UNSIGNED_LONG_LONG)
++
++CHECK_C_SOURCE_COMPILES("
++int main() {char *function_name = __func__; return 0;}"
++   HAVE___FUNC__
++)
++CHECK_C_SOURCE_COMPILES("
++int main() {char *function_name = __FUNCTION__; return 0;}"
++  HAVE___FUNCTION__
++)
++
++################################################################
++
++# User-configurable options
++#
++# (Note: The CMake GUI displays these in alphabetical order, regardless of
++# the order we use here)
++
++SET(BUILD_SHARED_LIBS OFF CACHE BOOL
++    "Build shared libraries instead of static ones.")
++
++#SET(REDLAND_ENABLE_TESTING TRUE CACHE BOOL
++#    "Enable unit tests")
++
++IF(BUILD_SHARED_LIBS)
++  SET(REDLAND_STATIC FALSE)
++ELSE()
++  SET(REDLAND_STATIC TRUE)
++ENDIF()
++
++# ---------- Threading -----------
++
++if(HAVE_PTHREAD_H)
++  set(WITH_THREADS OFF CACHE BOOL "With POSIX thread support")
++  if(WITH_THREADS)
++    set(CMAKE_THREAD_PREFER_PTHREAD)
++    find_package(Threads REQUIRED)
++    if(NOT CMAKE_USE_PTHREADS_INIT)
++      message(SEND_ERROR "POSIX pthread library not found")
++    endif()
++  endif()
++endif()
++
++
++########## ------- Storage Backends ------- ###########
++
++set(persistent_storages "file tstore mysql sqlite")
++set(persistent_store 0)
++set(all_storages memory file hashes trees mysql sqlite tstore postgresql virtuoso)
++set(always_available_storages memory file hashes trees)
++set(storages_enabled )
++
++set(ENABLE_ALL_STORAGES OFF CACHE BOOL "Use all available storages")
++
++# default availabilities and enablements
++foreach(storage ${all_storages})
++  set(${storage}_storage_available 0)
++  set(${storage}_storage 0)
++endforeach()
++foreach(storage ${always_available_storages})
++  set(${storage}_storage_available 1)
++  string(TOUPPER ${storage} storage_uc)
++  if(NOT ${storage} STREQUAL "memory")
++    set(ENABLE_${storage_uc} 1 CACHE BOOL "Use ${storage} storage backend")
++  endif()
++endforeach()
++set(ENABLE_MEMORY 1)
++
++# ----------- BerkeleyDB -------------
++
++set(bdb_available "Missing")
++set(bdb_version "n/a")
++set(storages_available ${always_available_storages})
++
++if(HAVE_LIBDB)
++  list(APPEND storages_available "hashes(bdb ${bdb_version})")
++endif()
++
++# ----------- MySql -------------
++
++set(ENABLE_MYSQL_INIT 0)
++set(libmysql_min_version 3.23.56)
++set(mysql_storage_available 0)
++
++find_program(MYSQL_CONFIG mysql_config)
++if(MYSQL_CONFIG)
++  execute_process(COMMAND ${MYSQL_CONFIG} --version
++    OUTPUT_VARIABLE LIBMYSQL_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE
++  )
++  message("mysql version: ${LIBMYSQL_VERSION}")
++  execute_process(COMMAND ${MYSQL_CONFIG} --libs
++    OUTPUT_VARIABLE LIBMYSQL_LIBRARIES OUTPUT_STRIP_TRAILING_WHITESPACE
++  )
++  execute_process(COMMAND ${MYSQL_CONFIG} --include
++    OUTPUT_VARIABLE LIBMYSQL_INCLUDE_DIR OUTPUT_STRIP_TRAILING_WHITESPACE
++  )
++  string(REPLACE "-I" "" LIBMYSQL_INCLUDE_DIR ${LIBMYSQL_INCLUDE_DIR})
++  message("mysql include dir: ${LIBMYSQL_INCLUDE_DIR}")
++  list(APPEND storages_available "mysql(${LIBMYSQL_VERSION})")
++  set(ENABLE_MYSQL_INIT 1)
++  set(mysql_storage_available 1)
++endif()
++
++set(ENABLE_MYSQL ${ENABLE_MYSQL_INIT} CACHE BOOL "Use MySQL 3/4 storage backend")
++
++foreach(storage ${all_storages})
++  string(TOUPPER ${storage} storage_uc)
++  if(${storage}_storage_available AND
++     (ENABLE_${storage_uc} OR ENABLE_ALL_STORAGES))
++    set(STORAGE_${storage_uc} 1)
++    list(APPEND storages_enabled ${storage})
++    list(FIND persistent_storages ${storage} _index)
++    if(${_index} GREATER -1)
++      set(persistent_store 1)
++    endif()
++  endif()
++endforeach()
++
++if(NOT persistent_store)
++  message("WARNING: No persistant storage is available or enabled")
++endif()
++
++########## ------- Digest Modules ------- ###########
++
++set(digest_modules md5 sha1 ripemd160)
++set(digest_modules_available )
++
++set(digest_srcs )
++foreach(module ${digest_modules})
++  string(TOUPPER ${module} module_uc)
++  set(base rdf_digest_${module})
++  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/src/${base}.c)
++    set(HAVE_LOCAL_${module_uc}_DIGEST 1)
++    list(APPEND digest_srcs ${base}.c)
++    list(APPEND digest_modules_available ${module})
++  endif()
++endforeach()
++
++################################################################
++
++include(CMakePackageConfigHelpers)
++
++CONFIGURE_FILE(
++  src/rdf_config_cmake.h.in
++  src/rdf_config.h
++  @ONLY
++)
++
++ADD_DEFINITIONS(-DHAVE_CONFIG_H)
++
++#CONFIGURE_FILE(
++#  src/rasqal.h.in
++#  src/rasqal.h
++#  @ONLY
++#)
++
++set(INCLUDE_INSTALL_DIR include)
++set(LIB_INSTALL_DIR lib)
++set(BIN_INSTALL_DIR bin)
++set(CMAKE_INSTALL_DIR lib/redland/cmake)
++set(DATA_INSTALL_DIR share/redland)
++
++add_subdirectory(src)
++
++configure_package_config_file(RedlandConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/RedlandConfig.cmake
++  INSTALL_DESTINATION ${CMAKE_INSTALL_DIR}
++  PATH_VARS INCLUDE_INSTALL_DIR
++  NO_CHECK_REQUIRED_COMPONENTS_MACRO
++)
++
++write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/RedlandConfigVersion.cmake
++  VERSION ${VERSION}
++  COMPATIBILITY AnyNewerVersion
++)
++
++install(FILES
++  ${CMAKE_CURRENT_BINARY_DIR}/RedlandConfig.cmake
++  ${CMAKE_CURRENT_BINARY_DIR}/RedlandConfigVersion.cmake
++  DESTINATION ${CMAKE_INSTALL_DIR}
++)
++
++
++message("Redland configuration:
++  Oracle Berkeley DB (BDB) : ${bdb_available}
++  Triple stores available  : ${storages_available}
++  Triple stores enabled    : ${storages_enabled}
++  RDF parsers              : ${rdf_parsers_available}
++  RDF query                : ${rdf_query}
++  Content digests          : ${digest_modules_available}"
++)
++
++# end redland/CMakeLists.txt
+diff -burN redland-1.0.17-orig/RedlandConfig.cmake.in redland-1.0.17-patched/RedlandConfig.cmake.in
+--- redland-1.0.17-orig/RedlandConfig.cmake.in	1970-01-01 01:00:00.000000000 +0100
++++ redland-1.0.17-patched/RedlandConfig.cmake.in	2014-11-26 14:08:47.781299653 +0100
+@@ -0,0 +1,13 @@
++set(Redland_VERSION @VERSION@)
++
++@PACKAGE_INIT@
++
++set_and_check(Redland_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
++
++find_package(Raptor2 REQUIRED)
++find_package(Rasqal REQUIRED)
++list(APPEND Redland_INCLUDE_DIR ${Rasqal_INCLUDE_DIR} ${Raptor2_INCLUDE_DIR})
++
++if(NOT TARGET rdf AND EXISTS ${CMAKE_CURRENT_LIST_DIR}/RedlandTargets.cmake)
++  include(${CMAKE_CURRENT_LIST_DIR}/RedlandTargets.cmake)
++endif()
+diff -burN redland-1.0.17-orig/RedlandConfig.cmake.in~ redland-1.0.17-patched/RedlandConfig.cmake.in~
+--- redland-1.0.17-orig/RedlandConfig.cmake.in~	1970-01-01 01:00:00.000000000 +0100
++++ redland-1.0.17-patched/RedlandConfig.cmake.in~	2014-11-26 14:03:18.518283855 +0100
+@@ -0,0 +1,9 @@
++set(Redland_VERSION @VERSION@)
++
++@PACKAGE_INIT@
++
++set_and_check(Redland_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
++
++if(NOT TARGET rdf AND EXISTS ${CMAKE_CURRENT_LIST_DIR}/RedlandTargets.cmake)
++  include(${CMAKE_CURRENT_LIST_DIR}/RedlandTargets.cmake)
++endif()
+diff -burN redland-1.0.17-orig/src/CMakeLists.txt redland-1.0.17-patched/src/CMakeLists.txt
+--- redland-1.0.17-orig/src/CMakeLists.txt	1970-01-01 01:00:00.000000000 +0100
++++ redland-1.0.17-patched/src/CMakeLists.txt	2014-11-26 14:03:18.518283855 +0100
+@@ -0,0 +1,171 @@
++# redland/src/CMakeLists.txt
++#
++# Based on the src/CMakeLists.txt file from Raptor
++# This file is in the public domain.
++#
++
++set(public_headers
++  librdf.h
++  rdf_concepts.h
++  rdf_digest.h
++  rdf_hash.h
++  rdf_init.h
++  rdf_iterator.h
++  rdf_list.h
++  rdf_log.h
++  rdf_model.h
++  rdf_node.h
++  rdf_parser.h
++  rdf_query.h
++  rdf_raptor.h
++  rdf_serializer.h
++  rdf_statement.h
++  rdf_storage.h
++  rdf_storage_module.h
++  rdf_stream.h
++  rdf_uri.h
++  rdf_utf8.h
++  redland.h
++)
++
++set(internal_headers
++  rdf_concepts_internal.h
++  rdf_digest_internal.h
++  rdf_files.h
++  rdf_hash_internal.h
++  rdf_heuristics.h
++  rdf_init_internal.h
++  rdf_internal.h
++  rdf_iterator_internal.h
++  rdf_list_internal.h
++  rdf_log_internal.h
++  rdf_model_internal.h
++  rdf_node_internal.h
++  rdf_parser_internal.h
++  rdf_query_internal.h
++  rdf_raptor_internal.h
++  rdf_serializer_internal.h
++  rdf_statement_internal.h
++  rdf_storage_internal.h
++  rdf_stream_internal.h
++  rdf_types.h
++  rdf_uri_internal.h
++)
++
++set(srcs
++  rdf_concepts.c
++  rdf_digest.c
++  rdf_files.c
++  rdf_hash.c
++  rdf_hash_cursor.c
++  rdf_hash_memory.c
++  rdf_heuristics.c
++  rdf_init.c
++  rdf_iterator.c
++  rdf_list.c
++  rdf_log.c
++  rdf_model.c
++  rdf_model_storage.c
++  rdf_node_common.c
++  rdf_node.c
++  rdf_parser.c
++  rdf_parser_raptor.c
++  rdf_query.c
++  rdf_query_rasqal.c
++  rdf_query_results.c
++  rdf_raptor.c
++  rdf_serializer.c
++  rdf_serializer_raptor.c
++  rdf_statement.c
++  rdf_statement_common.c
++  rdf_storage.c
++  rdf_storage_sql.c
++  rdf_stream.c
++  rdf_uri.c
++  rdf_utf8.c
++  ${digest_srcs}
++  ${internal_headers}
++)
++
++if(NOT HAVE_MEMCMP)
++  list(APPEND srcs memcmp.c)
++endif()
++
++# Storages always built-in
++list(APPEND srcs rdf_storage_list.c rdf_storage_hashes.c rdf_storage_trees.c)
++if(STORAGE_FILE)
++  list(APPEND srcs rdf_storage_file.c)
++endif()
++
++set(storage_libs )
++if(STORAGE_TSTORE)
++  list(APPEND srcs rdf_storage_tstore.c)
++endif()
++if(STORAGE_MYSQL)
++  list(APPEND srcs rdf_storage_mysql.c)
++  include_directories(${LIBMYSQL_INCLUDE_DIR})
++  list(APPEND storage_libs ${LIBMYSQL_LIBRARIES})
++  INSTALL(FILES mysql-v1.ttl mysql-v2.ttl
++    DESTINATION ${DATA_INSTALL_DIR}
++  )
++endif()
++if(STORAGE_SQLITE)
++  list(APPEND srcs rdf_storage_sqlite.c)
++endif()
++if(STORAGE_POSTGRESQL)
++  list(APPEND srcs rdf_storage_postgresql.c)
++endif()
++if(STORAGE_VIRTUOSO)
++  list(APPEND srcs rdf_storage_virtuoso.c rdf_query_virtuoso.c rdf_storage_virtuoso_internal.h)
++endif()
++
++add_library(rdf ${srcs})
++
++target_link_libraries(rdf raptor2 rasqal ${storage_libs})
++if(WITH_THREADS)
++  target_link_libraries(rdf ${CMAKE_THREAD_LIBS_INIT})
++endif()
++
++SET_TARGET_PROPERTIES(
++  rdf
++  PROPERTIES
++  COMPILE_DEFINITIONS "LIBRDF_INTERNAL;PKGDATADIR=\"${CMAKE_INSTALL_PREFIX}/${DATA_INSTALL_DIR}\""
++  PUBLIC_HEADER "${public_headers}"
++)
++
++# Generate pkg-config metadata file
++#
++FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/redland.pc
++"prefix=${CMAKE_INSTALL_PREFIX}
++exec_prefix=\${prefix}
++libdir=\${exec_prefix}/${LIB_INSTALL_DIR}
++includedir=\${prefix}/${INCLUDE_INSTALL_DIR}
++
++have_raptor2_api=1
++
++Name: ${PROJECT_DESCRIPTION}
++Description: Redland RDF API and triple store library
++Requires.private: raptor2 >= ${RAPTOR_MIN_VERSION}, rasqal >= ${RASQAL_MIN_VERSION}, rasqal <= 0.9.99
++Version: ${VERSION}
++Libs: -L\${libdir} -lrdf
++Libs.private: -ldl
++Cflags: -I\${includedir}
++")
++
++INSTALL(FILES
++  ${CMAKE_CURRENT_BINARY_DIR}/redland.pc
++  DESTINATION ${LIB_INSTALL_DIR}/pkgconfig
++)
++
++INSTALL(
++  TARGETS rdf
++  EXPORT  RedlandTargets
++  ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
++  LIBRARY DESTINATION ${LIB_INSTALL_DIR}
++  RUNTIME DESTINATION ${BIN_INSTALL_DIR}
++  PUBLIC_HEADER DESTINATION ${INCLUDE_INSTALL_DIR}
++)
++
++INSTALL(EXPORT RedlandTargets DESTINATION ${CMAKE_INSTALL_DIR})
++
++# end redland/src/CMakeLists.txt
+diff -burN redland-1.0.17-orig/src/rdf_config_cmake.h.in redland-1.0.17-patched/src/rdf_config_cmake.h.in
+--- redland-1.0.17-orig/src/rdf_config_cmake.h.in	1970-01-01 01:00:00.000000000 +0100
++++ redland-1.0.17-patched/src/rdf_config_cmake.h.in	2014-11-26 14:03:18.519283855 +0100
+@@ -0,0 +1,508 @@
++/* src/rdf_config_cmake.h.in.*/
++
++/* Release version as a decimal */
++#define LIBRDF_VERSION_DECIMAL @REDLAND_VERSION_DECIMAL@
++
++/* Major version number */
++#define LIBRDF_VERSION_MAJOR @REDLAND_VERSION_MAJOR@
++
++/* Minor version number */
++#define LIBRDF_VERSION_MINOR @REDLAND_VERSION_MINOR@
++
++/* Release version number */
++#define LIBRDF_VERSION_RELEASE @REDLAND_VERSION_RELEASE@
++
++/* ---------- package information ------------ */
++
++/* Name of package */
++#define PACKAGE @PROJECT_NAME@
++
++/* Define to the address where bug reports for this package should be sent. */
++#define PACKAGE_BUGREPORT "http://bugs.librdf.org/"
++
++/* Define to the full name of this package. */
++#define PACKAGE_NAME "@PROJECT_DESCRIPTION@"
++
++/* Define to the full name and version of this package. */
++#define PACKAGE_STRING "@PROJECT_DESCRIPTION@ @VERSION@"
++
++/* Define to the one symbol short name of this package. */
++#define PACKAGE_TARNAME librdf
++
++/* Define to the home page for this package. */
++#define PACKAGE_URL ""
++
++/* Define to the version of this package. */
++#define PACKAGE_VERSION "@VERSION@"
++
++/* Version number of package */
++#define VERSION "@VERSION@"
++
++/* Define if building universal (internal helper macro) */
++#cmakedefine AC_APPLE_UNIVERSAL_BUILD
++
++/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
++   significant byte first (like Motorola and SPARC, unlike Intel). */
++#if defined AC_APPLE_UNIVERSAL_BUILD
++# if defined __BIG_ENDIAN__
++#  define WORDS_BIGENDIAN 1
++# endif
++#else
++# ifndef WORDS_BIGENDIAN
++#  undef WORDS_BIGENDIAN
++# endif
++#endif
++
++/* ------------ header availability --------------- */
++
++/* Define to 1 if you have the <db.h> header file. */
++#cmakedefine HAVE_DB_H
++
++/* Define to 1 if you have the <dirent.h> header file. */
++#cmakedefine HAVE_DIRENT_H
++
++/* Define to 1 if you have the <dld.h> header file. */
++#cmakedefine HAVE_DLD_H
++
++/* Define to 1 if you have the <dlfcn.h> header file. */
++#cmakedefine HAVE_DLFCN_H
++
++/* Define to 1 if you have the <dl.h> header file. */
++#cmakedefine HAVE_DL_H
++
++/* Define if you have the _dyld_func_lookup function. */
++#cmakedefine HAVE_DYLD
++
++/* Define to 1 if you have the <errno.h> header file. */
++#cmakedefine HAVE_ERRNO_H
++
++/* Define to 1 if you have the <fcntl.h> header file. */
++#cmakedefine HAVE_FCNTL_H
++
++/* Define to 1 if you have the <getopt.h> header file. */
++#cmakedefine HAVE_GETOPT_H
++
++/* Define to 1 if you have the <inttypes.h> header file. */
++#cmakedefine HAVE_INTTYPES_H
++
++/* Define to 1 if you have the <libpq-fe.h> header file. */
++#cmakedefine HAVE_LIBPQ_FE_H
++
++/* Define to 1 if you have the <mach-o/dyld.h> header file. */
++#cmakedefine HAVE_MACH_O_DYLD_H
++
++/* Define to 1 if you have the <memory.h> header file. */
++#cmakedefine HAVE_MEMORY_H
++
++/* Define to 1 if you have the <pthread.h> header file. */
++#cmakedefine HAVE_PTHREAD_H
++
++/* Define to 1 if you have the <sqlite3.h> header file. */
++#cmakedefine HAVE_SQLITE3_H
++
++/* Define to 1 if you have the <sqlite.h> header file. */
++#cmakedefine HAVE_SQLITE_H
++
++/* Define to 1 if you have the <stddef.h> header file. */
++#cmakedefine HAVE_STDDEF_H
++
++/* Define to 1 if you have the <stdint.h> header file. */
++#cmakedefine HAVE_STDINT_H
++
++/* Define to 1 if you have the <stdlib.h> header file. */
++#cmakedefine HAVE_STDLIB_H
++
++/* Define to 1 if you have the <strings.h> header file. */
++#cmakedefine HAVE_STRINGS_H
++
++/* Define to 1 if you have the <string.h> header file. */
++#cmakedefine HAVE_STRING_H
++
++/* Define to 1 if you have the <sys/dl.h> header file. */
++#cmakedefine HAVE_SYS_DL_H
++
++/* Define to 1 if you have the <sys/stat.h> header file. */
++#cmakedefine HAVE_SYS_STAT_H
++
++/* Define to 1 if you have the <sys/time.h> header file. */
++#cmakedefine01 HAVE_SYS_TIME_H
++
++/* Define to 1 if you have the <sys/types.h> header file. */
++#cmakedefine HAVE_SYS_TYPES_H
++
++/* Define to 1 if you have the <time.h> header file. */
++#cmakedefine HAVE_TIME_H
++
++/* Define to 1 if you have the <unistd.h> header file. */
++#cmakedefine HAVE_UNISTD_H
++
++
++/* --------- feature availability ------------ */
++
++/* Define so that glibc/gnulib argp.h does not typedef error_t. */
++#undef __error_t_defined
++
++/* Define to a type to use for `error_t' if it is not otherwise available. */
++#undef error_t
++
++/* BDB has close method with 2 args */
++#cmakedefine HAVE_BDB_CLOSE_2_ARGS
++
++/* BDB defines DBC */
++#cmakedefine HAVE_BDB_CURSOR
++
++/* BDB cursor method has 4 arguments */
++#cmakedefine HAVE_BDB_CURSOR_4_ARGS
++
++/* BDB defines DB_TXN */
++#cmakedefine HAVE_BDB_DB_TXN
++
++/* BDB has fd method with 2 args */
++#cmakedefine HAVE_BDB_FD_2_ARGS
++
++/* Have BDB hash support */
++#cmakedefine HAVE_BDB_HASH
++
++/* BDB has open method with 6 args */
++#cmakedefine HAVE_BDB_OPEN_6_ARGS
++
++/* BDB has open method with 7 args */
++#cmakedefine HAVE_BDB_OPEN_7_ARGS
++
++/* BDB has set_flags method */
++#cmakedefine HAVE_BDB_SET_FLAGS
++
++/* Define to 1 if the system has the type `byte'. */
++#cmakedefine HAVE_BYTE
++
++/* Define if you have the GNU dld library. */
++#cmakedefine HAVE_DLD
++
++/* Have local MD5 digest */
++#cmakedefine HAVE_LOCAL_MD5_DIGEST
++
++/* Have local RIPEMD160 digest */
++#cmakedefine HAVE_LOCAL_RIPEMD160_DIGEST
++
++/* Have local SHA1 digest */
++#cmakedefine HAVE_LOCAL_SHA1_DIGEST
++
++/* Define this if a modern libltdl is already installed */
++#cmakedefine HAVE_LTDL
++
++/* Define if you have the libdl library or equivalent. */
++#cmakedefine HAVE_LIBDL
++
++/* Define if libdlloader will be built on this platform */
++#cmakedefine HAVE_LIBDLLOADER
++
++/* have MYSQL_OPT_RECONNECT declared */
++#cmakedefine HAVE_MYSQL_OPT_RECONNECT
++
++/* Define if libtool can extract symbol lists from object files. */
++#cmakedefine HAVE_PRELOADED_SYMBOLS
++
++/* Define to 1 if the system has the type `u32'. */
++#cmakedefine HAVE_U32
++
++/* Define to 1 if the system has the type `u64'. */
++#cmakedefine HAVE_U64
++
++/* This value is set to 1 to indicate that the system argz facility works */
++#cmakedefine HAVE_WORKING_ARGZ
++
++/* Run time assertion checks. */
++#cmakedefine LIBRDF_ASSERT
++
++/* Print run time assertion check failure messages. */
++#cmakedefine LIBRDF_ASSERT_MESSAGES
++
++/* Define if the OS needs help to load dependent libraries for dlopen(). */
++#cmakedefine LTDL_DLOPEN_DEPLIBS
++
++/* Define to the system default library search path. */
++#cmakedefine LT_DLSEARCH_PATH
++
++/* The archive extension */
++#cmakedefine LT_LIBEXT
++
++/* The archive prefix */
++#cmakedefine LT_LIBPREFIX
++
++/* Define to the extension used for runtime loadable modules, say, ".so". */
++#cmakedefine LT_MODULE_EXT
++
++/* Define to the name of the environment variable that determines the run-time
++   module search path. */
++#cmakedefine LT_MODULE_PATH_VAR
++
++/* Define to the sub-directory in which libtool stores uninstalled libraries.
++   */
++#cmakedefine LT_OBJDIR
++
++/* Define to the shared library suffix, say, ".dylib". */
++#cmakedefine LT_SHARED_EXT
++
++/* Build storage backends as modules */
++#cmakedefine MODULAR_LIBRDF
++
++/* Define if dlsym() requires a leading underscore in symbol names. */
++#cmakedefine NEED_USCORE
++
++/* Define to 1 if your C compiler doesn't accept -c and -o together. */
++#cmakedefine NO_MINUS_C_MINUS_O
++
++
++/* The size of `unsigned char', as computed by sizeof. */
++#define SIZEOF_UNSIGNED_CHAR @SIZEOF_UNSIGNED_CHAR@
++
++/* The size of `unsigned int', as computed by sizeof. */
++#define SIZEOF_UNSIGNED_INT @SIZEOF_UNSIGNED_INT@
++
++/* The size of `unsigned long', as computed by sizeof. */
++#define SIZEOF_UNSIGNED_LONG @SIZEOF_UNSIGNED_LONG@
++
++/* The size of `unsigned long long', as computed by sizeof. */
++#define SIZEOF_UNSIGNED_LONG_LONG @SIZEOF_UNSIGNED_LONG_LONG@
++
++/* define to SQLINTEGER if not defined in the ODBC headers */
++#cmakedefine SQLLEN
++
++/* define to SQLUINTEGER if not defined in the ODBC headers */
++#cmakedefine SQLULEN
++
++/* Define to 1 if you have the ANSI C header files. */
++#cmakedefine STDC_HEADERS
++
++/* Building file storage */
++#cmakedefine STORAGE_FILE
++
++/* Building hashes storage */
++#cmakedefine STORAGE_HASHES
++
++/* Building memory storage */
++#cmakedefine STORAGE_MEMORY
++
++/* Building MySQL storage */
++#cmakedefine STORAGE_MYSQL
++
++/* Building PostgreSQL storage */
++#cmakedefine STORAGE_POSTGRESQL
++
++/* Building SQLite storage */
++#cmakedefine STORAGE_SQLITE
++
++/* Building trees storage */
++#cmakedefine STORAGE_TREES
++
++/* Building 3store storage */
++#cmakedefine STORAGE_TSTORE
++
++/* Building Virtuoso storage */
++#cmakedefine STORAGE_VIRTUOSO
++
++/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
++#cmakedefine01 TIME_WITH_SYS_TIME
++
++/* Use POSIX threads */
++#cmakedefine WITH_THREADS
++
++/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
++   significant byte first (like Motorola and SPARC, unlike Intel). */
++#if defined AC_APPLE_UNIVERSAL_BUILD
++# if defined __BIG_ENDIAN__
++#  define WORDS_BIGENDIAN 1
++# endif
++#else
++# ifndef WORDS_BIGENDIAN
++#  undef WORDS_BIGENDIAN
++# endif
++#endif
++
++/* --------- function availability ----------- */
++
++/* Define to 1 if you have the `argz_add' function. */
++#cmakedefine HAVE_ARGZ_ADD
++
++/* Define to 1 if you have the `argz_append' function. */
++#cmakedefine HAVE_ARGZ_APPEND
++
++/* Define to 1 if you have the `argz_count' function. */
++#cmakedefine HAVE_ARGZ_COUNT
++
++/* Define to 1 if you have the `argz_create_sep' function. */
++#cmakedefine HAVE_ARGZ_CREATE_SEP
++
++/* Define to 1 if you have the <argz.h> header file. */
++#cmakedefine HAVE_ARGZ_H
++
++/* Define to 1 if you have the `argz_insert' function. */
++#cmakedefine HAVE_ARGZ_INSERT
++
++/* Define to 1 if you have the `argz_next' function. */
++#cmakedefine HAVE_ARGZ_NEXT
++
++/* Define to 1 if you have the `argz_stringify' function. */
++#cmakedefine HAVE_ARGZ_STRINGIFY
++
++/* Define to 1 if you have the `closedir' function. */
++#cmakedefine HAVE_CLOSEDIR
++
++/* BDB has dbopen method */
++#cmakedefine HAVE_DBOPEN
++
++/* BDB has db_create method */
++#cmakedefine HAVE_DB_CREATE
++
++/* BDB has db_open method */
++#cmakedefine HAVE_DB_OPEN
++
++/* Define to 1 if you have the declaration of `cygwin_conv_path', and to 0 if
++   you don't. */
++#cmakedefine HAVE_DECL_CYGWIN_CONV_PATH
++
++/* Define to 1 if you have the `dlerror' function. */
++#cmakedefine HAVE_DLERROR
++
++/* Define to 1 if the system has the type `error_t'. */
++#cmakedefine HAVE_ERROR_T
++
++/* Define to 1 if you have the `getenv' function. */
++#cmakedefine HAVE_GETENV
++
++/* Define to 1 if you have the `getopt' function. */
++#cmakedefine HAVE_GETOPT
++
++/* Define to 1 if you have the `getopt_long' function. */
++#cmakedefine HAVE_GETOPT_LONG
++
++/* Define to 1 if you have the `gettimeofday' function. */
++#cmakedefine HAVE_GETTIMEOFDAY
++
++#cmakedefine HAVE_ACCESS
++#cmakedefine HAVE__ACCESS
++#cmakedefine HAVE_SNPRINTF
++#cmakedefine HAVE__SNPRINTF
++#cmakedefine HAVE_STRCASECMP
++#cmakedefine HAVE_STRICMP
++#cmakedefine HAVE__STRICMP
++#cmakedefine HAVE_STRNICMP
++#cmakedefine HAVE__STRNICMP
++#cmakedefine HAVE_VASPRINTF
++#cmakedefine HAVE_VSNPRINTF
++#cmakedefine HAVE__VSNPRINTF
++
++/* Define to 1 if you have the `memcmp' function. */
++#cmakedefine HAVE_MEMCMP
++
++/* Define to 1 if you have the `mkstemp' function. */
++#cmakedefine HAVE_MKSTEMP
++
++/* Define to 1 if you have the `mktemp' function. */
++#cmakedefine HAVE_MKTEMP
++#cmakedefine HAVE__MKTEMP
++
++/* Define to 1 if you have the `opendir' function. */
++#cmakedefine HAVE_OPENDIR
++
++/* Define to 1 if you have the `readdir' function. */
++#cmakedefine HAVE_READDIR
++
++/* Define if you have the shl_load function. */
++#cmakedefine HAVE_SHL_LOAD
++
++/* Define to 1 if you have the `strlcat' function. */
++#cmakedefine HAVE_STRLCAT
++
++/* Define to 1 if you have the `strlcpy' function. */
++#cmakedefine HAVE_STRLCPY
++
++/* Define to 1 if you have the `tmpnam' function. */
++#cmakedefine HAVE_TMPNAM
++
++#cmakedefine HAVE_CLOSE
++#cmakedefine HAVE__CLOSE
++
++#cmakedefine HAVE_UNLINK
++#cmakedefine HAVE__UNLINK
++
++
++/* --------- WIN32 config ----------- */
++
++#ifdef WIN32
++
++# ifdef __cplusplus
++  extern "C" {
++# endif
++
++# define WIN32_LEAN_AND_MEAN 1
++# define _CRT_NONSTDC_NO_DEPRECATE
++# define _CRT_SECURE_NO_DEPRECATE
++
++
++  /* MS names for these functions */
++  // next line breaks build on wntmsci12
++  //#define vsnprintf _vsnprintf
++# if !defined(HAVE_SNPRINTF) && defined(HAVE__SNPRINTF)
++#   define snprintf _snprintf
++# endif
++# if !defined(HAVE_STRICMP) && defined(HAVE__STRICMP)
++#   define stricmp _stricmp
++# endif
++# if !defined(HAVE_STRNICMP) && defined(HAVE__STRNICMP)
++#   define strnicmp _strnicmp
++# endif
++
++# if !defined(HAVE_CLOSE) && defined(HAVE__CLOSE)
++#   define close _close
++# endif
++# if !defined(HAVE_UNLINK) && defined(HAVE__UNLINK)
++#   define unlink _unlink
++# endif
++# if !defined(HAVE_MKTEMP) && defined(HAVE__MKTEMP)
++#   define mktemp _mktemp
++# endif
++
++/* Define the following if you are calling the librdf from C# or any language which uses stdcall */
++#define USE_STDCALL_CALLBACKS 1
++
++/* for access() which is POSIX but doesn't seem to have the defines in VC */
++# ifndef R_OK
++# define F_OK 0
++# define R_OK 4
++# endif
++
++# ifdef _MSC_VER
++#   if (_MSC_VER >= 1300) && !defined(__func__)
++#     define __func__ __FUNCTION__
++#     define HAVE___FUNC__
++#   elif !defined(__func__)
++      /* better than nothing */
++#     define rasqal_str(s) #s
++#     define __func__ "func@" __FILE__ ":" rasqal_str(__LINE__)
++#   endif
++# endif
++
++# if !defined(HAVE_ACCESS) && defined(HAVE__ACCESS)
++#   define access(p,m) _access(p,m)
++# endif
++
++# undef REDLAND_INLINE
++# define REDLAND_INLINE __inline
++
++# include <windows.h>
++# include <io.h>
++# include <stdio.h>
++# include <process.h>
++
++  /* get _isnan() since it is not in math.h */
++# include <float.h>
++# ifndef isnan
++# define isnan(d) (_isnan(d))
++# endif
++
++# ifdef __cplusplus
++  }
++# endif
++
++#endif
+diff -burN redland-1.0.17-orig/src/win32_rdf_config.h redland-1.0.17-patched/src/win32_rdf_config.h
+--- redland-1.0.17-orig/src/win32_rdf_config.h	2013-12-28 17:31:20.000000000 +0100
++++ redland-1.0.17-patched/src/win32_rdf_config.h	2014-11-26 14:03:18.520283855 +0100
+@@ -21,6 +21,7 @@
+  *
+  */
+ 
++#if 0
+ #ifndef WIN32_RDF_CONFIG_H
+ #define WIN32_RDF_CONFIG_H
+ 
+@@ -300,3 +301,4 @@
+ #endif
+ 
+ #endif
++#endif
+diff -burN redland-1.0.17-orig/src/win32_rdf_config.h.in redland-1.0.17-patched/src/win32_rdf_config.h.in
+--- redland-1.0.17-orig/src/win32_rdf_config.h.in	2013-04-05 19:17:40.000000000 +0200
++++ redland-1.0.17-patched/src/win32_rdf_config.h.in	2014-11-26 14:03:18.521283855 +0100
+@@ -21,6 +21,7 @@
+  *
+  */
+ 
++#if 0
+ #ifndef WIN32_RDF_CONFIG_H
+ #define WIN32_RDF_CONFIG_H
+ 
+@@ -300,3 +301,4 @@
+ #endif
+ 
+ #endif
++#endif
diff --git a/CMakeExternals/redland.cmake b/CMakeExternals/redland.cmake
new file mode 100644
index 0000000000..e5b110928c
--- /dev/null
+++ b/CMakeExternals/redland.cmake
@@ -0,0 +1,44 @@
+#-----------------------------------------------------------------------------
+# redland
+#-----------------------------------------------------------------------------
+
+if(MITK_USE_redland)
+
+# Sanity checks
+if(DEFINED redland_DIR AND NOT EXISTS ${redland_DIR})
+  message(FATAL_ERROR "redland_DIR variable is defined but corresponds to non-existing directory")
+endif()
+
+set(proj redland)
+set(proj_DEPENDENCIES ${raptor2_DEPENDS} ${rasqal_DEPENDS})
+set(${proj}_DEPENDS ${proj})
+
+if(NOT DEFINED redland_DIR)
+
+  ExternalProject_Add(${proj}
+     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
+     BINARY_DIR ${proj}-build
+     INSTALL_DIR ${REDLAND_INSTALL_DIR}
+     PREFIX ${proj}-cmake
+     URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/redland-1.0.17.tar.gz
+     URL_MD5 e5be03eda13ef68aabab6e42aa67715e
+     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_LIST_DIR}/redland-1.0.17.patch
+     CMAKE_GENERATOR ${gen}
+     CMAKE_ARGS
+       ${ep_common_args}
+       -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
+       -DBUILD_SHARED_LIBS:BOOL=ON
+       -DWITH_THREADS:BOOL=OFF
+       -DCMAKE_PREFIX_PATH:STRING=${REDLAND_INSTALL_DIR}
+     DEPENDS ${proj_DEPENDENCIES}
+    )
+
+  set(${proj}_DIR ${REDLAND_INSTALL_DIR}/lib/redland/cmake/)
+
+else()
+
+  mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+
+endif()
+
+endif()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 97380f819c..b614e371c8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,1102 +1,1103 @@
 set(DESIRED_QT_VERSION 4 CACHE STRING "Pick a version of Qt to use: 4 or 5")
 
 if(DESIRED_QT_VERSION MATCHES "4")
   cmake_minimum_required(VERSION 2.8.9)
 else()
   cmake_minimum_required(VERSION 2.8.12)
 endif()
 
 #-----------------------------------------------------------------------------
 # Include ctest launchers for dashboard in case of makefile generator
 #-----------------------------------------------------------------------------
 if(${CMAKE_VERSION} VERSION_GREATER "2.8.9")
   include(CTestUseLaunchers)
 endif()
 
 #-----------------------------------------------------------------------------
 # 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()
 
 #-----------------------------------------------------------------------------
 # Superbuild Option - Enabled by default
 #-----------------------------------------------------------------------------
 
 option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON)
 
 if(MITK_USE_SUPERBUILD)
   project(MITK-superbuild)
   set(MITK_SOURCE_DIR ${PROJECT_SOURCE_DIR})
   set(MITK_BINARY_DIR ${PROJECT_BINARY_DIR})
 else()
   project(MITK)
 endif()
 
 #-----------------------------------------------------------------------------
 # Warn if source or build path is too long
 #-----------------------------------------------------------------------------
 
 if(WIN32)
   set(_src_dir_length_max 50)
   set(_bin_dir_length_max 50)
   if(MITK_USE_SUPERBUILD)
     set(_src_dir_length_max 43) # _src_dir_length_max - strlen(ITK-src)
     set(_bin_dir_length_max 40) # _bin_dir_length_max - strlen(MITK-build)
   endif()
 
   string(LENGTH "${MITK_SOURCE_DIR}" _src_n)
   string(LENGTH "${MITK_BINARY_DIR}" _bin_n)
 
   # The warnings should be converted to errors
   if(_src_n GREATER _src_dir_length_max)
     message(WARNING "MITK source code directory path length is too long (${_src_n} > ${_src_dir_length_max})."
                     "Please move the MITK source code directory to a directory with a shorter path." )
   endif()
   if(_bin_n GREATER _bin_dir_length_max)
     message(WARNING "MITK build directory path length is too long (${_bin_n} > ${_bin_dir_length_max})."
                     "Please move the MITK build directory to a directory with a shorter path." )
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
 #-----------------------------------------------------------------------------
 
 set(project_policies
   CMP0001 # NEW: CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
   CMP0002 # NEW: Logical target names must be globally unique.
   CMP0003 # NEW: Libraries linked via full path no longer produce linker search paths.
   CMP0004 # NEW: Libraries linked may NOT have leading or trailing whitespace.
   CMP0005 # NEW: Preprocessor definition values are now escaped automatically.
   CMP0006 # NEW: Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
   CMP0007 # NEW: List command no longer ignores empty elements.
   CMP0008 # NEW: Libraries linked by full-path must have a valid library file name.
   CMP0009 # NEW: FILE GLOB_RECURSE calls should not follow symlinks by default.
   CMP0010 # NEW: Bad variable reference syntax is an error.
   CMP0011 # NEW: Included scripts do automatic cmake_policy PUSH and POP.
   CMP0012 # NEW: if() recognizes numbers and boolean constants.
   CMP0013 # NEW: Duplicate binary directories are not allowed.
   CMP0014 # NEW: Input directories must have CMakeLists.txt.
   CMP0020 # NEW: Automatically link Qt executables to qtmain target on Windows.
   CMP0028 # NEW: Double colon in target name means ALIAS or IMPORTED target.
   CMP0043 # NEW: Ignore COMPILE_DEFINITIONS_<Config> properties.
   )
 foreach(policy ${project_policies})
   if(POLICY ${policy})
     cmake_policy(SET ${policy} NEW)
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #------------------------------------------------------------------------------
 
 set(MITK_CMAKE_DIR ${MITK_SOURCE_DIR}/CMake)
 
 set(CMAKE_MODULE_PATH
   ${MITK_CMAKE_DIR}
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(mitkMacroEmptyExternalProject)
 include(mitkFunctionGenerateProjectXml)
 include(mitkFunctionSuppressWarnings)
 include(mitkFunctionEnableBuildConfiguration)
 include(mitkFunctionWhitelists)
 include(FeatureSummary)
 
 SUPPRESS_VC_DEPRECATED_WARNINGS()
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   # Make sure the directory exists
   if(DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY
      AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     message("Creating directory MITK_CMAKE_${type}_OUTPUT_DIRECTORY: ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
     file(MAKE_DIRECTORY "${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
   endif()
 
   if(MITK_USE_SUPERBUILD)
     set(output_dir ${MITK_BINARY_DIR}/bin)
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_BINARY_DIR}/MITK-build/bin)
     endif()
   else()
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(output_dir ${MITK_BINARY_DIR}/bin)
     else()
       set(output_dir ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     endif()
   endif()
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${output_dir} CACHE INTERNAL "Single output directory for building all libraries.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Additional MITK Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON)
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 option(BUILD_TESTING "Test the project" ON)
 
 macro(env_option name doc value)
   set(_value $ENV{${name}})
   if("${_value}" STREQUAL "")
     set(_value ${value})
   endif()
   option(${name} "${doc}" ${_value})
 endmacro()
 
 # -----------------------------------------
 # Qt version related variables
 
 env_option(MITK_USE_QT "Use Nokia's Qt library" ON)
 set(MITK_DESIRED_QT_VERSION ${DESIRED_QT_VERSION})
 
 if(MITK_USE_QT)
   # find the package at the very beginning, so that QT4_FOUND is available
   if(DESIRED_QT_VERSION MATCHES 4)
     set(MITK_QT4_MINIMUM_VERSION 4.7)
     find_package(Qt4 ${MITK_QT4_MINIMUM_VERSION} REQUIRED)
     set(MITK_USE_Qt4 TRUE)
     set(MITK_USE_Qt5 FALSE)
   endif()
   if(DESIRED_QT_VERSION MATCHES 5)
     set(MITK_QT5_MINIMUM_VERSION 5.0.0)
     set(MITK_USE_Qt4 FALSE)
     set(MITK_USE_Qt5 TRUE)
     set(QT5_INSTALL_PREFIX "" CACHE PATH "The install location of Qt5")
     set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${QT5_INSTALL_PREFIX})
     find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
     find_package(Qt5Concurrent ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
     find_package(Qt5OpenGL ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
     find_package(Qt5PrintSupport ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
     find_package(Qt5Sql ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
     find_package(Qt5Svg ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
     find_package(Qt5WebKit ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
     find_package(Qt5WebKitWidgets ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
     find_package(Qt5Widgets ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
     find_package(Qt5Xml ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
   endif()
 else()
   set(MITK_USE_Qt4 FALSE)
   set(MITK_USE_Qt5 FALSE)
 endif()
 
 # -----------------------------------------
 # MITK_USE_* build variables
 
 env_option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF)
 set(MITK_BUILD_TUTORIAL OFF CACHE INTERNAL "Deprecated! Use MITK_BUILD_EXAMPLES instead!")
 env_option(MITK_BUILD_EXAMPLES "Build the MITK Examples" ${MITK_BUILD_TUTORIAL})
 env_option(MITK_USE_ACVD "Use Approximated Centroidal Voronoi Diagrams" OFF)
 env_option(MITK_USE_ANN "Use Approximate Nearest Neighbor Library" ON)
 env_option(MITK_USE_CppUnit "Use CppUnit for unit tests" ON)
 if(BUILD_TESTING AND NOT MITK_USE_CppUnit)
   message("> Forcing MITK_USE_CppUnit to ON because BUILD_TESTING=ON")
   set(MITK_USE_CppUnit ON CACHE BOOL "Use CppUnit for unit tests" FORCE)
 endif()
 env_option(MITK_USE_Eigen "Use the Eigen library" ON)
 env_option(MITK_USE_GLEW "Use the GLEW library" ON)
 env_option(MITK_USE_Boost "Use the Boost C++ library" OFF)
 env_option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
 env_option(MITK_USE_CTK "Use CTK in MITK" ON)
 env_option(MITK_USE_DCMTK "EXPERIMENTAL, superbuild only: Use DCMTK in MITK" ${MITK_USE_CTK})
 env_option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF)
 env_option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF)
 env_option(MITK_USE_Poco "Use the Poco library" ON)
+env_option(MITK_USE_Redland "Use the Redland RDF library" OFF)
 env_option(MITK_USE_SOFA "Use Simulation Open Framework Architecture" OFF)
 env_option(MITK_USE_Python "Use Python wrapping in MITK" OFF)
 env_option(MITK_USE_SimpleITK "Use the SimpleITK library" OFF)
 set(MITK_USE_CableSwig ${MITK_USE_Python})
 
 option(MITK_ENABLE_PIC_READER "Enable support for reading the DKFZ pic file format." ON)
 
 set(_buildConfigs "Custom")
 
 file(GLOB _buildConfigFiles CMake/BuildConfigurations/*.cmake)
 
 foreach(_buildConfigFile ${_buildConfigFiles})
   get_filename_component(_buildConfigFile ${_buildConfigFile} NAME_WE)
   list(APPEND _buildConfigs ${_buildConfigFile})
 endforeach()
 
 set(MITK_BUILD_CONFIGURATION "Custom" CACHE STRING "Use pre-defined MITK configurations")
 set_property(CACHE MITK_BUILD_CONFIGURATION PROPERTY STRINGS ${_buildConfigs})
 
 mitkFunctionEnableBuildConfiguration()
 
 mitkFunctionCreateWhitelistPaths(MITK)
 mitkFunctionFindWhitelists(MITK)
 
 mark_as_advanced(MITK_BUILD_ALL_APPS
                  MITK_USE_CppUnit
                  MITK_USE_GLEW
                  MITK_USE_CTK
                  MITK_USE_DCMTK
                  MITK_ENABLE_PIC_READER
                  MITK_BUILD_CONFIGURATION
                 )
 
 if(MITK_USE_Python)
   if(APPLE)
     message(WARNING "Python wrapping is unsuported on mac OSX!")
     set(MITK_USE_Python OFF CACHE BOOL "Use Python wrapping in MITK" FORCE)
   else()
     option(MITK_USE_SYSTEM_PYTHON "Use the system python runtime" OFF)
     # SimpleITK is required when python is enabled
     set(MITK_USE_SimpleITK ON CACHE BOOL "Use the SimpleITK library" FORCE)
     if(MITK_USE_SYSTEM_PYTHON)
       FIND_PACKAGE(PythonLibs REQUIRED)
       FIND_PACKAGE(PythonInterp REQUIRED)
     else()
       FIND_PACKAGE(PythonLibs)
       FIND_PACKAGE(PythonInterp)
     endif()
   endif()
 endif()
 
 if(MITK_USE_Boost)
   option(MITK_USE_SYSTEM_Boost "Use the system Boost" OFF)
   set(MITK_USE_Boost_LIBRARIES "" CACHE STRING "A semi-colon separated list of required Boost libraries")
 endif()
 
 if(MITK_USE_BLUEBERRY)
   option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
   mark_as_advanced(MITK_BUILD_ALL_PLUGINS)
 
   if(NOT MITK_USE_CTK)
     message("> Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY")
     set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE)
   endif()
 endif()
 
 if(MITK_USE_CTK AND NOT MITK_USE_DCMTK)
   message("> Forcing MITK_USE_DCMTK to ON because of MITK_USE_CTK")
   set(MITK_USE_DCMTK ON CACHE BOOL "Use DCMTK in MITK" FORCE)
 endif()
 
 if(MITK_USE_SOFA)
   # SOFA requires at least CMake 2.8.8
   set(SOFA_CMAKE_VERSION 2.8.8)
   if(${CMAKE_VERSION} VERSION_LESS ${SOFA_CMAKE_VERSION})
     set(MITK_USE_SOFA OFF CACHE BOOL "" FORCE)
     message(WARNING "Switched off MITK_USE_SOFA\n  Minimum required CMake version: ${SOFA_CMAKE_VERSION}\n  Installed CMake version: ${CMAKE_VERSION}")
   endif()
   # SOFA/ITK combination requires at least MSVC 2010
   if(MSVC_VERSION AND MSVC_VERSION LESS 1600)
     set(MITK_USE_SOFA OFF CACHE BOOL "" FORCE)
     message(WARNING "Switched off MITK_USE_SOFA\n  MSVC versions less than 2010 are not supported.")
   endif()
   # SOFA requires boost library
   if(MITK_USE_SOFA AND NOT MITK_USE_Boost)
     message("Forcing MITK_USE_Boost to ON because of MITK_USE_SOFA")
     set(MITK_USE_Boost ON CACHE BOOL "" FORCE)
   endif()
   # SOFA requires boost system library
   list(FIND MITK_USE_Boost_LIBRARIES system _result)
   if(_result LESS 0)
     message("Adding 'system' to MITK_USE_Boost_LIBRARIES.")
     list(APPEND MITK_USE_Boost_LIBRARIES system)
   endif()
   # SOFA requires boost thread library
   list(FIND MITK_USE_Boost_LIBRARIES thread _result)
   if(_result LESS 0)
     message("Adding 'thread' to MITK_USE_Boost_LIBRARIES.")
     list(APPEND MITK_USE_Boost_LIBRARIES thread)
   endif()
   # Simulation plugin requires boost chrono library
   list(FIND MITK_USE_Boost_LIBRARIES chrono _result)
   if(_result LESS 0)
     message("Adding 'chrono' to MITK_USE_Boost_LIBRARIES.")
     list(APPEND MITK_USE_Boost_LIBRARIES chrono)
   endif()
   set(MITK_USE_Boost_LIBRARIES ${MITK_USE_Boost_LIBRARIES} CACHE STRING "" FORCE)
   # Allow setting external SOFA plugins directory and SOFA plugins
   set(MITK_USE_SOFA_PLUGINS_DIR ${MITK_USE_SOFA_PLUGINS_DIR} CACHE PATH "External SOFA plugins directory" FORCE)
   set(MITK_USE_SOFA_PLUGINS ${MITK_USE_SOFA_PLUGINS} CACHE PATH "List of semicolon-separated plugin names" FORCE)
 endif()
 
 # Customize the default pixel types for multiplex macros
 
 set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
     "int, unsigned int, short, unsigned short, char, unsigned char"
     CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
     "double, float"
     CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_DIMENSIONS
     "2,3"
     CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 
 mark_as_advanced(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
                  MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
                  MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
                  MITK_ACCESSBYITK_DIMENSIONS
                 )
 
 # consistency checks
 
 if(NOT MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
       "int, unsigned int, short, unsigned short, char, unsigned char"
       CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
       "double, float"
       CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES)
   string(REPLACE "," ";" _integral_types ${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES})
   string(REPLACE "," ";" _floating_types ${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES})
   foreach(_scalar_type ${_integral_types} ${_floating_types})
     set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES
         "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}itk::VariableLengthVector<${_scalar_type}>,")
   endforeach()
   string(LENGTH "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" _length)
   math(EXPR _length "${_length} - 1")
   string(SUBSTRING "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" 0 ${_length} MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES ${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
       CACHE STRING "List of vector pixel types used in AccessByItk and InstantiateAccessFunction macros for itk::VectorImage types" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_DIMENSIONS)
   set(MITK_ACCESSBYITK_DIMENSIONS
       "2,3"
       CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 endif()
 
 #-----------------------------------------------------------------------------
 # Project.xml
 #-----------------------------------------------------------------------------
 
 # A list of topologically ordered targets
 set(CTEST_PROJECT_SUBPROJECTS)
 if(MITK_USE_BLUEBERRY)
   list(APPEND CTEST_PROJECT_SUBPROJECTS BlueBerry)
 endif()
 
 list(APPEND CTEST_PROJECT_SUBPROJECTS
   MITK-Core
   MITK-CoreUI
   MITK-IGT
   MITK-ToF
   MITK-DTI
   MITK-Registration
   MITK-Modules # all modules not contained in a specific subproject
   MITK-Plugins # all plugins not contained in a specific subproject
   MITK-Examples
   Unlabeled # special "subproject" catching all unlabeled targets and tests
   )
 
 # Configure CTestConfigSubProject.cmake that could be used by CTest scripts
 configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in
                ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake)
 
 if(CTEST_PROJECT_ADDITIONAL_TARGETS)
   # those targets will be executed at the end of the ctest driver script
   # and they also get their own subproject label
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS};${CTEST_PROJECT_ADDITIONAL_TARGETS}")
 else()
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS}")
 endif()
 
 # Generate Project.xml file expected by the CTest driver script
 mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} MITK "${subproject_list}" ${MITK_USE_SUPERBUILD})
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
 
   # Print configuration summary
   message("\n\n")
   feature_summary(
     DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
     WHAT ALL)
   return()
 endif()
 
 #*****************************************************************************
 #****************************  END OF SUPERBUILD  ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(WriteBasicConfigVersionFile)
 include(CheckCXXSourceCompiles)
 include(mitkFunctionCheckCompilerFlags)
 include(mitkFunctionGetGccVersion)
 include(MacroParseArguments)
 include(mitkFunctionSuppressWarnings) # includes several functions
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionGetVersion)
 include(mitkFunctionGetVersionDescription)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkFunctionInstallProvisioningFiles)
 include(mitkFunctionInstallAutoLoadModules)
 include(mitkFunctionGetLibrarySearchPaths)
 include(mitkFunctionCompileSnippets)
 include(mitkFunctionUseModules)
 include(mitkMacroCreateModuleConf)
 include(mitkFunctionCheckModuleDependencies)
 include(mitkFunctionCreateModule)
 include(mitkMacroCreateExecutable)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroGetLinuxDistribution)
 include(mitkMacroGetPMDPlatformString)
 
 #-----------------------------------------------------------------------------
 # Set MITK specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and mitkWorkbench
 option(MITK_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting MITK GUI Applications" ON)
 mark_as_advanced(MITK_SHOW_CONSOLE_WINDOW)
 
 # TODO: check if necessary
 option(USE_ITKZLIB "Use the ITK zlib for pic compression." ON)
 mark_as_advanced(USE_ITKZLIB)
 
 if(NOT MITK_FAST_TESTING)
   if(DEFINED MITK_CTEST_SCRIPT_MODE
       AND (MITK_CTEST_SCRIPT_MODE STREQUAL "continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "experimental") )
     set(MITK_FAST_TESTING 1)
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Get MITK version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
 mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK)
 
 #-----------------------------------------------------------------------------
 # Installation preparation
 #
 # These should be set before any MITK install macros are used
 #-----------------------------------------------------------------------------
 
 # on Mac OSX all BlueBerry plugins get copied into every
 # application bundle (.app directory) specified here
 if(MITK_USE_BLUEBERRY AND APPLE)
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
 
   foreach(mitk_app ${MITK_APPS})
     # extract option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 1 option_name)
     list(GET target_info_list 0 app_name)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} Mitk${app_name})
     endif()
   endforeach()
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Set symbol visibility Flags
 #-----------------------------------------------------------------------------
 
 # MinGW does not export all symbols automatically, so no need to set flags
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT MINGW)
   set(VISIBILITY_CXX_FLAGS ) #"-fvisibility=hidden -fvisibility-inlines-hidden")
 endif()
 
 #-----------------------------------------------------------------------------
 # Set coverage Flags
 #-----------------------------------------------------------------------------
 
 if(WITH_COVERAGE)
   if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG")
     set(COVERAGE_CXX_FLAGS ${coverage_flags})
     set(COVERAGE_C_FLAGS ${coverage_flags})
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK C/CXX Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_C_FLAGS "${COVERAGE_C_FLAGS}")
 set(MITK_C_FLAGS_DEBUG )
 set(MITK_C_FLAGS_RELEASE )
 set(MITK_CXX_FLAGS "${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS}")
 set(MITK_CXX_FLAGS_DEBUG )
 set(MITK_CXX_FLAGS_RELEASE )
 
 set(MITK_EXE_LINKER_FLAGS )
 set(MITK_SHARED_LINKER_FLAGS )
 
 if(WIN32)
   set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -D_WIN32_WINNT=0x0501 -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN -DNOMINMAX")
   mitkFunctionCheckCompilerFlags("/wd4005" MITK_CXX_FLAGS) # warning C4005: macro redefinition
   mitkFunctionCheckCompilerFlags("/wd4231" MITK_CXX_FLAGS) # warning C4231: nonstandard extension used : 'extern' before template explicit instantiation
   # the following line should be removed after fixing bug 17637
   mitkFunctionCheckCompilerFlags("/wd4316" MITK_CXX_FLAGS) # warning C4316: object alignment on heap
 endif()
 
 if(NOT MSVC_VERSION)
   foreach(_flag
     -Wall
     -Wextra
     -Wpointer-arith
     -Winvalid-pch
     -Wcast-align
     -Wwrite-strings
     -Wno-error=gnu
     -Wno-error=unknown-pragmas
     # The strict-overflow warning is generated by ITK template code
     -Wno-error=strict-overflow
     -Woverloaded-virtual
     -Wstrict-null-sentinel
     #-Wold-style-cast
     #-Wsign-promo
 
     # the following two lines should be removed after ITK-3097 has
     # been resolved, see also MITK bug 15279
     -Wno-unused-local-typedefs
     -Wno-array-bounds
 
     -fdiagnostics-show-option
     )
     mitkFunctionCheckCAndCXXCompilerFlags(${_flag} MITK_C_FLAGS MITK_CXX_FLAGS)
   endforeach()
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)
   mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" MITK_SHARED_LINKER_FLAGS)
   mitkFunctionCheckCompilerFlags("-Wl,--as-needed" MITK_SHARED_LINKER_FLAGS)
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
 
   mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
   # With older version of gcc supporting the flag -fstack-protector-all, an extra dependency to libssp.so
   # is introduced. If gcc is smaller than 4.4.0 and the build type is Release let's not include the flag.
   # Doing so should allow to build package made for distribution using older linux distro.
   if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
     mitkFunctionCheckCAndCXXCompilerFlags("-fstack-protector-all" MITK_C_FLAGS MITK_CXX_FLAGS)
   endif()
   if(MINGW)
     # suppress warnings about auto imported symbols
     set(MITK_SHARED_LINKER_FLAGS "-Wl,--enable-auto-import ${MITK_SHARED_LINKER_FLAGS}")
   endif()
 
   set(MITK_CXX_FLAGS_RELEASE "-D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}")
 
 endif()
 
 set(MITK_MODULE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
 set(MITK_EXE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
 
 #-----------------------------------------------------------------------------
 # MITK Packages
 #-----------------------------------------------------------------------------
 
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   enable_testing()
   include(CTest)
   mark_as_advanced(TCL_TCLSH DART_ROOT)
 
   option(MITK_ENABLE_RENDERING_TESTING OFF "Enable the MITK rendering tests. Requires x-server in Linux.")
   #Rendering testing does not work for Linux nightlies, thus it is disabled per default
   #and activated for Mac and Windows.
   if(WIN32 OR APPLE)
     set(MITK_ENABLE_RENDERING_TESTING ON)
   endif()
   mark_as_advanced( MITK_ENABLE_RENDERING_TESTING )
 
   # Setup file for setting custom ctest vars
   configure_file(
     CMake/CTestCustom.cmake.in
     ${MITK_BINARY_DIR}/CTestCustom.cmake
     @ONLY
     )
 
   # Configuration for the CMake-generated test driver
   set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include <stdexcept>")
   set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "
     try
       {")
   set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "    }
       catch( std::exception & excp )
         {
         fprintf(stderr,\"%s\\n\",excp.what());
         return EXIT_FAILURE;
         }
       catch( ... )
         {
         printf(\"Exception caught in the test driver\\n\");
         return EXIT_FAILURE;
         }
       ")
 
   set(MITK_TEST_OUTPUT_DIR "${MITK_BINARY_DIR}/test_output")
   if(NOT EXISTS ${MITK_TEST_OUTPUT_DIR})
     file(MAKE_DIRECTORY ${MITK_TEST_OUTPUT_DIR})
   endif()
 
   # Test the external project template
   if(MITK_USE_BLUEBERRY)
     include(mitkTestProjectTemplate)
   endif()
 
   # Test the package target
   include(mitkPackageTest)
 endif()
 
 configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h)
 
 #-----------------------------------------------------------------------------
 # MITK_SUPERBUILD_BINARY_DIR
 #-----------------------------------------------------------------------------
 
 # If MITK_SUPERBUILD_BINARY_DIR isn't defined, it means MITK is *NOT* build using Superbuild.
 # In that specific case, MITK_SUPERBUILD_BINARY_DIR should default to MITK_BINARY_DIR
 if(NOT DEFINED MITK_SUPERBUILD_BINARY_DIR)
   set(MITK_SUPERBUILD_BINARY_DIR ${MITK_BINARY_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # Compile Utilities and set-up MITK variables
 #-----------------------------------------------------------------------------
 
 include(mitkSetupVariables)
 
   #-----------------------------------------------------------------------------
   # Cleanup
   #-----------------------------------------------------------------------------
 
   file(GLOB _MODULES_CONF_FILES ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}/*.cmake)
   if(_MODULES_CONF_FILES)
     file(REMOVE ${_MODULES_CONF_FILES})
   endif()
 
 add_subdirectory(Utilities)
 
 if(MITK_USE_BLUEBERRY)
 
   # We need to hack a little bit because MITK applications may need
   # to enable certain BlueBerry plug-ins. However, these plug-ins
   # are validated separately from the MITK plug-ins and know nothing
   # about potential MITK plug-in dependencies of the applications. Hence
   # we cannot pass the MITK application list to the BlueBerry
   # ctkMacroSetupPlugins call but need to extract the BlueBerry dependencies
   # from the applications and set them explicitly.
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
 
   foreach(mitk_app ${MITK_APPS})
     # extract target_dir and option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 0 target_dir)
     list(GET target_info_list 1 option_name)
     # check if the application is enabled and if target_libraries.cmake exists
     if((${option_name} OR MITK_BUILD_ALL_APPS) AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
       include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
       foreach(_target_dep ${target_libraries})
         if(_target_dep MATCHES org_blueberry_)
           string(REPLACE _ . _app_bb_dep ${_target_dep})
           # explicitly set the build option for the BlueBerry plug-in
           set(BLUEBERRY_BUILD_${_app_bb_dep} ON CACHE BOOL "Build the ${_app_bb_dep} plug-in")
         endif()
       endforeach()
     endif()
   endforeach()
 
   set(mbilog_DIR "${mbilog_BINARY_DIR}")
 
   if(MITK_BUILD_ALL_PLUGINS)
     set(BLUEBERRY_BUILD_ALL_PLUGINS ON)
   endif()
 
   set(BLUEBERRY_XPDOC_OUTPUT_DIR ${MITK_DOXYGEN_OUTPUT_DIR}/html/extension-points/html/)
 
   add_subdirectory(BlueBerry)
 
   set(BlueBerry_DIR ${CMAKE_CURRENT_BINARY_DIR}/BlueBerry
       CACHE PATH "The directory containing a CMake configuration file for BlueBerry" FORCE)
 
   include(mitkMacroCreateCTKPlugin)
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Set C/CXX and linker flags for MITK code
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${MITK_CXX_FLAGS_DEBUG}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MITK_CXX_FLAGS_RELEASE}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}")
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${MITK_C_FLAGS_DEBUG}")
 set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${MITK_C_FLAGS_RELEASE}")
 
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MITK_EXE_LINKER_FLAGS}")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MITK_SHARED_LINKER_FLAGS}")
 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MITK_MODULE_LINKER_FLAGS}")
 
 #-----------------------------------------------------------------------------
 # Add custom targets representing CDash subprojects
 #-----------------------------------------------------------------------------
 
 foreach(subproject ${CTEST_PROJECT_SUBPROJECTS})
   if(NOT TARGET ${subproject} AND NOT subproject MATCHES "Unlabeled")
     add_custom_target(${subproject})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Core)
 
 add_subdirectory(Modules)
 
 if(MITK_USE_BLUEBERRY)
 
   find_package(BlueBerry REQUIRED)
 
   set(MITK_DEFAULT_SUBPROJECTS MITK-Plugins)
 
   # Plug-in testing (needs some work to be enabled again)
   if(BUILD_TESTING)
     include(berryTestingHelpers)
 
     set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp")
     if(TARGET CoreApp)
       get_target_property(_is_macosx_bundle CoreApp MACOSX_BUNDLE)
       if(APPLE AND _is_macosx_bundle)
         set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp")
       endif()
     endif()
     set(BLUEBERRY_TEST_APP_ID "org.mitk.qt.coreapplication")
   endif()
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake")
   mitkFunctionWhitelistPlugins(MITK MITK_EXT_PLUGINS)
 
   set(mitk_plugins_fullpath "")
   foreach(mitk_plugin ${MITK_EXT_PLUGINS})
     list(APPEND mitk_plugins_fullpath Plugins/${mitk_plugin})
   endforeach()
 
   if(EXISTS ${MITK_PRIVATE_MODULES}/PluginList.cmake)
     include(${MITK_PRIVATE_MODULES}/PluginList.cmake)
 
     foreach(mitk_plugin ${MITK_PRIVATE_PLUGINS})
       list(APPEND mitk_plugins_fullpath ${MITK_PRIVATE_MODULES}/${mitk_plugin})
     endforeach()
   endif()
 
   if(MITK_BUILD_EXAMPLES)
     include("${CMAKE_CURRENT_SOURCE_DIR}/Examples/Plugins/PluginList.cmake")
     set(mitk_example_plugins_fullpath )
     foreach(mitk_example_plugin ${MITK_EXAMPLE_PLUGINS})
       list(APPEND mitk_example_plugins_fullpath Examples/Plugins/${mitk_example_plugin})
       list(APPEND mitk_plugins_fullpath Examples/Plugins/${mitk_example_plugin})
     endforeach()
   endif()
 
   # Specify which plug-ins belong to this project
   macro(GetMyTargetLibraries all_target_libraries varname)
     set(re_ctkplugin_mitk "^org_mitk_[a-zA-Z0-9_]+$")
     set(re_ctkplugin_bb "^org_blueberry_[a-zA-Z0-9_]+$")
     set(_tmp_list)
     list(APPEND _tmp_list ${all_target_libraries})
     ctkMacroListFilter(_tmp_list re_ctkplugin_mitk re_ctkplugin_bb OUTPUT_VARIABLE ${varname})
   endmacro()
 
   # Get infos about application directories and build options
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
   set(mitk_apps_fullpath )
   foreach(mitk_app ${MITK_APPS})
     string(FIND ${mitk_app} "MITK_BUILD_APP_" _index)
     string(SUBSTRING ${mitk_app} ${_index} -1 _var)
     if(${_var})
       list(APPEND mitk_apps_fullpath "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${mitk_app}")
     endif()
   endforeach()
 
   if (mitk_plugins_fullpath)
     ctkMacroSetupPlugins(${mitk_plugins_fullpath}
                          BUILD_OPTION_PREFIX MITK_BUILD_
                          APPS ${mitk_apps_fullpath}
                          BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
                          COMPACT_OPTIONS)
   endif()
 
   set(MITK_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkPluginUseFile.cmake")
   if(${PROJECT_NAME}_PLUGIN_LIBRARIES)
     ctkFunctionGeneratePluginUseFile(${MITK_PLUGIN_USE_FILE})
   else()
     file(REMOVE ${MITK_PLUGIN_USE_FILE})
     set(MITK_PLUGIN_USE_FILE )
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Documentation)
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 
 # set MITK cpack variables
 # These are the default variables, which can be overwritten ( see below )
 include(mitkSetupCPack)
 
 set(use_default_config ON)
 
 # MITK_APPS is set in Applications/AppList.cmake (included somewhere above
 # if MITK_USE_BLUEBERRY is set to ON).
 if(MITK_APPS)
 
   set(activated_apps_no 0)
   list(LENGTH MITK_APPS app_count)
 
   # Check how many apps have been enabled
   # If more than one app has been activated, the we use the
   # default CPack configuration. Otherwise that apps configuration
   # will be used, if present.
   foreach(mitk_app ${MITK_APPS})
     # extract option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 1 option_name)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       MATH(EXPR activated_apps_no "${activated_apps_no} + 1")
     endif()
   endforeach()
 
   if(app_count EQUAL 1 AND (activated_apps_no EQUAL 1 OR MITK_BUILD_ALL_APPS))
     # Corner case if there is only one app in total
     set(use_project_cpack ON)
   elseif(activated_apps_no EQUAL 1 AND NOT MITK_BUILD_ALL_APPS)
     # Only one app is enabled (no "build all" flag set)
     set(use_project_cpack ON)
   else()
     # Less or more then one app is enabled
     set(use_project_cpack OFF)
   endif()
 
   foreach(mitk_app ${MITK_APPS})
     # extract target_dir and option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 0 target_dir)
     list(GET target_info_list 1 option_name)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       # check whether application specific configuration files will be used
       if(use_project_cpack)
         # use files if they exist
         if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
           include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
         endif()
 
         if(EXISTS "${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in")
           set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/Applications/${target_dir}/CPackConfig.cmake")
           configure_file(${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in
                          ${CPACK_PROJECT_CONFIG_FILE} @ONLY)
           set(use_default_config OFF)
         endif()
       endif()
     # add link to the list
     list(APPEND CPACK_CREATE_DESKTOP_LINKS "${target_dir}")
     endif()
   endforeach()
 
 endif()
 
 # if no application specific configuration file was used, use default
 if(use_default_config)
   configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
                  ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY)
   set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake")
 endif()
 
 # include CPack model once all variables are set
 include(CPack)
 
 # Additional installation rules
 include(mitkInstallRules)
 
 #-----------------------------------------------------------------------------
 # Last configuration steps
 #-----------------------------------------------------------------------------
 
 set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
 file(REMOVE ${MITK_EXPORTS_FILE})
 
 set(targets_to_export)
 get_property(module_targets GLOBAL PROPERTY MITK_MODULE_TARGETS)
 if(module_targets)
   list(APPEND targets_to_export ${module_targets})
 endif()
 
 if(MITK_USE_BLUEBERRY)
   if(MITK_PLUGIN_LIBRARIES)
     list(APPEND targets_to_export ${MITK_PLUGIN_LIBRARIES})
   endif()
 endif()
 
 export(TARGETS ${targets_to_export} APPEND
        FILE ${MITK_EXPORTS_FILE})
 
 set(MITK_EXPORTED_TARGET_PROPERTIES )
 foreach(target_to_export ${targets_to_export})
   get_target_property(autoload_targets ${target_to_export} MITK_AUTOLOAD_TARGETS)
   if(autoload_targets)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_TARGETS \"${autoload_targets}\")")
   endif()
   get_target_property(autoload_dir ${target_to_export} MITK_AUTOLOAD_DIRECTORY)
   if(autoload_dir)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_DIRECTORY \"${autoload_dir}\")")
   endif()
 endforeach()
 
 get_property(MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS_CONFIG GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
 
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY)
 
 set(VISIBILITY_AVAILABLE 0)
 set(visibility_test_flag "")
 mitkFunctionCheckCompilerFlags("-fvisibility=hidden" visibility_test_flag)
 if(visibility_test_flag)
   # The compiler understands -fvisiblity=hidden (probably gcc >= 4 or Clang)
   set(VISIBILITY_AVAILABLE 1)
 endif()
 configure_file(mitkExportMacros.h.in ${MITK_BINARY_DIR}/mitkExportMacros.h)
 
 configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 
 set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc)
 set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities)
 
 file(GLOB _MODULES_CONF_FILES RELATIVE ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME} ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}/*.cmake)
 set(MITK_MODULE_NAMES)
 foreach(_module ${_MODULES_CONF_FILES})
   string(REPLACE Config.cmake "" _module_name ${_module})
   list(APPEND MITK_MODULE_NAMES ${_module_name})
 endforeach()
 
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
 
 write_basic_config_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
   VERSION ${MITK_VERSION_STRING} COMPATIBILITY AnyNewerVersion)
 
 # If we are under Windows, create two batch files which correctly
 # set up the environment for the application and for Visual Studio
 if(WIN32)
   include(mitkFunctionCreateWindowsBatchScript)
 
   set(VS_SOLUTION_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln")
   foreach(VS_BUILD_TYPE debug release)
     mitkFunctionCreateWindowsBatchScript("${MITK_SOURCE_DIR}/CMake/StartVS.bat.in"
       ${PROJECT_BINARY_DIR}/StartVS_${VS_BUILD_TYPE}.bat
       ${VS_BUILD_TYPE})
   endforeach()
 endif(WIN32)
 
 
 #-----------------------------------------------------------------------------
 # MITK Applications
 #-----------------------------------------------------------------------------
 
 # This must come after MITKConfig.h was generated, since applications
 # might do a find_package(MITK REQUIRED).
 add_subdirectory(Applications)
 
 #-----------------------------------------------------------------------------
 # MITK Examples
 #-----------------------------------------------------------------------------
 
 if(MITK_BUILD_EXAMPLES)
   # This must come after MITKConfig.h was generated, since applications
   # might do a find_package(MITK REQUIRED).
   add_subdirectory(Examples)
 endif()
 
 #-----------------------------------------------------------------------------
 # Print configuration summary
 #-----------------------------------------------------------------------------
 
 message("\n\n")
 feature_summary(
   DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
   WHAT ALL
 )
 
diff --git a/Modules/ModuleList.cmake b/Modules/ModuleList.cmake
index 73d55f62c4..20fbfb8dae 100644
--- a/Modules/ModuleList.cmake
+++ b/Modules/ModuleList.cmake
@@ -1,60 +1,61 @@
 set(mitk_modules
+  RDF
   LegacyIO
   DataTypesExt
   Overlays
   LegacyGL
   AlgorithmsExt
   MapperExt
   DICOMReader
   DICOMTesting
   Qt4Qt5TestModule
   SceneSerializationBase
   PlanarFigure
   ImageDenoising
   ImageExtraction
   ImageStatistics
   LegacyAdaptors
   SceneSerialization
   GraphAlgorithms
   ContourModel
   SurfaceInterpolation
   Segmentation
   PlanarFigureSegmentation
   OpenViewCore
   QmlItems
   QtWidgets
   QtWidgetsExt
   SegmentationUI
   DiffusionImaging
   GPGPU
   IGTBase
   IGT
   CameraCalibration
   RigidRegistration
   RigidRegistrationUI
   DeformableRegistration
   DeformableRegistrationUI
   OpenCL
   OpenCVVideoSupport
   QtOverlays
   InputDevices
   ToFHardware
   ToFProcessing
   ToFUI
   US
   USUI
   DicomUI
   Simulation
   Remeshing
   Python
   Persistence
   IGTUI
   VtkShaders
   DicomRT
   IOExt
   XNAT
 )
 
 if(MITK_ENABLE_PIC_READER)
   list(APPEND mitk_modules IpPicSupportIO)
 endif()
diff --git a/Modules/RDF/CMakeLists.txt b/Modules/RDF/CMakeLists.txt
new file mode 100644
index 0000000000..56363dc4b6
--- /dev/null
+++ b/Modules/RDF/CMakeLists.txt
@@ -0,0 +1,6 @@
+mitk_create_module(PACKAGE_DEPENDS Redland
+                   WARNINGS_AS_ERRORS
+                  )
+
+add_subdirectory(Testing)
+
diff --git a/Modules/RDF/Documentation/Doxygen/Modules.dox b/Modules/RDF/Documentation/Doxygen/Modules.dox
new file mode 100644
index 0000000000..bffddac499
--- /dev/null
+++ b/Modules/RDF/Documentation/Doxygen/Modules.dox
@@ -0,0 +1,8 @@
+/**
+  \defgroup MitkRDFModule MitkRDF
+  \ingroup MITKModules
+
+  \brief MITK RDF Library
+
+  This module provides classes to work with RDF concepts and data formats.
+*/
diff --git a/Modules/RDF/Testing/CMakeLists.txt b/Modules/RDF/Testing/CMakeLists.txt
new file mode 100644
index 0000000000..42638c56cd
--- /dev/null
+++ b/Modules/RDF/Testing/CMakeLists.txt
@@ -0,0 +1 @@
+mitk_create_module_tests()
diff --git a/Modules/RDF/Testing/files.cmake b/Modules/RDF/Testing/files.cmake
new file mode 100644
index 0000000000..686370ac21
--- /dev/null
+++ b/Modules/RDF/Testing/files.cmake
@@ -0,0 +1,7 @@
+# tests with no extra command line parameter
+set(MODULE_TESTS
+  mitkRdfNodeTest.cpp
+)
+
+set(RESOURCE_FILES
+)
diff --git a/Modules/RDF/Testing/mitkRdfNodeTest.cpp b/Modules/RDF/Testing/mitkRdfNodeTest.cpp
new file mode 100644
index 0000000000..c34ebd8a30
--- /dev/null
+++ b/Modules/RDF/Testing/mitkRdfNodeTest.cpp
@@ -0,0 +1,52 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkTestingMacros.h"
+#include <mitkTestingConfig.h>
+#include <mitkTestFixture.h>
+
+#include "mitkRdfNode.h"
+
+class mitkRdfNodeTestSuite : public mitk::TestFixture
+{
+  // List of Tests
+  CPPUNIT_TEST_SUITE(mitkRdfNodeTestSuite);
+
+  MITK_TEST(TestDummy);
+
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+  void setUp()
+  {
+  }
+
+  void tearDown()
+  {
+  }
+
+  // Test functions
+
+  void TestDummy()
+  {
+    mitk::RdfNode node;
+    CPPUNIT_ASSERT(node.dummy() == true);
+  }
+
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkRdfNode)
diff --git a/Modules/RDF/files.cmake b/Modules/RDF/files.cmake
new file mode 100644
index 0000000000..4fd8b64962
--- /dev/null
+++ b/Modules/RDF/files.cmake
@@ -0,0 +1,3 @@
+set(CPP_FILES
+  mitkRdfNode.cpp
+)
diff --git a/Modules/RDF/mitkRdfNode.cpp b/Modules/RDF/mitkRdfNode.cpp
new file mode 100644
index 0000000000..73563bcbe9
--- /dev/null
+++ b/Modules/RDF/mitkRdfNode.cpp
@@ -0,0 +1,68 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkRdfNode.h"
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include <redland.h>
+
+namespace mitk {
+
+bool RdfNode::dummy()
+{
+  librdf_world* world;
+  librdf_storage *storage;
+  librdf_model* model;
+  librdf_statement* statement;
+  raptor_world *raptor_world_ptr;
+  raptor_iostream* iostr;
+  
+  world=librdf_new_world();
+  librdf_world_open(world);
+  raptor_world_ptr = librdf_world_get_raptor(world);
+
+  model=librdf_new_model(world, storage=librdf_new_storage(world, "hashes", NULL, "hash-type='memory'"), NULL);
+
+  librdf_model_add_statement(model, 
+                             statement=librdf_new_statement_from_nodes(world, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://www.dajobe.org/"),
+                                                             librdf_new_node_from_uri_string(world, (const unsigned char*)"http://purl.org/dc/elements/1.1/creator"),
+                                                             librdf_new_node_from_literal(world, (const unsigned char*)"Dave Beckett", NULL, 0)
+                                                             )
+                             );
+
+  librdf_free_statement(statement);
+
+  iostr = raptor_new_iostream_to_file_handle(raptor_world_ptr, stdout);
+  librdf_model_write(model, iostr);
+  raptor_free_iostream(iostr);
+  
+  librdf_free_model(model);
+  librdf_free_storage(storage);
+
+  librdf_free_world(world);
+
+#ifdef LIBRDF_MEMORY_DEBUG
+  librdf_memory_report(stderr);
+#endif
+
+  return true;
+}
+
+}
diff --git a/Modules/RDF/mitkRdfNode.h b/Modules/RDF/mitkRdfNode.h
new file mode 100644
index 0000000000..83d8d99678
--- /dev/null
+++ b/Modules/RDF/mitkRdfNode.h
@@ -0,0 +1,39 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+
+#ifndef MITKRDFNODE_H
+#define MITKRDFNODE_H
+
+#include <MitkRDFExports.h>
+
+namespace mitk {
+
+/**
+ * \ingroup MitkRDFModule
+ */
+class MitkRDF_EXPORT RdfNode
+{
+
+public:
+
+  bool dummy();
+
+};
+
+}
+
+#endif
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index f5c8650b5a..ce6ba9a0cb 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,491 +1,527 @@
 
 #-----------------------------------------------------------------------------
 # Convenient macro allowing to download a file
 #-----------------------------------------------------------------------------
 
+if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL)
+  set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty)
+endif()
+
 macro(downloadFile url dest)
   file(DOWNLOAD ${url} ${dest} STATUS status)
   list(GET status 0 error_code)
   list(GET status 1 error_msg)
   if(error_code)
     message(FATAL_ERROR "error: Failed to download ${url} - ${error_msg}")
   endif()
 endmacro()
 
 #-----------------------------------------------------------------------------
 # MITK Prerequisites
 #-----------------------------------------------------------------------------
 
 if(UNIX AND NOT APPLE)
 
   include(mitkFunctionCheckPackageHeader)
 
   # Check for libxt-dev
   mitkFunctionCheckPackageHeader(StringDefs.h libxt-dev /usr/include/X11/)
 
   # Check for libtiff4-dev
   mitkFunctionCheckPackageHeader(tiff.h libtiff4-dev)
 
   # Check for libwrap0-dev
   mitkFunctionCheckPackageHeader(tcpd.h libwrap0-dev)
 
 endif()
 
+# We need a proper patch program. On Linux and MacOS, we assume
+# that "patch" is available. On Windows, we download patch.exe
+# if not patch program is found.
+find_program(PATCH_COMMAND patch)
+if((NOT PATCH_COMMAND OR NOT EXISTS ${PATCH_COMMAND}) AND WIN32)
+  downloadFile(${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/patch.exe
+               ${CMAKE_CURRENT_BINARY_DIR}/patch.exe)
+  find_program(PATCH_COMMAND patch ${CMAKE_CURRENT_BINARY_DIR})
+endif()
+if(NOT PATCH_COMMAND)
+  message(FATAL_ERROR "No patch program found.")
+endif()
+
 #-----------------------------------------------------------------------------
 # Qt options for external projects and MITK
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_QT)
   set(qt_project_args -DDESIRED_QT_VERSION:STRING=${DESIRED_QT_VERSION})
 else()
   set(qt_project_args )
 endif()
 
 if(MITK_USE_Qt4)
   list(APPEND qt_project_args
        -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} )
 endif()
 
 #-----------------------------------------------------------------------------
 # ExternalProjects
 #-----------------------------------------------------------------------------
 
 # These are ordered by dependencies
 set(external_projects
   ZLIB
   Python
   Numpy
   tinyxml
   GLUT
   ANN
   CppUnit
   GLEW
   VTK
   ACVD
   GDCM
   OpenCV
   Poco
   ITK
   Boost
   DCMTK
   CTK
   SOFA
   MITKData
   Qwt
   PCRE
   Swig
   SimpleITK
   Eigen
+  raptor2
+  rasqal
+  redland
   )
 
 # These are "hard" dependencies and always set to ON
 set(MITK_USE_tinyxml 1)
 set(MITK_USE_GLEW 1)
 set(MITK_USE_GDCM 1)
 set(MITK_USE_ITK 1)
 set(MITK_USE_VTK 1)
 
 # Semi-hard dependencies, enabled by user-controlled variables
 if(MITK_USE_QT)
   set(MITK_USE_Qwt 1)
 endif()
 
+if(MITK_USE_Redland)
+  set(REDLAND_INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/Redland-install)
+  set(MITK_USE_raptor2 1)
+  set(MITK_USE_PCRE 1)
+  set(MITK_USE_rasqal 1)
+  set(MITK_USE_redland 1)
+endif()
+
 if(MITK_USE_SOFA)
   set(MITK_USE_GLUT 1)
 endif()
 
 if(NOT MITK_USE_SYSTEM_PYTHON)
   set(MITK_USE_ZLIB 1)
 endif()
 
 if(MITK_USE_SimpleITK OR MITK_USE_Python)
   set(MITK_USE_SWIG 1)
   if(UNIX)
     set(MITK_USE_PCRE 1)
   endif()
 endif()
 
 # A list of "nice" external projects, playing well together with CMake
 set(nice_external_projects ${external_projects})
 list(REMOVE_ITEM nice_external_projects Boost)
 foreach(proj ${nice_external_projects})
   if(MITK_USE_${proj})
     set(EXTERNAL_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory")
     mark_as_advanced(EXTERNAL_${proj}_DIR)
     if(EXTERNAL_${proj}_DIR)
       set(${proj}_DIR ${EXTERNAL_${proj}_DIR})
     endif()
   endif()
 endforeach()
 
 if(MITK_USE_Boost)
   set(EXTERNAL_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory")
   mark_as_advanced(EXTERNAL_BOOST_ROOT)
   if(EXTERNAL_BOOST_ROOT)
     set(BOOST_ROOT ${EXTERNAL_BOOST_ROOT})
   endif()
 endif()
 
 # Setup file for setting custom ctest vars
 configure_file(
   CMake/SuperbuildCTestCustom.cmake.in
   ${MITK_BINARY_DIR}/CTestCustom.cmake
   @ONLY
 )
 
 if(BUILD_TESTING)
   set(EXTERNAL_MITK_DATA_DIR "${MITK_DATA_DIR}" CACHE PATH "Path to the MITK data directory")
   mark_as_advanced(EXTERNAL_MITK_DATA_DIR)
   if(EXTERNAL_MITK_DATA_DIR)
     set(MITK_DATA_DIR ${EXTERNAL_MITK_DATA_DIR})
   endif()
 endif()
 
 # Look for git early on, if needed
 if((BUILD_TESTING AND NOT EXTERNAL_MITK_DATA_DIR) OR
    (MITK_USE_CTK AND NOT EXTERNAL_CTK_DIR))
   find_package(Git REQUIRED)
 endif()
 
 #-----------------------------------------------------------------------------
 # External project settings
 #-----------------------------------------------------------------------------
 
 include(ExternalProject)
 
 set(ep_base "${CMAKE_BINARY_DIR}/CMakeExternals")
 set_property(DIRECTORY PROPERTY EP_BASE ${ep_base})
 
 set(ep_install_dir ${ep_base}/Install)
 #set(ep_build_dir ${ep_base}/Build)
 set(ep_source_dir ${ep_base}/Source)
 #set(ep_parallelism_level)
 set(ep_build_shared_libs ON)
 set(ep_build_testing OFF)
 
-if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL)
-  set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty)
-endif()
-
 # Compute -G arg for configuring external projects with the same CMake generator:
 if(CMAKE_EXTRA_GENERATOR)
   set(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
 else()
   set(gen "${CMAKE_GENERATOR}")
 endif()
 
 # Use this value where semi-colons are needed in ep_add args:
 set(sep "^^")
 
 ##
 
 if(MSVC_VERSION)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
 endif()
 
 set(ep_common_args
   -DBUILD_TESTING:BOOL=${ep_build_testing}
   -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
   -DCMAKE_PREFIX_PATH:PATH=${CMAKE_PREFIX_PATH}
   -DBUILD_SHARED_LIBS:BOOL=ON
   -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
   -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
   -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
   -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
   -DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS}
   #debug flags
   -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
   -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
   #release flags
   -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
   -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
   #relwithdebinfo
   -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
   -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
   #link flags
   -DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
   -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS}
   -DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS}
 )
 
 # Pass the CMAKE_OSX variables to external projects
 if(APPLE)
   set(MAC_OSX_ARCHITECTURE_ARGS
         -DCMAKE_OSX_ARCHITECTURES:PATH=${CMAKE_OSX_ARCHITECTURES}
         -DCMAKE_OSX_DEPLOYMENT_TARGET:PATH=${CMAKE_OSX_DEPLOYMENT_TARGET}
         -DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT}
   )
   set(ep_common_args
         ${MAC_OSX_ARCHITECTURE_ARGS}
         ${ep_common_args}
   )
 endif()
 
 # Include external projects
 foreach(p ${external_projects})
   include(CMakeExternals/${p}.cmake)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Set superbuild boolean args
 #-----------------------------------------------------------------------------
 
 set(mitk_cmake_boolean_args
   BUILD_SHARED_LIBS
   WITH_COVERAGE
   BUILD_TESTING
 
   MITK_USE_QT
   MITK_BUILD_ALL_PLUGINS
   MITK_BUILD_ALL_APPS
   MITK_BUILD_TUTORIAL # Deprecated. Use MITK_BUILD_EXAMPLES instead
   MITK_BUILD_EXAMPLES
 
   MITK_USE_ACVD
   MITK_USE_ANN
   MITK_USE_BLUEBERRY
   MITK_USE_Boost
   MITK_USE_CppUnit
   MITK_USE_CTK
   MITK_USE_DCMTK
   MITK_USE_Eigen
   MITK_USE_GLEW
   MITK_USE_OpenCL
   MITK_USE_OpenCV
   MITK_USE_Poco
   MITK_USE_Python
+  MITK_USE_Redland
   MITK_USE_SOFA
   MITK_USE_SYSTEM_Boost
 
   MITK_ENABLE_PIC_READER
   )
 
 #-----------------------------------------------------------------------------
 # Create the final variable containing superbuild boolean args
 #-----------------------------------------------------------------------------
 
 set(mitk_superbuild_boolean_args)
 foreach(mitk_cmake_arg ${mitk_cmake_boolean_args})
   list(APPEND mitk_superbuild_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}})
 endforeach()
 
 if(MITK_BUILD_ALL_PLUGINS)
   list(APPEND mitk_superbuild_boolean_args -DBLUEBERRY_BUILD_ALL_PLUGINS:BOOL=ON)
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK Utilities
 #-----------------------------------------------------------------------------
 
 set(proj MITK-Utilities)
 ExternalProject_Add(${proj}
   DOWNLOAD_COMMAND ""
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     # Mandatory dependencies
     ${tinyxml_DEPENDS}
     ${ANN_DEPENDS}
     ${VTK_DEPENDS}
     ${ITK_DEPENDS}
     # Optionnal dependencies
     ${ACVD_DEPENDS}
     ${CppUnit_DEPENDS}
     ${Eigen_DEPENDS}
     ${GLUT_DEPENDS}
     ${GLEW_DEPENDS}
     ${Boost_DEPENDS}
     ${CTK_DEPENDS}
     ${DCMTK_DEPENDS}
     ${OpenCV_DEPENDS}
     ${Poco_DEPENDS}
+    ${PCRE_DEPENDS}
+    ${Swig_DEPENDS}
+    ${raptor2_DEPENDS}
+    ${rasqal_DEPENDS}
+    ${redland_DEPENDS}
     ${SOFA_DEPENDS}
     ${MITK-Data_DEPENDS}
     ${Qwt_DEPENDS}
     ${ZLIB_DEPENDS}
     ${SimpleITK_DEPENDS}
     ${Numpy_DEPENDS}
 )
 #-----------------------------------------------------------------------------
 # Additional MITK CXX/C Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags for MITK")
 set(MITK_ADDITIONAL_C_FLAGS_RELEASE "" CACHE STRING "Additional Release C Flags for MITK")
 set(MITK_ADDITIONAL_C_FLAGS_DEBUG "" CACHE STRING "Additional Debug C Flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_C_FLAGS MITK_ADDITIONAL_C_FLAGS_DEBUG MITK_ADDITIONAL_C_FLAGS_RELEASE)
 
 set(MITK_ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags for MITK")
 set(MITK_ADDITIONAL_CXX_FLAGS_RELEASE "" CACHE STRING "Additional Release CXX Flags for MITK")
 set(MITK_ADDITIONAL_CXX_FLAGS_DEBUG "" CACHE STRING "Additional Debug CXX Flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_CXX_FLAGS MITK_ADDITIONAL_CXX_FLAGS_DEBUG MITK_ADDITIONAL_CXX_FLAGS_RELEASE)
 
 set(MITK_ADDITIONAL_EXE_LINKER_FLAGS "" CACHE STRING "Additional exe linker flags for MITK")
 set(MITK_ADDITIONAL_SHARED_LINKER_FLAGS "" CACHE STRING "Additional shared linker flags for MITK")
 set(MITK_ADDITIONAL_MODULE_LINKER_FLAGS "" CACHE STRING "Additional module linker flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_EXE_LINKER_FLAGS MITK_ADDITIONAL_SHARED_LINKER_FLAGS MITK_ADDITIONAL_MODULE_LINKER_FLAGS)
 
 #-----------------------------------------------------------------------------
 # MITK Configure
 #-----------------------------------------------------------------------------
 
 if(MITK_INITIAL_CACHE_FILE)
   set(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}")
 endif()
 
 set(mitk_optional_cache_args )
 foreach(type RUNTIME ARCHIVE LIBRARY)
   if(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
     list(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
   endif()
 endforeach()
 
 # Optional python variables
 if(MITK_USE_Python)
   list(APPEND mitk_optional_cache_args
        -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
        -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
        -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
        -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
        -DMITK_USE_SYSTEM_PYTHON:BOOL=${MITK_USE_SYSTEM_PYTHON}
       )
   if( NOT MITK_USE_SYSTEM_PYTHON )
     list(APPEND mitk_optional_cache_args
           # Folders are needed to create an installer
           -DPython_DIR:PATH=${Python_DIR}
           -DNumpy_DIR:PATH=${Numpy_DIR}
         )
   endif()
 endif()
 
 if(MITK_USE_QT)
   if(DESIRED_QT_VERSION MATCHES "5")
     list(APPEND mitk_optional_cache_args
       -DQT5_INSTALL_PREFIX:PATH=${QT5_INSTALL_PREFIX}
     )
   endif()
 endif()
 
 set(proj MITK-Configure)
 
 ExternalProject_Add(${proj}
   LIST_SEPARATOR ^^
   DOWNLOAD_COMMAND ""
   CMAKE_GENERATOR ${gen}
   CMAKE_CACHE_ARGS
     # --------------- Build options ----------------
     -DBUILD_TESTING:BOOL=${ep_build_testing}
     -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_BINARY_DIR}/MITK-build/install
     -DBUILD_SHARED_LIBS:BOOL=ON
     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
     # --------------- Compile options ----------------
     -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
     -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
     "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${MITK_ADDITIONAL_C_FLAGS}"
     "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_ADDITIONAL_CXX_FLAGS}"
     # debug flags
     "-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} ${MITK_ADDITIONAL_CXX_FLAGS_DEBUG}"
     "-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} ${MITK_ADDITIONAL_C_FLAGS_DEBUG}"
     # release flags
     "-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} ${MITK_ADDITIONAL_CXX_FLAGS_RELEASE}"
     "-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} ${MITK_ADDITIONAL_C_FLAGS_RELEASE}"
     # relwithdebinfo
     -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
     -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
     # link flags
     "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} ${MITK_ADDITIONAL_EXE_LINKER_FLAGS}"
     "-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} ${MITK_ADDITIONAL_SHARED_LINKER_FLAGS}"
     "-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ${MITK_ADDITIONAL_MODULE_LINKER_FLAGS}"
     # Output directories
     -DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
     # ------------- Boolean build options --------------
     ${mitk_superbuild_boolean_args}
     ${mitk_optional_cache_args}
     -DMITK_USE_SUPERBUILD:BOOL=OFF
     -DMITK_BUILD_CONFIGURATION:STRING=${MITK_BUILD_CONFIGURATION}
     -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
     # ----------------- Miscellaneous ---------------
     -DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE}
     -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
     -DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD}
     -DMITK_WHITELIST:STRING=${MITK_WHITELIST}
     -DMITK_WHITELISTS_EXTERNAL_PATH:STRING=${MITK_WHITELISTS_EXTERNAL_PATH}
     -DMITK_WHITELISTS_INTERNAL_PATH:STRING=${MITK_WHITELISTS_INTERNAL_PATH}
     ${qt_project_args}
     -DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_VECTOR_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS}
     # --------------- External project dirs ---------------
     -DCppMicroServices_DIR:PATH=${CppMicroServices_DIR}
     -DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE}
     -DCTK_DIR:PATH=${CTK_DIR}
     -DDCMTK_DIR:PATH=${DCMTK_DIR}
     -DEigen_DIR:PATH=${Eigen_DIR}
     -Dtinyxml_DIR:PATH=${tinyxml_DIR}
     -DGLUT_DIR:PATH=${GLUT_DIR}
     -DGLEW_DIR:PATH=${GLEW_DIR}
     -DANN_DIR:PATH=${ANN_DIR}
     -DCppUnit_DIR:PATH=${CppUnit_DIR}
     -DVTK_DIR:PATH=${VTK_DIR}     # FindVTK expects VTK_DIR
     -DITK_DIR:PATH=${ITK_DIR}     # FindITK expects ITK_DIR
     -DACVD_DIR:PATH=${ACVD_DIR}
     -DOpenCV_DIR:PATH=${OpenCV_DIR}
     -DPoco_DIR:PATH=${Poco_DIR}
+    -DPCRE_DIR:PATH=${PCRE_DIR}
+    -DSwig_DIR:PATH=${Swig_DIR}
+    -DRaptor2_DIR:PATH=${raptor2_DIR}
+    -DRasqal_DIR:PATH=${rasqal_DIR}
+    -DRedland_DIR:PATH=${redland_DIR}
+    -DREDLAND_INSTALL_DIR:PATH=${REDLAND_INSTALL_DIR}
     -DSOFA_DIR:PATH=${SOFA_DIR}
     -DGDCM_DIR:PATH=${GDCM_DIR}
     -DBOOST_ROOT:PATH=${BOOST_ROOT}
     -DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
     -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
     -DQwt_DIR:PATH=${Qwt_DIR}
     -DSimpleITK_DIR:PATH=${SimpleITK_DIR}
     -DNumpy_DIR:PATH=${Numpy_DIR}
   CMAKE_ARGS
     ${mitk_initial_cache_arg}
     ${MAC_OSX_ARCHITECTURE_ARGS}
 
   SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
   BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     MITK-Utilities
   )
 
 
 #-----------------------------------------------------------------------------
 # MITK
 #-----------------------------------------------------------------------------
 
 if(CMAKE_GENERATOR MATCHES ".*Makefiles.*")
   set(mitk_build_cmd "$(MAKE)")
 else()
   set(mitk_build_cmd ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build --config ${CMAKE_CFG_INTDIR})
 endif()
 
 if(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET)
   set(MITKBUILD_TARGET_ALL_OPTION "ALL")
 else()
   set(MITKBUILD_TARGET_ALL_OPTION "")
 endif()
 
 add_custom_target(MITK-build ${MITKBUILD_TARGET_ALL_OPTION}
   COMMAND ${mitk_build_cmd}
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
   DEPENDS MITK-Configure
   )
 
 #-----------------------------------------------------------------------------
 # Custom target allowing to drive the build of the MITK project itself
 #-----------------------------------------------------------------------------
 
 add_custom_target(MITK
   COMMAND ${mitk_build_cmd}
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
 )