diff --git a/CCache.cmake b/CCache.cmake
new file mode 100644
index 0000000..b65bf62
--- /dev/null
+++ b/CCache.cmake
@@ -0,0 +1,12 @@
+option(SWIFT_ENABLE_CCACHE "Use ccache to speed up compilation process" OFF)
+
+if(SWIFT_ENABLE_CCACHE)
+  find_program(CCACHE_PATH ccache)
+  if(CCACHE_PATH)
+    message(STATUS "Using ccache at ${CCACHE_PATH}")
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_PATH})
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE_PATH})
+  else()
+    message(STATUS "Could not find ccache")
+  endif()
+endif()
diff --git a/ClangFormat.cmake b/ClangFormat.cmake
new file mode 100644
index 0000000..54b0ec2
--- /dev/null
+++ b/ClangFormat.cmake
@@ -0,0 +1,208 @@
+#
+# A module to create custom targets to format source and header files in a git repo
+#
+# The function swift_setup_clang_format will create several targets which will
+# use clang-format to format source code according to a configuration file. 2 types
+# of targets will be created, one for formatting all files in the repository and the
+# other for formatting only the files which differ from master. The list of files to
+# format is generated by git itself. 
+#
+# The created targets have the names
+#
+# - clang-format-all-${PROJECT_NAME} - formats all files in the repo
+# - clang-format-diff-${PROJECT_NAME} - formats only changed files
+#
+# In addition if the current project is at the top level of the working tree 2 more
+# targets will be created
+#
+# - clang-format-all
+# - clang-format-diff
+#
+# which are aliases for the namespaced targets. If every project in a working
+# directory uses this module to create auto-formatting targets there will never be
+# a name clash
+#
+# The parameter SCRIPT can be used to specify a custom formatting command instead
+# of calling clang-format directly. This should be executable and will be called
+# with a single argument of either 'all' or 'diff' according to the target
+#
+# clang-format-all-${PROJECT_NAME} will run `<script> all`
+# clang-format-diff-${PROJECT_NAME} will run `<script> diff`
+#
+# If a script is not specified explicitly this function will first search for an
+# appropriate script. It must live in ${CMAKE_CURRENT_SOURCE_DIR}/scripts and be
+# named either clang-format.sh or clang-format.bash. If found the custom targets
+# will run this script with the same parameters as above
+#
+# If not script is found or specified default formatting commands will be run.
+# This function will find an appropriate clang-format program and run it against
+# the file list provided by git.
+#
+# The list of program names can be overriden by passing the CLANG_FORMAT_NAMES
+# parameter with a list of names to search for
+#
+# All commands will be run from the source directory which calls this function.
+# It is highly recommended to include this module and call swift_setup_clang_format
+# from the top level CMakeLists.txt, using in a subdirectory may not work as
+# intended.
+#
+# In addition this function sets up a cmake option which can be used to control
+# whether the targets are created either on the command line or by a super project.
+# The option has the name
+#
+# ${PROJECT_NAME}_ENABLE_CLANG_FORMAT
+#
+# The default value is ON for top level projects, and OFF for any others.
+#
+# Running 
+#
+# cmake -D<project>_ENABLE_CLANG_FORMAT=OFF ..
+#
+# will explicitly disable these targets from the command line at configure time
+#
+
+# Helper function to actually create the targets, not to be used outside this file
+function(create_targets)
+  set(argOption "")
+  set(argSingle "TOP_LEVEL")
+  set(argMulti "ALL_COMMAND" "DIFF_COMMAND")
+
+  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
+
+  add_custom_target(clang-format-all-${PROJECT_NAME}
+      COMMAND ${x_ALL_COMMAND}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      )
+  add_custom_target(clang-format-diff-${PROJECT_NAME}
+      COMMAND ${x_DIFF_COMMAND}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      )
+
+  # Top level projects will create the targets clang-format-all and
+  # clang-format-diff with the same commands as the namespaced targets
+  # above. However, cmake doesn't support aliases for non-library targets
+  # so we have to create them fully.
+  if(x_TOP_LEVEL)
+    add_custom_target(clang-format-all
+        COMMAND ${x_ALL_COMMAND}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+    add_custom_target(clang-format-diff
+        COMMAND ${x_DIFF_COMMAND}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+  endif()
+endfunction()
+
+macro(early_exit level msg)
+  message(${level} "${msg}")
+  if(x_REQUIRED)
+    message(FATAL_ERROR "clang-format support is REQUIRED for ${PROJECT_NAME}")
+  endif()
+  return()
+endmacro()
+
+# External function to create clang-format-* targets. Call according to the
+# documentation in the file header.
+function(swift_setup_clang_format)
+  set(argOption "REQUIRED")
+  set(argSingle "SCRIPT")
+  set(argMulti "CLANG_FORMAT_NAMES")
+
+  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
+
+  if(x_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unparsed arguments ${x_UNPARSED_ARGUMENTS}")
+  endif()
+
+  # Global clang-format enable option, influences the default project specific enable option
+  option(ENABLE_CLANG_FORMAT "Enable auto-formatting of code using clang-format globally" ON)
+  if(NOT ENABLE_CLANG_FORMAT)
+    early_exit(STATUS "auto-formatting is disabled globally")
+  endif()
+
+  if(${PROJECT_NAME} STREQUAL ${CMAKE_PROJECT_NAME})
+    # This is the top level project, ie the CMakeLists.txt which cmake was run
+    # on directly, not a submodule/subproject. We can do some special things now.
+    # The option to enable clang formatting will be enabled by default only for
+    # top level projects. Also the top level project will create an alias target
+    # clang-format-all against the project specific target
+    set(top_level_project ON)
+  else()
+    set(top_level_project OFF)
+  endif()
+
+  # Create a cmake option to enable formatting of this specific project
+  option(${PROJECT_NAME}_ENABLE_CLANG_FORMAT "Enable auto-formatting of code using clang-format for project ${PROJECT_NAME}" ${top_level_project})
+
+  if(NOT ${PROJECT_NAME}_ENABLE_CLANG_FORMAT)
+    # Explicitly disabled
+    early_exit(STATUS "${PROJECT_NAME} clang-format support is DISABLED")
+  endif()
+
+  # If a custom script has been specified always use that by default
+  if(x_SCRIPT)
+    if(EXISTS ${x_SCRIPT})
+      message(STATUS "Initialising clang format targets for ${PROJECT_NAME} using existing script in ${x_SCRIPT}")
+      create_targets(
+          TOP_LEVEL ${top_level_project}
+          ALL_COMMAND ${x_SCRIPT} all
+          DIFF_COMMAND ${x_SCRIPT} diff
+          )
+    else()
+      message(FATAL_ERROR "Specified clang-format script ${x_SCRIPT} doesn't exist")
+    endif()
+    return()
+  endif()
+
+  # Search for a custom formatting script in some reasonable places
+  set(custom_scripts "${CMAKE_CURRENT_SOURCE_DIR}/scripts/clang-format.sh" "${CMAKE_CURRENT_SOURCE_DIR}/scripts/clang-format.bash")
+
+  foreach(script ${custom_scripts})
+    if(EXISTS ${script})
+      # Found a custom formatting script
+      message(STATUS "Initialising clang format target for ${PROJECT_NAME} using existing script in ${script}")
+      create_targets(
+          TOP_LEVEL ${top_level_project}
+          ALL_COMMAND ${script} all
+          DIFF_COMMAND ${script} diff
+          )
+      return()
+    endif()
+  endforeach()
+
+  # Did not find any script to use, generate a default formatting command to process all code files in the repo
+
+  # First try to find clang-format
+  if(NOT x_CLANG_FORMAT_NAMES)
+    set(x_CLANG_FORMAT_NAMES 
+        clang-format60 clang-format-6.0
+        clang-format40 clang-format-4.0
+        clang-format39 clang-format-3.9
+        clang-format38 clang-format-3.8
+        clang-format37 clang-format-3.7
+        clang-format36 clang-format-3.6
+        clang-format35 clang-format-3.5
+        clang-format34 clang-format-3.4
+        clang-format
+       )
+  endif()
+  find_program(CLANG_FORMAT NAMES ${x_CLANG_FORMAT_NAMES})
+
+  if("${CLANG_FORMAT}" STREQUAL "CLANG_FORMAT-NOTFOUND")
+    # clang-format not found, can't continue
+    early_exit(WARNING "Could not find appropriate clang-format, targets disabled")
+  endif()
+
+  message(STATUS "Using ${CLANG_FORMAT}")
+  set(${PROJECT_NAME}_CLANG_FORMAT ${CLANG_FORMAT} CACHE STRING "Absolute path to clang-format for ${PROJECT_NAME}")
+
+  # Format all source and header files in the repo, use a git command to build the file list
+  set(default_patterns "*.[ch]" "*.cpp" "*.cc" "*.hpp")
+
+  create_targets(
+      TOP_LEVEL ${top_level_project}
+      ALL_COMMAND git ls-files ${default_patterns} | xargs ${${PROJECT_NAME}_CLANG_FORMAT} -i
+      DIFF_COMMAND git diff --diff-filter=ACMRTUXB --name-only master -- ${default_patterns} | xargs ${${PROJECT_NAME}_CLANG_FORMAT} -i
+  )
+endfunction()
diff --git a/ClangTidy.cmake b/ClangTidy.cmake
new file mode 100644
index 0000000..6d329aa
--- /dev/null
+++ b/ClangTidy.cmake
@@ -0,0 +1,275 @@
+#
+# A module to create custom targets to lint source files using clang-tidy
+#
+# The function swift_setup_clang_tidy will create several targets which will
+# use clang-tidy to lint source files. 2 types of targets will be created, one
+# for linting all listed source files and the other for linting only those which
+# differ from the master branch. The list of file to lint can be created in 2
+# ways which are explained below.
+#
+# The created targets have the names
+#
+# - clang-tidy-all-${PROJECT_NAME} - lints all files
+# - clang-tidy-diff-${PROJECT_NAME} - lints only changed files
+#
+# In addition if the current project is at the top level of the working tree 2 more
+# targets will be created
+#
+# - clang-tidy-all
+# - clang-tidy-diff
+#
+# which behave in exactly the same way as the namespaced targets.
+#
+# The parameter SCRIPT can be passed to specify a custom linting script. If given
+# the create targets will call this script directly. The script will be passed
+# a single argument of 'all' or 'diff' according to the target
+#
+# clang-tidy-all - will run `<script> all`
+# clang-tidy-diff - will run `<script> diff`
+#
+# If a script is not explicitly passed this function will first search for a 
+# custom linting script. The script must exist in ${CMAKE_CURRENT_SOURCE_DIR}/scripts
+# and be named either clang-tidy.sh or clang-tidy.bash. It will be called with
+# the same arguments as described above.
+#
+# If no custom script is available this function will generate some default linting
+# commands. clang-tidy will be called and passed a list of files to lint. 
+#
+# The file list can be constructed in one of two ways, either by GLOB patterns or
+# a list of targets
+#
+# GLOB
+#   Pass the parameter 'PATTERNS' with 1 or more GLOB patterns as arguments. These
+#   patterns will be passed to git directly which will generate a list of files to
+#   lint.
+#
+#   swift_setup_clang_tidy(PATTERNS 'src/*.c' 'src/*.cc' 'src/*.cpp')
+#
+# TARGETS
+#   Pass the parameter 'TARGETS" with 1 or more cmake targets as arguments. These
+#   target must already have been created. The list of source files will be extracted
+#   from these targets and passed first to git so it can correctly filter them, then
+#   to clang-tidy.
+#
+# This function must be called with one of the above options, or it must be able to
+# find a custom script in the file system otherwise it will throw an error.
+#
+# All commands are run from ${CMAKE_CURRENT_SOURCE_DIR}. It is highly recommended
+# that this module only be included from the top level CMakeLists.txt of a project,
+# using it from a subdirectory may not work as expected.
+#
+# In addition this function sets up a cmake option which can be used to control
+# whether the targets are created either on the command line or by a super project.
+# The option has the name
+#
+# ${PROJECT_NAME}_ENABLE_CLANG_TIDY
+#
+# The default value is ON for top level projects, and OFF for any others.
+#
+# Running 
+#
+# cmake -D<project>_ENABLE_CLANG_TIDY=OFF ..
+#
+# will explicitly disable these targets from the command line at configure time
+#
+
+# Helper function to actually create the targets, not to be used outside this file
+function(create_targets)
+  set(argOption "")
+  set(argSingle "TOP_LEVEL")
+  set(argMulti "ALL_COMMAND" "DIFF_COMMAND")
+
+  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
+
+  add_custom_target(
+      clang-tidy-all-${PROJECT_NAME}
+      COMMAND ${x_ALL_COMMAND}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      )
+  add_custom_target(
+      clang-tidy-diff-${PROJECT_NAME}
+      COMMAND ${x_DIFF_COMMAND}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      )
+
+  # Top level projects will create the targets clang-tidy-all and
+  # clang-tidy-diff with the same commands as the namespaced targets
+  # above. However, cmake doesn't support aliases for non-library targets
+  # so we have to create them fully.
+  if(x_TOP_LEVEL)
+    add_custom_target(
+        clang-tidy-all
+        COMMAND ${x_ALL_COMMAND}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+    add_custom_target(
+        clang-tidy-diff
+        COMMAND ${x_DIFF_COMMAND}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+  endif()
+endfunction()
+
+# Scan a list of targets and build up a list of source files
+function(generate_file_list_from_targets)
+  set(argOption "")
+  set(argSingle "")
+  set(argMulti "TARGETS")
+
+  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
+
+  foreach(target ${x_TARGETS})
+    if(NOT TARGET ${target})
+      message(FATAL_ERROR "Trying to enable clang-tidy for target ${target} which doesn't exist")
+    endif()
+
+    # Extract the list of source files from the target and convert to absolute paths
+    set(target_srcs "")
+    set(abs_target_srcs "")
+    get_target_property(target_srcs ${target} SOURCES)
+    foreach(file ${target_srcs})
+      if(${file} MATCHES ".*\\.h$")
+        list(REMOVE_ITEM target_srcs ${file})
+      endif()
+    endforeach()
+
+    list(REMOVE_DUPLICATES target_srcs)
+
+    get_target_property(target_dir ${target} SOURCE_DIR)
+    foreach(file ${target_srcs})
+      get_filename_component(abs_file ${file} ABSOLUTE BASE_DIR ${target_dir})
+      list(APPEND abs_target_srcs ${abs_file})
+    endforeach()
+
+    if(abs_target_srcs)
+      list(APPEND srcs ${abs_target_srcs})
+      set(srcs ${srcs} PARENT_SCOPE)
+    else()
+      message(WARNING "Target ${target} does not have any lintable sources")
+    endif()
+  endforeach()
+endfunction()
+
+macro(early_exit level msg)
+  message(${level} "${msg}")
+  if(x_REQUIRED)
+    message(FATAL_ERROR "clang-tidy support is REQUIRED for ${PROJECT_NAME}")
+  endif()
+  return()
+endmacro()
+
+# External function to create clang-tidy-* targets, Call according to the
+# documentation in the file header.
+function(swift_setup_clang_tidy)
+  set(argOption "REQUIRED")
+  set(argSingle "SCRIPT")
+  set(argMulti "CLANG_TIDY_NAMES" "TARGETS" "PATTERNS")
+
+  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
+
+  if(x_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unparsed arguments ${x_UNPARSED_ARGUMENTS}")
+  endif()
+
+  # Global clang-tidy enable option, influences the default project specific enable option
+  option(ENABLE_CLANG_TIDY "Enable auto-linting of code using clang-tidy globally" ON)
+  if(NOT ENABLE_CLANG_TIDY)
+    early_exit(STATUS "auto-linting is disabled globally")
+  endif()
+
+  if(${PROJECT_NAME} STREQUAL ${CMAKE_PROJECT_NAME})
+    set(top_level_project ON)
+  else()
+    set(top_level_project OFF)
+  endif()
+
+  # Create a cmake option to enable linting of this specific project
+  option(${PROJECT_NAME}_ENABLE_CLANG_TIDY "Enable auto-linting of code using clang-tidy for project ${PROJECT_NAME}" ${top_level_project})
+
+  if(NOT ${PROJECT_NAME}_ENABLE_CLANG_TIDY)
+    early_exit(STATUS "${PROJECT_NAME} clang-tidy support is DISABLED")
+  endif()
+
+  # This is required so that clang-tidy can work out what compiler options to use
+  # for each file
+  set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Export compile commands" FORCE)
+
+  # Use a custom script if explicitly passed
+  if(x_SCRIPT)
+    if(EXISTS ${x_SCRIPT})
+      message(STATUS "Initialising clang tidy targets for ${PROJECT_NAME} using existing script in ${x_SCRIPT}")
+      create_targets(
+          TOP_LEVEL ${top_level_project}
+          ALL_COMMAND ${x_SCRIPT} all
+          DIFF_COMMAND ${x_SCRIPT} diff
+          )
+      return()
+    endif()
+    message(FATAL_ERROR "Specified clang-tidy script ${x_SCRIPT} doesn't exist")
+  endif()
+
+  # Search some default locations for a custom tidy script
+  set(custom_scripts "${CMAKE_CURRENT_SOURCE_DIR}/scripts/clang-tidy.sh" "${CMAKE_CURRENT_SOURCE_DIR}/scripts/clang-tidy.bash")
+
+  foreach(script ${custom_scripts})
+    if(EXISTS ${script})
+      message(STATUS "Initialising clang tidy target for ${PROJECT_NAME} using existing script in ${script}")
+      create_targets(
+          TOP_LEVEL ${top_level_project}
+          ALL_COMMAND ${script} all
+          DIFF_COMMAND ${script} diff
+          )
+      return()
+    endif()
+  endforeach()
+
+  # Didn't find a custom script. Generate some default commands
+
+  # First search for an appropriate clang-tidy
+  if(NOT x_CLANG_TIDY_NAMES)
+    set(x_CLANG_TIDY_NAMES 
+        clang-tidy60 clang-tidy-6.0
+        clang-tidy40 clang-tidy-4.0
+        clang-tidy39 clang-tidy-3.9
+        clang-tidy38 clang-tidy-3.8
+        clang-tidy37 clang-tidy-3.7
+        clang-tidy36 clang-tidy-3.6
+        clang-tidy35 clang-tidy-3.5
+        clang-tidy34 clang-tidy-3.4
+        clang-tidy
+       )
+  endif()
+  find_program(CLANG_TIDY NAMES ${x_CLANG_TIDY_NAMES})
+
+  if("${CLANG_TIDY}" STREQUAL "CLANG_TIDY-NOTFOUND")
+    early_exit(WARNING "Could not find appropriate clang-tidy, targets disabled")
+  endif()
+
+  message(STATUS "Using ${CLANG_TIDY}")
+  set(${PROJECT_NAME}_CLANG_TIDY ${CLANG_TIDY} CACHE STRING "Absolute path to clang-tidy for ${PROJECT_NAME}")
+
+  set(srcs "")
+  if(x_TARGETS)
+    # Extract a list of source files from each of the specified targets
+    generate_file_list_from_targets(TARGETS ${x_TARGETS})
+  elseif(x_PATTERNS)
+    # Just use the provided pattern as the file list
+    set(srcs ${x_PATTERNS})
+  else()
+    message(FATAL_ERROR "ClangTidy modules must be set up to use either a custom script, a list of targets, or file patterns")
+  endif()
+
+  if(NOT srcs)
+    early_exit(WARNING "Couldn't find any source/header files to tidy in ${PROJECT_NAME}")
+  else()
+    create_targets(
+        TOP_LEVEL ${top_level_project}
+        ALL_COMMAND
+          ${${PROJECT_NAME}_CLANG_TIDY} -p ${CMAKE_BINARY_DIR} --export-fixes=${CMAKE_CURRENT_SOURCE_DIR}/fixes.yaml
+          `git ls-files ${srcs}`
+        DIFF_COMMAND
+          ${${PROJECT_NAME}_CLANG_TIDY} -p ${CMAKE_BINARY_DIR} --export-fixes=${CMAKE_CURRENT_SOURCE_DIR}/fixes.yaml
+          `git diff --diff-filter=ACMRTUXB --name-only master -- ${srcs}`
+        )
+  endif()
+endfunction()
diff --git a/FindCheck.cmake b/FindCheck.cmake
new file mode 100644
index 0000000..8ad818f
--- /dev/null
+++ b/FindCheck.cmake
@@ -0,0 +1,55 @@
+# - Try to find the CHECK libraries
+#  Once done this will define
+#
+#  CHECK_FOUND - system has check
+#  CHECK_INCLUDE_DIRS - the check include directory
+#  CHECK_LIBRARIES - check library
+#
+#  Copyright (c) 2007 Daniel Gollub <gollub@b1-systems.de>
+#  Copyright (c) 2007-2009 Bjoern Ricks  <bjoern.ricks@gmail.com>
+#
+#  Redistribution and use is allowed according to the terms of the New
+#  BSD license.
+#  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+
+INCLUDE( FindPkgConfig )
+
+IF ( Check_FIND_REQUIRED )
+	SET( _pkgconfig_REQUIRED "REQUIRED" )
+ELSE( Check_FIND_REQUIRED )
+	SET( _pkgconfig_REQUIRED "" )
+ENDIF ( Check_FIND_REQUIRED )
+
+IF ( CHECK_MIN_VERSION )
+	PKG_SEARCH_MODULE( CHECK ${_pkgconfig_REQUIRED} check>=${CHECK_MIN_VERSION} )
+ELSE ( CHECK_MIN_VERSION )
+	PKG_SEARCH_MODULE( CHECK ${_pkgconfig_REQUIRED} check )
+ENDIF ( CHECK_MIN_VERSION )
+
+# Look for CHECK include dir and libraries
+IF( NOT CHECK_FOUND AND NOT PKG_CONFIG_FOUND )
+
+	FIND_PATH( CHECK_INCLUDE_DIRS check.h )
+
+	FIND_LIBRARY( CHECK_LIBRARIES NAMES check )
+
+	IF ( CHECK_INCLUDE_DIRS AND CHECK_LIBRARIES )
+		SET( CHECK_FOUND 1 )
+		IF ( NOT Check_FIND_QUIETLY )
+			MESSAGE ( STATUS "Found CHECK: ${CHECK_LIBRARIES}" )
+		ENDIF ( NOT Check_FIND_QUIETLY )
+	ELSE ( CHECK_INCLUDE_DIRS AND CHECK_LIBRARIES )
+		IF ( Check_FIND_REQUIRED )
+			MESSAGE( FATAL_ERROR "Could NOT find CHECK" )
+		ELSE ( Check_FIND_REQUIRED )
+			IF ( NOT Check_FIND_QUIETLY )
+				MESSAGE( STATUS "Could NOT find CHECK" )
+			ENDIF ( NOT Check_FIND_QUIETLY )
+		ENDIF ( Check_FIND_REQUIRED )
+	ENDIF ( CHECK_INCLUDE_DIRS AND CHECK_LIBRARIES )
+ENDIF( NOT CHECK_FOUND AND NOT PKG_CONFIG_FOUND )
+
+# Hide advanced variables from CMake GUIs
+MARK_AS_ADVANCED( CHECK_INCLUDE_DIRS CHECK_LIBRARIES )
+
diff --git a/FindEigen.cmake b/FindEigen.cmake
new file mode 100644
index 0000000..fd2bd58
--- /dev/null
+++ b/FindEigen.cmake
@@ -0,0 +1,19 @@
+if(TARGET eigen)
+  return()
+endif()
+
+add_library(eigen INTERFACE)
+
+# Include Eigen library as system headers to suppress warnings when not
+# cross-compiling. GNU ARM toolchain wraps system headers with `extern "C"`,
+# causing errors, so in this case Eigen must be #included using
+# `#pragma GCC system_header` in the source.
+# See https://gcc.gnu.org/onlinedocs/cpp/System-Headers.html
+if (NOT CMAKE_CROSSCOMPILING OR THIRD_PARTY_INCLUDES_AS_SYSTEM)
+  target_include_directories(eigen SYSTEM INTERFACE
+      ${PROJECT_SOURCE_DIR}/third_party/eigen/)
+else()
+  target_include_directories(eigen INTERFACE
+      ${PROJECT_SOURCE_DIR}/third_party/eigen/)
+endif()
+
diff --git a/FindFastCSV.cmake b/FindFastCSV.cmake
new file mode 100644
index 0000000..8816f5d
--- /dev/null
+++ b/FindFastCSV.cmake
@@ -0,0 +1,6 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET "fast-csv"
+    SOURCE_DIR "fast-cpp-csv-parser"
+    SYSTEM_INCLUDES
+    )
diff --git a/FindGFlags.cmake b/FindGFlags.cmake
new file mode 100644
index 0000000..37f420f
--- /dev/null
+++ b/FindGFlags.cmake
@@ -0,0 +1,19 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET gflags
+    SOURCE_DIR "googleflags"
+    )
+
+if(NOT CMAKE_CROSSCOMPILING OR THIRD_PARTY_INCLUDES_AS_SYSTEM)
+  # Change all of GoogleFlags's include directories to be system includes, to avoid
+  # compiler errors. The generalised version of this in GenericFindDependency won't
+  # work here because we are dealing with an aliased target
+  get_target_property(_aliased gflags ALIASED_TARGET)
+  if(_aliased)
+    get_target_property(gflags_include_directories ${_aliased} INTERFACE_INCLUDE_DIRECTORIES)
+    if(gflags_include_directories)
+      set_target_properties(${_aliased} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "")
+      target_include_directories(${_aliased} SYSTEM INTERFACE ${gflags_include_directories})
+    endif()
+  endif()
+endif()
diff --git a/FindGnss-converters.cmake b/FindGnss-converters.cmake
new file mode 100644
index 0000000..cda9bed
--- /dev/null
+++ b/FindGnss-converters.cmake
@@ -0,0 +1,6 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET gnss_converters
+    SOURCE_DIR "gnss-converters/c"
+    SYSTEM_INCLUDES
+    )
diff --git a/FindGoogletest.cmake b/FindGoogletest.cmake
new file mode 100644
index 0000000..01668e8
--- /dev/null
+++ b/FindGoogletest.cmake
@@ -0,0 +1,6 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET gtest
+    SOURCE_DIR "googletest"
+    SYSTEM_INCLUDES
+    )
diff --git a/FindJson.cmake b/FindJson.cmake
new file mode 100644
index 0000000..9e97715
--- /dev/null
+++ b/FindJson.cmake
@@ -0,0 +1,7 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET "nlohmann_json"
+    SOURCE_DIR "json"
+    SYSTEM_INCLUDES
+    )
+
diff --git a/FindOptional.cmake b/FindOptional.cmake
new file mode 100644
index 0000000..299d1f9
--- /dev/null
+++ b/FindOptional.cmake
@@ -0,0 +1,5 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET optional
+    SYSTEM_INCLUDES
+    )
diff --git a/FindOrion-Proto.cmake b/FindOrion-Proto.cmake
new file mode 100644
index 0000000..474bbc4
--- /dev/null
+++ b/FindOrion-Proto.cmake
@@ -0,0 +1,6 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET orion-proto
+    SOURCE_DIR "orion_proto"
+    SYSTEM_INCLUDES
+    )
diff --git a/FindProtobuf.cmake b/FindProtobuf.cmake
new file mode 100644
index 0000000..80a75f3
--- /dev/null
+++ b/FindProtobuf.cmake
@@ -0,0 +1,6 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET "libprotobuf"
+    SOURCE_DIR "protobuf/cmake"
+    SYSTEM_INCLUDES
+    )
diff --git a/FindRapidCheck.cmake b/FindRapidCheck.cmake
new file mode 100644
index 0000000..6a81b37
--- /dev/null
+++ b/FindRapidCheck.cmake
@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.2)
+include("GenericFindDependency")
+
+set(RC_ENABLE_GTEST ON CACHE BOOL "" FORCE)
+
+GenericFindDependency(
+    TARGET rapidcheck
+    )
+
+# Change all of rapidcheck's include directories to be system includes, to avoid
+# compiler errors. The generalised version in GenericFindDependency isn't suitable
+# in this instance.
+get_target_property(rapidcheck_interface_includes rapidcheck INTERFACE_INCLUDE_DIRECTORIES)
+if(rapidcheck_interface_includes)
+  set_target_properties(rapidcheck PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "")
+  target_include_directories(rapidcheck SYSTEM INTERFACE ${rapidcheck_interface_includes})
+else()
+  message(WARNING "No include directories in rapidcheck, this seems wrong")
+endif()
+unset(rapidcheck_interface_includes)
+
+get_target_property(rapidcheck_gtest_interface_includes rapidcheck_gtest INTERFACE_INCLUDE_DIRECTORIES)
+if(rapidcheck_gtest_interface_includes)
+  set_target_properties(rapidcheck_gtest PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "")
+  target_include_directories(rapidcheck_gtest SYSTEM INTERFACE ${rapidcheck_gtest_interface_includes})
+else()
+  message(WARNING "No include directories in rapidcheck_gtest, this seems wrong")
+endif()
+unset(rapidcheck_gtest_interface_includes)
+
diff --git a/FindRtcm.cmake b/FindRtcm.cmake
new file mode 100644
index 0000000..c1f4bb1
--- /dev/null
+++ b/FindRtcm.cmake
@@ -0,0 +1,6 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET rtcm
+    SOURCE_DIR "c"
+    SYSTEM_INCLUDES
+    )
diff --git a/FindSbp.cmake b/FindSbp.cmake
new file mode 100644
index 0000000..251c640
--- /dev/null
+++ b/FindSbp.cmake
@@ -0,0 +1,6 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET sbp
+    SOURCE_DIR "c"
+    SYSTEM_INCLUDES
+    )
diff --git a/FindSettings.cmake b/FindSettings.cmake
new file mode 100644
index 0000000..b86f23d
--- /dev/null
+++ b/FindSettings.cmake
@@ -0,0 +1,5 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET settings
+    SYSTEM_INCLUDES
+    )
diff --git a/FindStarling.cmake b/FindStarling.cmake
new file mode 100644
index 0000000..6ef49e2
--- /dev/null
+++ b/FindStarling.cmake
@@ -0,0 +1,5 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET starling
+    SYSTEM_INCLUDES
+    )
diff --git a/FindSwiftnav.cmake b/FindSwiftnav.cmake
new file mode 100644
index 0000000..9c44bfa
--- /dev/null
+++ b/FindSwiftnav.cmake
@@ -0,0 +1,5 @@
+include("GenericFindDependency")
+GenericFindDependency(
+    TARGET swiftnav
+    SYSTEM_INCLUDES
+    )
diff --git a/FindYaml-Cpp.cmake b/FindYaml-Cpp.cmake
new file mode 100644
index 0000000..593bb8e
--- /dev/null
+++ b/FindYaml-Cpp.cmake
@@ -0,0 +1,7 @@
+include("GenericFindDependency")
+option(YAML_CPP_BUILD_TOOLS "Enable testing and parse tools" OFF)
+option(YAML_CPP_BUILD_CONTRIB "Enable contrib stuff in library" OFF)
+GenericFindDependency(
+    TARGET "yaml-cpp"
+    SYSTEM_INCLUDES
+    )
diff --git a/GenericFindDependency.cmake b/GenericFindDependency.cmake
new file mode 100644
index 0000000..d82aa12
--- /dev/null
+++ b/GenericFindDependency.cmake
@@ -0,0 +1,314 @@
+#
+# A generic cmake function to search for a dependency from several places and
+# include in the build system as appropriate
+#
+# Dependencies can be picked up either from bundled source code, usually a git
+# submodule located in the 'third_party' directory, or from libraries installed
+# in the host system or cross compiling sysroot.
+#
+# By default dependencies are first sought in bundled source code, and if not
+# found from the system libraries. This default behaviour can be controlled by 
+# several options
+#
+# EXCLUDE - can be used to disable searching in a particular location. Valid
+#   arguments are 'source' and 'system'
+# PREFER - used to override the default search location. Valid arguments are
+#   'source' and 'system'. If not specified defaults to 'source'
+#
+# Similar options can be specified on the command line as well.
+# SWIFT_PREFERRED_DEPENDENCY_SOURCE takes the same arguments as above but
+# will apply globally across the entire build tree at configure time. For example
+#
+# cmake -DSWIFT_PREFERRED_DEPENDENCY_SOURCE=system <path>
+#
+# will try to use depenedencies from the system libraries rather than bundled
+# source code.
+#
+# If the dependency is picked up from the system libraries this function will
+# create an interface target which can be used to link in to any other target.
+#
+# The options "SYSTEM_HEADER_FILE" and "SYSTEM_LIB_NAMES" will be passed verbatim
+# to the cmake functions find_header() and find_library() to search all the 
+# correct system locations.
+#
+# When using bundled source code the function will search several default locations
+# under '${CMAKE_CURRENT_SOURCE_DIR}/third_party' based on the package and target
+# names. The search location can be controlled by the "SOURCE_DIR" parameter
+#
+# The target name can be controlled by the option "TARGET". When using 
+# bundled source code this is used to verify the target was created properly
+# after calling add_subdirectory
+#
+# Passing the option SYSTEM_INCLUDES will rewrite the target include directories
+# so that they are marked as system headers. This will usually be passed to
+# the compiler as an command line option as decided by cmake. Be careful with
+# this option, it will supress warning which might otherwise be helpful.
+#
+# The option REQUIRED can be passed which will cause this function to fail
+# if the dependency was not found for any reason.
+#
+# Example: FindGoogletest.cmake
+#
+# GenericFindDependency(
+#    TARGET gtest
+#    SOURCE_DIR "googletest"
+#    SYSTEM_INCLUDES
+#    )
+#
+
+function(search_dependency_source)
+  set(argOptions "")
+  set(argSingleArguments "TARGET")
+  set(argMultiArguments "SOURCE_SEARCH_PATHS")
+
+  cmake_parse_arguments(x "${argOptions}" "${argSingleArguments}" "${argMultiArguments}" ${ARGN})
+
+  if (x_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unexpected extra arguments in search_dependency_source: ${x_UNPARSED_ARGUMENTS}")
+  endif()
+
+  foreach(P ${x_SOURCE_SEARCH_PATHS})
+    if(EXISTS "${P}/CMakeLists.txt")
+      message(STATUS "Found ${x_TARGET} source code in ${P}")
+      add_subdirectory(${P})
+  
+      if(NOT TARGET ${x_TARGET})
+        message(WARNING "Source code in ${P} did not declare target ${x_TARGET} as was expected")
+      endif()
+  
+      # This is very ugly, but required for some python modules, it will not last beyond this temporary solution
+      if(EXISTS "${P}/include")
+        set(x_${x_TARGET}_IncludeDir "${P}/include" CACHE PATH "Path to ${x_TARGET} bundled source code header files")
+      endif()
+
+      return()
+    endif()
+  endforeach()
+
+  message(STATUS "No ${x_TARGET} source available in search paths")
+endfunction()
+
+function(search_dependency_system)
+  set(argOptions "")
+  set(argSingleArguments "TARGET" "SYSTEM_HEADER_FILE")
+  set(argMultiArguments "SYSTEM_LIB_NAMES")
+
+  cmake_parse_arguments(x "${argOptions}" "${argSingleArguments}" "${argMultiArguments}" ${ARGN})
+
+  if (x_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unexpected extra arguments in search_dependency_system: ${x_UNPARSED_ARGUMENTS}")
+  endif()
+
+  find_path(x_${x_TARGET}_IncludeDir ${x_SYSTEM_HEADER_FILE})
+  find_library(x_${x_TARGET}_Library NAMES ${x_SYSTEM_LIB_NAMES})
+
+  if(NOT x_${x_TARGET}_IncludeDir OR NOT x_${x_TARGET}_Library)
+    message(STATUS "Could not find ${x_TARGET} from any available sysroot path")
+    return()
+  endif()
+
+  add_library(${x_TARGET} UNKNOWN IMPORTED)
+  set_target_properties(${x_TARGET} PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${x_${x_TARGET}_IncludeDir}")
+  set_property(TARGET ${x_TARGET} APPEND PROPERTY
+      IMPORTED_LOCATION "${x_${x_TARGET}_Library}")
+  message(STATUS "Found ${x_TARGET} from the system at ${x_${x_TARGET}_Library}")
+endfunction()
+
+# To be called from GenericFindDependency
+#
+# Create the variable which will contain a list of possible search locations sorted
+# by order of preference
+#
+# This is a macro so all input and output variable exist in the context of the caller
+#
+# This macro will return(), ie cause the caller to return, if there are no available locations.
+# It will raise a fatal error if unknown values are specified for any of the input parameters.
+#
+# Inputs: 
+# - x_PREFER - Parameter to GenericFindDependency, preferred location as defined by the project
+# - SWIFT_PREFERRED_DEPENDENCY_SOURCE - Global user preference, defined on the command line
+# - x_EXCLUDE - List of sources to exclude from consideration
+# - SWIFT_EXCLUDE_DEPENDENCY_SOURCE - Global user exclude list, defined on the command line
+#
+# Outputs:
+# - x_Locations - List of locations to search for the dependency
+# - x_NumLocations - Length of x_Locations
+#
+macro(setup_search_locations)
+  if(NOT x_PREFER)
+    if (SWIFT_PREFERRED_DEPENDENCY_SOURCE)
+      set(x_PREFER "${SWIFT_PREFERRED_DEPENDENCY_SOURCE}")
+    else()
+      set(x_PREFER "source")
+    endif()
+  endif()
+
+  if(${x_PREFER} STREQUAL "source")
+    list(APPEND x_Locations "source" "system")
+  elseif(${x_PREFER} STREQUAL "system")
+    list(APPEND x_Locations "system" "source")
+  else()
+    message(FATAL_ERROR "Unknown value for dependency location prefer: ${x_PREFER}")
+  endif()
+
+  if(x_EXCLUDE)
+    foreach(S ${x_EXCLUDE})
+      list(REMOVE_ITEM x_Locations ${S})
+    endforeach()
+  endif()
+
+  if(SWIFT_EXCLUDE_DEPENDENCY_SOURCE)
+    foreach(S ${SWIFT_EXCLUDE_DEPENDENCY_SOURCE})
+      list(REMOVE_ITEM x_Locations ${S})
+    endforeach()
+  endif()
+
+  list(LENGTH x_Locations x_NumLocations)
+  if (${x_NumLocations} EQUAL 0)
+    if (x_REQUIRED)
+      message(FATAL_ERROR "Could not find dependency ${x_TARGET}, no locations available")
+    else()
+      message(WARNING "Could not find dependency ${x_TARGET}, no locations available")
+      return()
+    endif()
+  endif()
+endmacro()
+
+#
+# To be called from GenericFindDependency
+#
+# Creates a list of paths to be searched for source code for the dependency
+#
+# This is a macro, all input and output variables exist in the context of the caller
+#
+# If a source dir path is not explicitly specified this macro will generate a list of
+# probable locations for the dependency source code. It outputs a list of absolute
+# paths to be searched
+#
+# Inputs:
+# - x_SOURCE_DIR - Parameter to GenericFindDependency, appened to the generated search paths
+#
+# Outputs:
+# - x_SOURCE_SEARCH_PATHS - A list of paths to be searched for source code
+#
+macro(create_source_search_paths)
+  # set defaults
+  set(x_SOURCE_SEARCH_PATHS "")
+  if(NOT x_SOURCE_DIR)
+    list(APPEND x_SOURCE_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/third_party/${CMAKE_FIND_PACKAGE_NAME}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/third_party/${x_TARGET}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/third_party/lib${x_TARGET}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${PROJECT_SOURCE_DIR}/third_party/${CMAKE_FIND_PACKAGE_NAME}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${PROJECT_SOURCE_DIR}/third_party/${x_TARGET}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${PROJECT_SOURCE_DIR}/third_party/lib${x_TARGET}")
+  else()
+    list(APPEND x_SOURCE_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/${x_SOURCE_DIR}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/third_party/${x_SOURCE_DIR}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${PROJECT_SOURCE_DIR}/${x_SOURCE_DIR}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${PROJECT_SOURCE_DIR}/third_party/${x_SOURCE_DIR}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/third_party/${CMAKE_FIND_PACKAGE_NAME}/${x_SOURCE_DIR}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/third_party/${x_TARGET}/${x_SOURCE_DIR}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/third_party/lib${x_TARGET}/${x_SOURCE_DIR}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${PROJECT_SOURCE_DIR}/third_party/${CMAKE_FIND_PACKAGE_NAME}/${x_SOURCE_DIR}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${PROJECT_SOURCE_DIR}/third_party/${x_TARGET}/${x_SOURCE_DIR}")
+    list(APPEND x_SOURCE_SEARCH_PATHS "${PROJECT_SOURCE_DIR}/third_party/lib${x_TARGET}/${x_SOURCE_DIR}")
+  endif()
+endmacro()
+
+#
+# Helper function to mark the specified target's include directories as system. This is
+# then passed to the compiler which will surpress warnings generated from any header file
+# included by this path. Use with care
+#
+# Should only be called from GenericFindDependency
+#
+function(mark_target_as_system_includes TARGET)
+  get_target_property(directories ${x_TARGET} INTERFACE_INCLUDE_DIRECTORIES)
+  if(directories)
+    message(STATUS "Marking ${x_TARGET} include directories as system")
+    set_target_properties(${x_TARGET} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "")
+    target_include_directories(${x_TARGET} SYSTEM INTERFACE ${directories})
+  endif()
+endfunction()
+
+function(GenericFindDependency)
+  set(argOptions "REQUIRED" "SYSTEM_INCLUDES")
+  set(argSingleArguments "TARGET" "PREFER" "SOURCE_DIR" "SYSTEM_HEADER_FILE" "SYSTEM_LIB_NAMES")
+  set(argMultiArguments "EXCLUDE")
+
+  cmake_parse_arguments(x "${argOptions}" "${argSingleArguments}" "${argMultiArguments}" ${ARGN})
+
+  if(x_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unexpected unparsed arguments ${x_UNPARSED_ARGUMENTS}")
+  endif()
+
+  if(TARGET ${x_TARGET})
+    # Target already defined, no need to do anything more
+    return()
+  endif()
+
+  # Generate a list of locations to search for the dependency in order of preference
+  setup_search_locations()
+
+  foreach(LOCATION ${x_Locations})
+    if (${LOCATION} STREQUAL "source")
+      # Try looking for bundled source code
+
+      # Set up search locations for source code
+      create_source_search_paths()
+
+      # Look for a suitably named directory which contains a CMakeLists.txt, try to add it
+      search_dependency_source(
+          TARGET "${x_TARGET}"
+          SOURCE_SEARCH_PATHS "${x_SOURCE_SEARCH_PATHS}"
+          )
+      
+      # If the expected target was created we have succeeded
+      if(TARGET ${x_TARGET})
+        message(STATUS "Using dependency ${x_TARGET} from bundled source code")
+        break()
+      endif()
+    else()
+      # Try looking for a header file and library in the system paths
+
+      if(NOT x_SYSTEM_HEADER_FILE)
+        # Use a sensible header file name if not explicitly set
+        set(x_SYSTEM_HEADER_FILE "lib${x_TARGET}/${x_TARGET}.h")
+      endif()
+
+      # Look for common library naming patterns
+      set(x_SYSTEM_LIB_NAMES "${x_SystemLibName}" "${x_TARGET}" "lib${x_TARGET}")
+
+      # Search either system libraries or sysroot, this is handled by cmake itself
+      search_dependency_system(
+          TARGET "${x_TARGET}"
+          SYSTEM_HEADER_FILE "${x_SYSTEM_HEADER_FILE}"
+          SYSTEM_LIB_NAMES "${x_SYSTEM_LIB_NAMES}"
+          )
+
+      # If the target was found we have succeeded
+      if(TARGET ${x_TARGET})
+        message(STATUS "Using dependency ${x_TARGET} from system")
+        break()
+      endif()
+    endif()
+  endforeach()
+
+  # Final validation that the target was properly created from some source
+  if(TARGET ${x_TARGET})
+    if(x_SYSTEM_INCLUDES)
+      if(NOT CMAKE_CROSSCOMPILING OR THIRD_PARTY_INCLUDES_AS_SYSTEM)
+        mark_target_as_system_includes(${x_TARGET})
+      endif()
+    endif()
+  else()
+    # Target not found in any location
+    if(x_REQUIRED OR ${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find REQUIRED dependency ${x_TARGET} in any available location")
+    else()
+      message(WARNING "Could not find dependency ${x_TARGET} in any available location")
+    endif()
+  endif()
+endfunction()
+    
diff --git a/SwiftCmakeOptions.cmake b/SwiftCmakeOptions.cmake
new file mode 100644
index 0000000..17af973
--- /dev/null
+++ b/SwiftCmakeOptions.cmake
@@ -0,0 +1,262 @@
+# Standard options for Swift cmake based project
+#
+# This module sets up cmake options for whatever features a project has.
+# Supports the following features:
+#
+# - Tests
+# - Test libraries for use by other projects
+# - Documentation
+# - Examples
+#
+# CMake options are set up with the names
+# - {project_name}_ENABLE_{feature}
+#
+# For example:
+# - libsbp_ENABLE_TESTS
+# - albatross_ENABLE_EXAMPLES
+#
+# Options are enabled by default but can be set on the command line at 
+# configure time, eg
+#
+# cmake -Dlibsbp_ENABLE_TESTS=OFF <path>
+#
+# They can also be disabled in CMakeLists.txt in a superproject, eg.
+#
+# ...
+# option(libsbp_ENABLE_TESTS "" OFF)
+# find_package(libsbp)
+# ...
+#
+# Usage:
+# Import this module and call the function swift_create_project_options 
+# specifying what features are available in the package. eg
+#
+# project(libsbp)
+# include(SwiftCmakeOptions)
+# swift_create_project_options(HAS_TESTS HAS_DOCS)
+#
+# Test components.
+# The TEST and TEST_LIBS features have some extra processing. They will
+# be automatically disabled when cross compiling, regardless of whether
+# they are explicitly enabled or not. This behaviour can be disabled
+# by passing the option SKIP_CROSS_COMPILING_CHECK. For example
+#
+# swift_create_project_options(HAS_TESTS SKIP_CROSS_COMPILING_CHECK)
+#
+# will enable unit tests and test libraries even when cross compiling.
+#
+# Conversely, the option DISABLE_TEST_COMPONENTS can be used to force
+# unit tests and test libraries to always be disabled, ignore any user
+# preference. For example
+#
+# swift_create_project_options(HAS_TESTS DISABLE_TEST_COMPONENTS TRUE)
+#
+# will disable unit tests and test libraries even if the user has
+# requested them. This is useful so a project can disable test components
+# based on other conditions that this module is not aware of, such as
+# when using a particular compiler. The following example will always
+# disable test components when using the Visual Studio compiler
+#
+# set(disable_tests FALSE)
+# if(MSVC)
+#   set(disable_tests TRUE)
+# endif()
+# swift_create_project_options(HAS_TESTS DISABLE_TEST_COMPONENTS ${disable_tests})
+#
+# A list of dependencies for test components can be specified using the 
+# TEST_PACKAGES option. Pass a list of packages which will be searched for
+# using the find_package() cmake function. If any of the packages is not
+# found the unit tests will be disabled
+#
+# swift_create_project_options(HAS_TESTS TEST_PACKAGES "Googletest" "RapidCheck")
+#
+# Similarly, the TEST_LIBS_PACKAGES can be used to specify the dependencies
+# of the test libraries. If takes the same behaviour as the TEST_PACKAGES library
+# except it will only disable the test libraries feature if requirements are not
+# met. If this option is not specified it assumes the same value as TEST_PACKAGES
+#
+# The following test packages are currently supported:
+#
+# - Googletest (targets gtest etc)
+# - RapidCheck
+# - GFlags
+# - Json
+# - Yaml-Cpp
+# - FastCSV
+#
+# Finally, this function will use the current project name as a prefix
+# to all options and output variables. This can be overridden by
+# passing the PROJECT option
+#
+# swift_create_project_options(PROJECT test_project HAS_TESTS)
+#
+# will create an option called test_project_ENABLE_TESTS
+#
+# After processing this function sets several cache variables which can
+# be used elsewhere to determine which targets to compile. The output
+# cache variable name is in the form {project}_BUILD_{feature}. eg
+#
+# libsbp_BUILD_TESTS
+# albatross_BUILD_EXAMPLES
+#
+# This can be used in CMakeLists.txt to selective compile targets eg.
+#
+# if(libsbp_BUILD_TESTS)
+#   add_executable(libsbp-test <sources>)
+# endif()
+#
+# or include subdirectories
+#
+# if(albatross_BUILD_EXAMPLES)
+#   add_subdirectory(examples)
+# endif()
+#
+# or any other valid cmake construct.
+#
+
+function(verify_test_dependencies)
+  cmake_parse_arguments(x "" "" "TEST_PACKAGES" ${ARGN})
+
+  set(dependencies_available ON PARENT_SCOPE)
+  if(x_TEST_PACKAGES)
+    foreach(P ${x_TEST_PACKAGES})
+      find_package(${P})
+      # Annoyingly, different test packages have different ways of reporting they were found
+      set(found FALSE)
+      if(${P} STREQUAL "Check" AND CHECK_FOUND)
+        set(found TRUE)
+      elseif(${P} STREQUAL "Googletest" AND TARGET gtest)
+        set(found TRUE)
+      elseif(${P} STREQUAL "RapidCheck" AND TARGET rapidcheck)
+        set(found TRUE)
+      elseif(${P} STREQUAL "GFlags" AND TARGET gflags)
+        set(found TRUE)
+      elseif(${P} STREQUAL "Json" AND TARGET nlohmann_json)
+        set(found TRUE)
+      elseif(${P} STREQUAL "Yaml-Cpp" AND TARGET yaml-cpp)
+        set(found TRUE)
+      elseif(${P} STREQUAL "FastCSV" AND TARGET fast-csv)
+        set(found TRUE)
+      endif()
+      if(NOT found)
+        message(STATUS "Disable tests because dependency ${P} was not found")
+        set(dependencies_available OFF PARENT_SCOPE)
+      endif()
+    endforeach()
+  endif()
+endfunction()
+
+
+function(swift_create_project_options)
+  set(argOptions "HAS_TESTS" "HAS_TEST_LIBS" "HAS_DOCS" "HAS_EXAMPLES" "SKIP_CROSS_COMPILING_CHECK")
+  set(argSingleArguments "PROJECT" "DISABLE_TEST_COMPONENTS")
+  set(argMultiArguments "TEST_PACKAGES" "TEST_LIBS_PACKAGES")
+
+  cmake_parse_arguments(x "${argOptions}" "${argSingleArguments}" "${argMultiArguments}" ${ARGN})
+
+  if(x_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unexpected extra arguments in swift_create_project_options: ${x_UNPARSED_ARGUMENTS}")
+  endif()
+
+  if(NOT x_PROJECT)
+    set(x_PROJECT ${PROJECT_NAME})
+  endif()
+
+  set(tests_possible ON)
+  set(test_libs_possible ON)
+  if(x_DISABLE_TEST_COMPONENTS)
+    message(STATUS "Test components disabled by project")
+    set(tests_possible OFF)
+    set(test_libs_possible OFF)
+  endif()
+
+  if(NOT x_SKIP_CROSS_COMPILING_CHECK)
+    if(CMAKE_CROSSCOMPILING)
+      # Don't compile any test stuff if we are cross compiling
+      message(STATUS "Skipping unit tests because we are cross compiling")
+      set(tests_possible OFF)
+      set(test_libs_possible OFF)
+    endif()
+  endif()
+
+  set(build_tests FALSE)
+  set(build_test_libs FALSE)
+
+  if(x_HAS_TESTS)
+    option(${x_PROJECT}_ENABLE_TESTS "Enable build of unit tests for ${x_PROJECT}" ${tests_possible})
+    if(${x_PROJECT}_ENABLE_TESTS)
+      if(tests_possible)
+        set(build_tests TRUE)
+      endif()
+    endif()
+  endif()
+
+  if(x_HAS_TEST_LIBS)
+    option(${x_PROJECT}_ENABLE_TEST_LIBS "Enable build of test libraries for ${x_PROJECT}" ${test_libs_possible})
+    if(${x_PROJECT}_ENABLE_TEST_LIBS)
+      if(test_libs_possible)
+        set(build_test_libs TRUE)
+      endif()
+    endif()
+  endif()
+
+  if(build_tests)
+    verify_test_dependencies(TEST_PACKAGES ${x_TEST_PACKAGES})
+
+    if(NOT dependencies_available)
+      set(build_tests OFF)
+    endif()
+  endif()
+
+  if(build_test_libs)
+    if(x_TEST_LIBS_PACKAGES)
+      verify_test_dependencies(TEST_PACKAGES ${x_TEST_LIBS_PACKAGES})
+    else()
+      verify_test_dependencies(TEST_PACKAGES ${x_TEST_PACKAGES})
+    endif()
+
+    if(NOT dependencies_available)
+      set(build_test_libs OFF)
+    endif()
+  endif()
+
+  if(x_HAS_TESTS)
+    if(build_tests)
+      set(${x_PROJECT}_BUILD_TESTS TRUE CACHE BOOL "Build unit tests for ${x_PROJECT}")
+    else()
+      message(STATUS "${x_PROJECT} unit tests are DISABLED")
+    endif()
+  endif()
+
+  if(x_HAS_TEST_LIBS)
+    if(build_test_libs)
+      set(${x_PROJECT}_BUILD_TEST_LIBS TRUE CACHE BOOL "Build test libraries for ${x_PROJECT}")
+    else()
+      message(STATUS "${x_PROJECT} test libraries are DISABLED")
+    endif()
+  endif()
+
+  if(x_HAS_DOCS)
+    option(${x_PROJECT}_ENABLE_DOCS "Enable build of documentation for ${x_PROJECT}" ON)
+    set(${x_PROJECT}_BUILD_DOCS ${${x_PROJECT}_ENABLE_DOCS} CACHE BOOL "Build documentation for ${x_PROJECT}")
+    if(NOT ${x_PROJECT}_BUILD_DOCS)
+      message(STATUS "${x_PROJECT} documentation is DISABLED")
+    endif()
+  endif()
+
+  if(x_HAS_EXAMPLES)
+    option(${x_PROJECT}_ENABLE_EXAMPLES "Enable build of example code for ${x_PROJECT}" ON)
+    set(${x_PROJECT}_BUILD_EXAMPLES ${${x_PROJECT}_ENABLE_EXAMPLES} CACHE BOOL "Build examples for ${x_PROJECT}")
+    if(NOT ${x_PROJECT}_BUILD_EXAMPLES)
+      message(STATUS "${x_PROJECT} examples are DISABLED")
+    endif()
+  endif()
+
+  foreach(feat "TESTS" "TEST_LIBS" "DOCS" "EXAMPLES")
+    if(DEFINED ${x_PROJECT}_ENABLE_${feat} AND NOT x_HAS_${feat})
+      message(WARNING "${x_PROJECT}_ENABLE_${feat} is set but the package does not support it")
+    endif()
+  endforeach()
+
+endfunction()
+