.clang-format

+---
+# Mapbox.Variant C/C+ style
+Language:        Cpp
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+ColumnLimit:     0
+CommentPragmas:  '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IndentCaseLabels: false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes: false
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        4
+UseTab:          Never

.clang-tidy

+---
+Checks:          '*,-cert-err58-cpp'
+WarningsAsErrors: '*'
+HeaderFilterRegex: '\/include\/'
+AnalyzeTemporaryDtors: false
+CheckOptions:    
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '1'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
+  - key:             modernize-loop-convert.MaxCopySize
+    value:           '16'
+  - key:             modernize-loop-convert.MinConfidence
+    value:           reasonable
+  - key:             modernize-loop-convert.NamingStyle
+    value:           CamelCase
+  - key:             modernize-pass-by-value.IncludeStyle
+    value:           llvm
+  - key:             modernize-replace-auto-ptr.IncludeStyle
+    value:           llvm
+  - key:             modernize-use-nullptr.NullMacros
+    value:           'NULL'
+...
+

.gitignore

 mason_packages
-test
+cmake-build
+.toolchain
+.mason
+local.env

.gitmodules

-[submodule ".mason"]
-	path = .mason
-	url = https://github.com/mapbox/mason.git

.travis.yml

 language: generic
-sudo: false
 
 matrix:
   include:
+    # clang-tidy/format specific job
+    - os: linux
+      sudo: false
+      env: CLANG_FORMAT CLANG_TIDY
+      addons:
+        apt:
+          sources: [ 'ubuntu-toolchain-r-test' ]
+          packages: [ 'libstdc++6', 'libstdc++-5-dev' ]
+      script:
+        - make tidy
+        - make format
     - os: linux
+      sudo: false
       env: CXX=g++-4.9
       addons:
         apt:
           sources: [ 'ubuntu-toolchain-r-test' ]
           packages: [ 'g++-4.9' ]
     - os: linux
+      sudo: false
       env: CXX=g++-5
       addons:
         apt:
           sources: [ 'ubuntu-toolchain-r-test' ]
           packages: [ 'g++-5' ]
     - os: linux
-      env: CXX=g++-6
+      sudo: false
+      env: CXX=clang++
       addons:
         apt:
           sources: [ 'ubuntu-toolchain-r-test' ]
-          packages: [ 'g++-6' ]
+          packages: [ 'libstdc++6', 'libstdc++-5-dev' ]
     - os: linux
-      env: CXX=clang++-3.8
+      sudo: required
+      env: CXXFLAGS="-fsanitize=address,undefined,integer -fno-sanitize-recover=all"
       addons:
         apt:
           sources: [ 'ubuntu-toolchain-r-test' ]
-          packages: [ 'libstdc++-4.9-dev' ]
-      before_script:
-        - git submodule update --init
-        - .mason/mason install clang++ 3.8.1
-        - export PATH=$(.mason/mason prefix clang++ 3.8.1)/bin:$PATH
+          packages: [ 'libstdc++6', 'libstdc++-5-dev' ]
+    # coverage build
     - os: linux
-      env: CXX=clang++-3.9
+      sudo: false
+      env: CXXFLAGS="--coverage" LDFLAGS="--coverage"
       addons:
         apt:
           sources: [ 'ubuntu-toolchain-r-test' ]
-          packages: [ 'libstdc++-4.9-dev' ]
-      before_script:
-        - git submodule update --init
-        - .mason/mason install clang++ 3.9.1
-        - export PATH=$(.mason/mason prefix clang++ 3.9.1)/bin:$PATH
-    - os: osx
-      osx_image: xcode7.3
+          packages: [ 'libstdc++6', 'libstdc++-5-dev' ]
+      script:
+        - make debug
+        - make test
+        # MASON_LLVM_RELEASE comes from the setup.sh script
+        - mason install llvm-cov ${MASON_LLVM_RELEASE}
+        - mason link llvm-cov ${MASON_LLVM_RELEASE}
+        - curl -S -f https://codecov.io/bash -o codecov
+        - chmod +x codecov
+        - ./codecov -x "llvm-cov gcov" -Z
+
+env:
+  global:
+   - CMAKE_VERSION="3.8.2"
 
-cache: apt
+install:
+  # set up the environment by installing mason and clang++
+  - ./scripts/setup.sh --config local.env
+  # put mason and clang++ on PATH
+  - source local.env
+  - mason install cmake ${CMAKE_VERSION}
+  - mason link cmake ${CMAKE_VERSION}
+  - which cmake
 
 script:
+  - make release
+  - make test
+  - make clean
+  - make debug
   - make test
+  - make clean

CMakeLists.txt

+cmake_minimum_required(VERSION 3.8)
+project(hpp_skel LANGUAGES CXX)
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED on)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/mason.cmake)
+
+option(WERROR "Add -Werror flag to build (turns warnings into errors)" ON)
+
+# configure optimization
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(OPTIMIZATION_FLAGS "-O0 -DDEBUG")
+    message("-- Configuring debug build")
+else()
+    set(OPTIMIZATION_FLAGS "-O3 -DNDEBUG")
+    message("-- Configuring release build")
+endif()
+
+# Enable extra warnings to adhere to https://github.com/mapbox/cpp/issues/37
+set(DESIRED_WARNINGS "-Wall -Wextra -Wconversion -Wunreachable-code -Wuninitialized -pedantic-errors -Wold-style-cast -Wno-error=unused-variable -Wshadow -Wfloat-equal -Weffc++")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  set(DESIRED_WARNINGS "${DESIRED_WARNINGS} -Wmost")
+endif()
+
+# Note: -D_GLIBCXX_USE_CXX11_ABI=0 is needed to support mason packages that are precompiled libs
+# Currently we only depend on a header only library, but this will help avoid issues when more libs are added via mason
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPTIMIZATION_FLAGS} -D_GLIBCXX_USE_CXX11_ABI=0 ${DESIRED_WARNINGS}")
+
+if (WERROR)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+endif()
+
+# mason_use is a mason function within the mason.cmake file and provides ready-to-go vars, like "STATIC_LIBS" and "INCLUDE_DIRS"
+mason_use(catch VERSION 1.9.6 HEADER_ONLY)
+include_directories(SYSTEM ${MASON_PACKAGE_catch_INCLUDE_DIRS})
+
+mason_use(benchmark VERSION 1.2.0)
+include_directories(SYSTEM ${MASON_PACKAGE_benchmark_INCLUDE_DIRS})
+
+mason_use(variant VERSION 1.1.5 HEADER_ONLY)
+include_directories(SYSTEM ${MASON_PACKAGE_variant_INCLUDE_DIRS})
+
+include_directories("${PROJECT_SOURCE_DIR}/include")
+
+file(GLOB TEST_SOURCES test/*.cpp)
+add_executable(unit-tests ${TEST_SOURCES})
+
+# libbenchmark.a supports threads and therefore needs pthread support
+find_package(Threads REQUIRED)
+file(GLOB BENCH_SOURCES bench/*.cpp)
+add_executable(bench-tests ${BENCH_SOURCES})
+
+# link benchmark static library to the bench-tests binary so the bench tests know where to find the benchmark impl code
+target_link_libraries(bench-tests ${MASON_PACKAGE_benchmark_STATIC_LIBS} ${CMAKE_THREAD_LIBS_INIT})

Makefile

-CXXFLAGS += -I include -std=c++14 -DDEBUG -O0 -Wall -Wextra -Werror
-MASON ?= .mason/mason
 
-VARIANT = 1.1.4
+# Whether to turn compiler warnings into errors
+export WERROR ?= true
+export BUILD_DIR ?= cmake-build
 
-default: test
+default: release
 
-$(MASON):
-	git submodule update --init
+release:
+	mkdir -p ./$(BUILD_DIR) && cd ./$(BUILD_DIR) && cmake ../ -DCMAKE_BUILD_TYPE=Release -DWERROR=$(WERROR) && VERBOSE=1 cmake --build .
 
-mason_packages/headers/variant/$(VARIANT):
-	$(MASON) install variant $(VARIANT)
+debug:
+	mkdir -p ./$(BUILD_DIR) && cd ./$(BUILD_DIR) && cmake ../ -DCMAKE_BUILD_TYPE=Debug -DWERROR=$(WERROR) && VERBOSE=1 cmake --build .
 
-test: tests/* include/mapbox/geometry/* mason_packages/headers/variant/$(VARIANT) Makefile
-	$(CXX) tests/*.cpp $(CXXFLAGS) `$(MASON) cflags variant $(VARIANT)` -o test
-	./test
+test:
+	@if [ -f ./$(BUILD_DIR)/unit-tests ]; then ./$(BUILD_DIR)/unit-tests; else echo "Please run 'make release' or 'make debug' first" && exit 1; fi
+
+bench:
+	@if [ -f ./$(BUILD_DIR)/bench-tests ]; then ./$(BUILD_DIR)/bench-tests; else echo "Please run 'make release' or 'make debug' first" && exit 1; fi
+
+tidy:
+	./scripts/clang-tidy.sh
+
+coverage:
+	./scripts/coverage.sh
 
 clean:
-	rm -f test
+	rm -rf ./$(BUILD_DIR)
+	rm -f *.profraw
+	rm -f *.profdata
+	@echo "run 'make distclean' to also clear mason_packages, .mason, and .toolchain directories"
+
+distclean: clean
+	rm -rf mason_packages
+	rm -rf .mason
+	rm -rf .toolchain
+	rm -f local.env
+
+format:
+	./scripts/format.sh
+
+.PHONY: test bench

README.md

 # geometry.hpp
 
+[![badge](https://mapbox.s3.amazonaws.com/cpp-assets/hpp-skel-badge_blue.svg)](https://github.com/mapbox/hpp-skel)
+
 Provides header-only, generic C++ interfaces for geometry types, geometry collections, and features.
 
  - `mapbox::geometry::point`
@@ -9,7 +11,7 @@ Provides header-only, generic C++ interfaces for geometry types, geometry collec
  - `mapbox::geometry::polygon`
  - `mapbox::geometry::multi_polygon`
  - `mapbox::geometry::geometry_collection`
- - `mapbox::geometry::feature` (experimental)
+ - `mapbox::feature::feature` (experimental)
 
 ### Design
 

bench/geometry.cpp

+#include <benchmark/benchmark.h>
+#include <mapbox/geometry.hpp>
+#include <random>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+static void BM_polygon_allocation(benchmark::State& state) // NOLINT google-runtime-references
+{
+    std::size_t s = state.range(0);
+    std::default_random_engine generator;
+    std::uniform_int_distribution<int> distribution(-99, 99);
+    auto dice = std::bind(distribution, generator);
+    while (state.KeepRunning())
+    {
+        mapbox::geometry::linear_ring<std::int64_t> r;
+        r.reserve(s);
+        r.emplace_back(dice(), dice());
+    }
+    state.SetLabel(std::to_string((s * 16) / 1024) + "kb");
+}
+
+BENCHMARK(BM_polygon_allocation)->Range(1024, 1 << 29);
+
+#pragma GCC diagnostic pop

bench/main.cpp

+#include <benchmark/benchmark.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+BENCHMARK_MAIN();
+#pragma GCC diagnostic pop

cmake/mason.cmake

+string(RANDOM LENGTH 16 MASON_INVOCATION)
+
+# Directory where Mason packages are located; typically ends with mason_packages
+if (NOT MASON_PACKAGE_DIR)
+    set(MASON_PACKAGE_DIR "${CMAKE_SOURCE_DIR}/mason_packages")
+endif()
+
+# URL prefix of where packages are located.
+if (NOT MASON_REPOSITORY)
+    set(MASON_REPOSITORY "https://mason-binaries.s3.amazonaws.com")
+endif()
+
+# Path to Mason executable
+if (NOT MASON_COMMAND)
+    set(MASON_COMMAND "${CMAKE_SOURCE_DIR}/.mason/mason")
+endif()
+
+# Determine platform
+# we call uname -s manually here since
+# CMAKE_HOST_SYSTEM_NAME will not be defined before the project() call
+execute_process(
+    COMMAND uname -s
+    OUTPUT_VARIABLE UNAME_S
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+if(NOT MASON_PLATFORM)
+    if (UNAME_S STREQUAL "Darwin")
+        set(MASON_PLATFORM "macos")
+    else()
+        set(MASON_PLATFORM "linux")
+    endif()
+endif()
+
+
+# Determine platform version string
+if(MASON_PLATFORM STREQUAL "ios")
+    set(MASON_PLATFORM_VERSION "8.0") # Deployment target version
+elseif(MASON_PLATFORM STREQUAL "android")
+    if (ANDROID_ABI STREQUAL "armeabi")
+        set(MASON_PLATFORM_VERSION "arm-v5-9")
+    elseif(ANDROID_ABI STREQUAL "arm64-v8a")
+        set(MASON_PLATFORM_VERSION "arm-v8-21")
+    elseif(ANDROID_ABI STREQUAL "x86")
+        set(MASON_PLATFORM_VERSION "x86-9")
+    elseif(ANDROID_ABI STREQUAL "x86_64")
+        set(MASON_PLATFORM_VERSION "x86-64-21")
+    elseif(ANDROID_ABI STREQUAL "mips")
+        set(MASON_PLATFORM_VERSION "mips-9")
+    elseif(ANDROID_ABI STREQUAL "mips64")
+        set(MASON_PLATFORM_VERSION "mips64-21")
+    else()
+        set(MASON_PLATFORM_VERSION "arm-v7-9")
+    endif()
+elseif(NOT MASON_PLATFORM_VERSION)
+    execute_process(
+        COMMAND uname -m
+        OUTPUT_VARIABLE MASON_PLATFORM_VERSION
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+endif()
+
+if(MASON_PLATFORM STREQUAL "macos")
+    set(MASON_PLATFORM "osx")
+endif()
+
+set(ENV{MASON_PLATFORM} "${MASON_PLATFORM}")
+set(ENV{MASON_PLATFORM_VERSION} "${MASON_PLATFORM_VERSION}")
+
+include(CMakeParseArguments)
+
+function(mason_use _PACKAGE)
+    if(NOT _PACKAGE)
+        message(FATAL_ERROR "[Mason] No package name given")
+    endif()
+
+    cmake_parse_arguments("" "HEADER_ONLY" "VERSION" "" ${ARGN})
+
+    if(_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "[Mason] mason_use() called with unrecognized arguments: ${_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT _VERSION)
+        message(FATAL_ERROR "[Mason] Specifying a version is required")
+    endif()
+
+    if(MASON_PACKAGE_${_PACKAGE}_INVOCATION STREQUAL "${MASON_INVOCATION}")
+        # Check that the previous invocation of mason_use didn't select another version of this package
+        if(NOT MASON_PACKAGE_${_PACKAGE}_VERSION STREQUAL ${_VERSION})
+            message(FATAL_ERROR "[Mason] Already using ${_PACKAGE} ${MASON_PACKAGE_${_PACKAGE}_VERSION}. Cannot select version ${_VERSION}.")
+        endif()
+    else()
+        if(_HEADER_ONLY)
+            set(_PLATFORM_ID "headers")
+        else()
+            set(_PLATFORM_ID "${MASON_PLATFORM}-${MASON_PLATFORM_VERSION}")
+        endif()
+
+        set(_SLUG "${_PLATFORM_ID}/${_PACKAGE}/${_VERSION}")
+        set(_INSTALL_PATH "${MASON_PACKAGE_DIR}/${_SLUG}")
+        file(RELATIVE_PATH _INSTALL_PATH_RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${_INSTALL_PATH}")
+
+        if(NOT EXISTS "${_INSTALL_PATH}")
+            set(_CACHE_PATH "${MASON_PACKAGE_DIR}/.binaries/${_SLUG}.tar.gz")
+            if (NOT EXISTS "${_CACHE_PATH}")
+                # Download the package
+                set(_URL "${MASON_REPOSITORY}/${_SLUG}.tar.gz")
+                message(STATUS "[Mason] Downloading package ${_URL}...")
+
+                set(_FAILED)
+                set(_ERROR)
+                # Note: some CMake versions are compiled without SSL support
+                get_filename_component(_CACHE_DIR "${_CACHE_PATH}" DIRECTORY)
+                file(MAKE_DIRECTORY "${_CACHE_DIR}")
+                execute_process(
+                    COMMAND curl --retry 3 -s -f -S -L "${_URL}" -o "${_CACHE_PATH}.tmp"
+                    RESULT_VARIABLE _FAILED
+                    ERROR_VARIABLE _ERROR)
+                if(_FAILED)
+                    message(FATAL_ERROR "[Mason] Failed to download ${_URL}: ${_ERROR}")
+                else()
+                    # We downloaded to a temporary file to prevent half-finished downloads
+                    file(RENAME "${_CACHE_PATH}.tmp" "${_CACHE_PATH}")
+                endif()
+            endif()
+
+            # Unpack the package
+            message(STATUS "[Mason] Unpacking package to ${_INSTALL_PATH_RELATIVE}...")
+            file(MAKE_DIRECTORY "${_INSTALL_PATH}")
+            execute_process(
+                COMMAND ${CMAKE_COMMAND} -E tar xzf "${_CACHE_PATH}"
+                WORKING_DIRECTORY "${_INSTALL_PATH}")
+        endif()
+
+        # Create a config file if it doesn't exist in the package
+        # TODO: remove this once all packages have a mason.ini file
+        if(NOT EXISTS "${_INSTALL_PATH}/mason.ini")
+            # Change pkg-config files
+            file(GLOB_RECURSE _PKGCONFIG_FILES "${_INSTALL_PATH}/*.pc")
+            foreach(_PKGCONFIG_FILE IN ITEMS ${_PKGCONFIG_FILES})
+                file(READ "${_PKGCONFIG_FILE}" _PKGCONFIG_FILE_CONTENT)
+                string(REGEX REPLACE "(^|\n)prefix=[^\n]*" "\\1prefix=${_INSTALL_PATH}" _PKGCONFIG_FILE_CONTENT "${_PKGCONFIG_FILE_CONTENT}")
+                file(WRITE "${_PKGCONFIG_FILE}" "${_PKGCONFIG_FILE_CONTENT}")
+            endforeach()
+
+            if(NOT EXISTS "${MASON_COMMAND}")
+                message(FATAL_ERROR "[Mason] Could not find Mason command at ${MASON_COMMAND}")
+            endif()
+
+            set(_FAILED)
+            set(_ERROR)
+            execute_process(
+                COMMAND ${MASON_COMMAND} config ${_PACKAGE} ${_VERSION}
+                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                OUTPUT_FILE "${_INSTALL_PATH}/mason.ini"
+                RESULT_VARIABLE _FAILED
+                ERROR_VARIABLE _ERROR)
+            if(_FAILED)
+                message(FATAL_ERROR "[Mason] Could not get configuration for package ${_PACKAGE} ${_VERSION}: ${_ERROR}")
+            endif()
+        endif()
+
+        set(MASON_PACKAGE_${_PACKAGE}_PREFIX "${_INSTALL_PATH}" CACHE STRING "${_PACKAGE} ${_INSTALL_PATH}" FORCE)
+        mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_PREFIX)
+
+        # Load the configuration from the ini file
+        file(STRINGS "${_INSTALL_PATH}/mason.ini" _CONFIG_FILE)
+        foreach(_LINE IN LISTS _CONFIG_FILE)
+            string(REGEX MATCH "^([a-z_]+) *= *" _KEY "${_LINE}")
+            if (_KEY)
+                string(LENGTH "${_KEY}" _KEY_LENGTH)
+                string(SUBSTRING "${_LINE}" ${_KEY_LENGTH} -1 _VALUE)
+                string(REGEX REPLACE ";.*$" "" _VALUE "${_VALUE}") # Trim trailing commas
+                string(REPLACE "{prefix}" "${_INSTALL_PATH}" _VALUE "${_VALUE}")
+                string(STRIP "${_VALUE}" _VALUE)
+                string(REPLACE "=" "" _KEY "${_KEY}")
+                string(STRIP "${_KEY}" _KEY)
+                string(TOUPPER "${_KEY}" _KEY)
+                if(_KEY STREQUAL "INCLUDE_DIRS" OR _KEY STREQUAL "STATIC_LIBS" )
+                    separate_arguments(_VALUE)
+                endif()
+                set(MASON_PACKAGE_${_PACKAGE}_${_KEY} "${_VALUE}" CACHE STRING "${_PACKAGE} ${_KEY}" FORCE)
+                mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_${_KEY})
+            endif()
+        endforeach()
+
+        # Compare version in the package to catch errors early on
+        if(NOT _VERSION STREQUAL MASON_PACKAGE_${_PACKAGE}_VERSION)
+            message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has version '${MASON_PACKAGE_${_PACKAGE}_VERSION}', but required '${_VERSION}'")
+        endif()
+
+        if(NOT _PACKAGE STREQUAL MASON_PACKAGE_${_PACKAGE}_NAME)
+            message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has name '${MASON_PACKAGE_${_PACKAGE}_NAME}', but required '${_NAME}'")
+        endif()
+
+        if(NOT _HEADER_ONLY)
+            if(NOT MASON_PLATFORM STREQUAL MASON_PACKAGE_${_PACKAGE}_PLATFORM)
+                message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has platform '${MASON_PACKAGE_${_PACKAGE}_PLATFORM}', but required '${MASON_PLATFORM}'")
+            endif()
+
+            if(NOT MASON_PLATFORM_VERSION STREQUAL MASON_PACKAGE_${_PACKAGE}_PLATFORM_VERSION)
+                message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has platform version '${MASON_PACKAGE_${_PACKAGE}_PLATFORM_VERSION}', but required '${MASON_PLATFORM_VERSION}'")
+            endif()
+        endif()
+
+        # Concatenate the static libs and libraries
+        set(_LIBRARIES)
+        list(APPEND _LIBRARIES ${MASON_PACKAGE_${_PACKAGE}_STATIC_LIBS} ${MASON_PACKAGE_${_PACKAGE}_LDFLAGS})
+        set(MASON_PACKAGE_${_PACKAGE}_LIBRARIES "${_LIBRARIES}" CACHE STRING "${_PACKAGE} _LIBRARIES" FORCE)
+        mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_LIBRARIES)
+
+        if(NOT _HEADER_ONLY)
+            string(REGEX MATCHALL "(^| +)-L *([^ ]+)" MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS "${MASON_PACKAGE_${_PACKAGE}_LDFLAGS}")
+            string(REGEX REPLACE "(^| +)-L *" "\\1" MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS "${MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS}")
+            set(MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS "${MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS}" CACHE STRING "${_PACKAGE} ${MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS}" FORCE)
+            mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS)
+        endif()
+
+        # Store invocation ID to prevent different versions of the same package in one invocation
+        set(MASON_PACKAGE_${_PACKAGE}_INVOCATION "${MASON_INVOCATION}" CACHE INTERNAL "${_PACKAGE} invocation ID" FORCE)
+    endif()
+endfunction()
+
+macro(target_add_mason_package _TARGET _VISIBILITY _PACKAGE)
+    if (NOT MASON_PACKAGE_${_PACKAGE}_INVOCATION)
+        message(FATAL_ERROR "[Mason] Package ${_PACKAGE} has not been initialized yet")
+    endif()
+
+    target_include_directories(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_INCLUDE_DIRS}")
+    target_compile_definitions(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_DEFINITIONS}")
+    target_compile_options(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_OPTIONS}")
+    target_link_libraries(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_LIBRARIES}")
+endmacro()

codecov.yml

+ignore:
+  - "bench"
+  - "test"
\ No newline at end of file

debian/changelog

-mapbox-geometry (0.9.3-3) UNRELEASED; urgency=medium
+mapbox-geometry (1.0.0-1) unstable; urgency=medium
 
+  * New upstream release.
   * Bump Standards-Version to 4.2.1, no changes.
   * Update watch file to limit matches to archive path.
+  * Switch to CMake build system.
+  * Add catch to build dependencies.
+  * Don't build bench-tests, causes FTBFS.
+  * Use Makefile for test target, set expected directory in build target.
 
- -- Bas Couwenberg <sebastic@debian.org>  Sun, 05 Aug 2018 20:26:04 +0200
+ -- Bas Couwenberg <sebastic@debian.org>  Mon, 12 Nov 2018 15:58:32 +0100
 
 mapbox-geometry (0.9.3-2) unstable; urgency=medium
 

debian/control

@@ -4,6 +4,8 @@ Priority: optional
 Maintainer: Debian GIS Project <pkg-grass-devel@lists.alioth.debian.org>
 Uploaders: Bas Couwenberg <sebastic@debian.org>
 Build-Depends: debhelper (>= 9),
+               catch,
+               cmake (>= 3.8),
                libmapbox-variant-dev
 Standards-Version: 4.2.1
 Vcs-Browser: https://salsa.debian.org/debian-gis-team/mapbox-geometry/

debian/patches/no-benchmark.patch

+Description: Don't build bench-tests, causes FTBFS.
+Author: Bas Couwenberg <sebastic@debian.org>
+Forwarded: not-needed
+
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -47,9 +47,9 @@ file(GLOB TEST_SOURCES test/*.cpp)
+ add_executable(unit-tests ${TEST_SOURCES})
+ 
+ # libbenchmark.a supports threads and therefore needs pthread support
+-find_package(Threads REQUIRED)
+-file(GLOB BENCH_SOURCES bench/*.cpp)
+-add_executable(bench-tests ${BENCH_SOURCES})
++#find_package(Threads REQUIRED)
++#file(GLOB BENCH_SOURCES bench/*.cpp)
++#add_executable(bench-tests ${BENCH_SOURCES})
+ 
+ # link benchmark static library to the bench-tests binary so the bench tests know where to find the benchmark impl code
+ #target_link_libraries(bench-tests ${MASON_PACKAGE_benchmark_STATIC_LIBS} ${CMAKE_THREAD_LIBS_INIT})

debian/patches/no-mason.patch

@@ -2,16 +2,32 @@ Description: Disable mason, dependencies are packaged.
 Author: Bas Couwenberg <sebastic@debian.org>
 Forwarded: not-needed
 
---- a/Makefile
-+++ b/Makefile
-@@ -11,8 +11,8 @@ $(MASON):
- mason_packages/headers/variant/$(VARIANT):
- 	$(MASON) install variant $(VARIANT)
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -32,14 +32,14 @@ if (WERROR)
+ endif()
  
--test: tests/* include/mapbox/geometry/* mason_packages/headers/variant/$(VARIANT) Makefile
--	$(CXX) tests/*.cpp $(CXXFLAGS) `$(MASON) cflags variant $(VARIANT)` -o test
-+test: tests/* include/mapbox/geometry/* Makefile
-+	$(CXX) tests/*.cpp $(CXXFLAGS) -o test
- 	./test
+ # mason_use is a mason function within the mason.cmake file and provides ready-to-go vars, like "STATIC_LIBS" and "INCLUDE_DIRS"
+-mason_use(catch VERSION 1.9.6 HEADER_ONLY)
+-include_directories(SYSTEM ${MASON_PACKAGE_catch_INCLUDE_DIRS})
++#mason_use(catch VERSION 1.9.6 HEADER_ONLY)
++#include_directories(SYSTEM ${MASON_PACKAGE_catch_INCLUDE_DIRS})
  
- clean:
+-mason_use(benchmark VERSION 1.2.0)
+-include_directories(SYSTEM ${MASON_PACKAGE_benchmark_INCLUDE_DIRS})
++#mason_use(benchmark VERSION 1.2.0)
++#include_directories(SYSTEM ${MASON_PACKAGE_benchmark_INCLUDE_DIRS})
+ 
+-mason_use(variant VERSION 1.1.5 HEADER_ONLY)
+-include_directories(SYSTEM ${MASON_PACKAGE_variant_INCLUDE_DIRS})
++#mason_use(variant VERSION 1.1.5 HEADER_ONLY)
++#include_directories(SYSTEM ${MASON_PACKAGE_variant_INCLUDE_DIRS})
+ 
+ include_directories("${PROJECT_SOURCE_DIR}/include")
+ 
+@@ -52,4 +52,4 @@ file(GLOB BENCH_SOURCES bench/*.cpp)
+ add_executable(bench-tests ${BENCH_SOURCES})
+ 
+ # link benchmark static library to the bench-tests binary so the bench tests know where to find the benchmark impl code
+-target_link_libraries(bench-tests ${MASON_PACKAGE_benchmark_STATIC_LIBS} ${CMAKE_THREAD_LIBS_INIT})
++#target_link_libraries(bench-tests ${MASON_PACKAGE_benchmark_STATIC_LIBS} ${CMAKE_THREAD_LIBS_INIT})

debian/patches/series

 no-mason.patch
+no-benchmark.patch

debian/rules

@@ -6,4 +6,12 @@
 export DEB_BUILD_MAINT_OPTIONS=hardening=+all
 
 %:
-	dh $@ --parallel
+	dh $@ \
+	      --buildsystem=cmake \
+	      --builddirectory=$(CURDIR)/cmake-build \
+	      --parallel
+
+override_dh_auto_test:
+ifeq (,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
+	$(MAKE) test
+endif

include/mapbox/geometry/feature.hpp → include/mapbox/feature.hpp

 #pragma once
 
-#include <mapbox/geometry/geometry.hpp>
+#include <mapbox/geometry.hpp>
 
 #include <mapbox/variant.hpp>
 
@@ -8,17 +8,14 @@
 #include <string>
 #include <vector>
 #include <unordered_map>
-#include <experimental/optional>
 
 namespace mapbox {
-namespace geometry {
+namespace feature {
 
 struct value;
 
 struct null_value_t
 {
-    constexpr null_value_t() {}
-    constexpr null_value_t(std::nullptr_t) {}
 };
 
 constexpr bool operator==(const null_value_t&, const null_value_t&) { return true; }
@@ -44,7 +41,7 @@ struct value : value_base
 using property_map = std::unordered_map<std::string, value>;
 
 // The same considerations and requirement for numeric types apply as for `value_base`.
-using identifier = mapbox::util::variant<uint64_t, int64_t, double, std::string>;
+using identifier = mapbox::util::variant<null_value_t, uint64_t, int64_t, double, std::string>;
 
 template <class T>
 struct feature
@@ -53,16 +50,34 @@ struct feature
     using geometry_type = mapbox::geometry::geometry<T>; // Fully qualified to avoid GCC -fpermissive error.
 
     geometry_type geometry;
-    property_map properties {};
-    std::experimental::optional<identifier> id {};
-
-    // GCC 4.9 does not support C++14 aggregates with non-static data member
-    // initializers.
-    feature(geometry_type geometry_,
-            property_map properties_ = property_map {},
-            std::experimental::optional<identifier> id_ = std::experimental::optional<identifier> {})
-        : geometry(std::move(geometry_)),
-          properties(std::move(properties_)),
+    property_map properties;
+    identifier id;
+
+    feature()
+        : geometry(),
+          properties(),
+          id() {}
+    feature(geometry_type const& geom_)
+        : geometry(geom_),
+          properties(),
+          id() {}
+    feature(geometry_type&& geom_)
+        : geometry(std::move(geom_)),
+          properties(),
+          id() {}
+    feature(geometry_type const& geom_, property_map const& prop_)
+        : geometry(geom_), properties(prop_), id() {}
+    feature(geometry_type&& geom_, property_map&& prop_)
+        : geometry(std::move(geom_)),
+          properties(std::move(prop_)),
+          id() {}
+    feature(geometry_type const& geom_, property_map const& prop_, identifier const& id_)
+        : geometry(geom_),
+          properties(prop_),
+          id(id_) {}
+    feature(geometry_type&& geom_, property_map&& prop_, identifier&& id_)
+        : geometry(std::move(geom_)),
+          properties(std::move(prop_)),
           id(std::move(id_)) {}
 };
 
@@ -87,10 +102,12 @@ struct feature_collection : Cont<feature<T>>
     using size_type = typename container_type::size_type;
 
     template <class... Args>
-    feature_collection(Args&&... args) : container_type(std::forward<Args>(args)...) {}
+    feature_collection(Args&&... args) : container_type(std::forward<Args>(args)...)
+    {
+    }
     feature_collection(std::initializer_list<feature_type> args)
         : container_type(std::move(args)) {}
 };
 
-} // namespace geometry
+} // namespace feature
 } // namespace mapbox

include/mapbox/geometry.hpp

@@ -7,7 +7,6 @@
 #include <mapbox/geometry/multi_line_string.hpp>
 #include <mapbox/geometry/multi_polygon.hpp>
 #include <mapbox/geometry/geometry.hpp>
-#include <mapbox/geometry/feature.hpp>
 #include <mapbox/geometry/point_arithmetic.hpp>
 #include <mapbox/geometry/for_each_point.hpp>
 #include <mapbox/geometry/envelope.hpp>