From f5aca5d8941a0b2fb87c9560fdb6616fcf088c70 Mon Sep 17 00:00:00 2001 From: Erik Rigtorp Date: Sun, 4 Oct 2026 19:28:30 -0400 Subject: [PATCH 1/3] Modernize CMake packaging and benchmark dependency detection --- CMakeLists.txt | 161 ++++++++++++++++++++--------------- README.md | 40 +++++++++ cmake/HashMapConfig.cmake.in | 4 + src/HashMapBenchmark.cpp | 8 +- vendor/benchmark | 1 - 5 files changed, 141 insertions(+), 73 deletions(-) create mode 100644 cmake/HashMapConfig.cmake.in delete mode 160000 vendor/benchmark diff --git a/CMakeLists.txt b/CMakeLists.txt index c72c478..d0f4583 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,86 +1,111 @@ cmake_minimum_required(VERSION 3.20) -project(HashMap VERSION 1.0 LANGUAGES CXX) +project(HashMap VERSION 1.0.0 LANGUAGES CXX) -add_library(${PROJECT_NAME} INTERFACE) -add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME}) - -target_compile_features(${PROJECT_NAME} INTERFACE cxx_std_14) - -target_include_directories(${PROJECT_NAME} INTERFACE - $ - $) +include(GNUInstallDirs) +include(CMakePackageConfigHelpers) -# Tests and examples +set(HASHMAP_TOP_LEVEL OFF) if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) - if(MSVC) - add_compile_options(/permissive- /W4) - else() - add_compile_options(-Wall -Wextra -Wpedantic) - endif() - - if(NOT WIN32) - find_package(absl) + set(HASHMAP_TOP_LEVEL ON) +endif() - add_executable(HashMapBenchmark src/HashMapBenchmark.cpp) - target_link_libraries(HashMapBenchmark HashMap) - if(absl_FOUND) - target_link_libraries(HashMapBenchmark absl::flat_hash_map) +option(HASHMAP_BUILD_TESTS "Build HashMap tests" ${HASHMAP_TOP_LEVEL}) +option(HASHMAP_BUILD_EXAMPLES "Build HashMap examples" ${HASHMAP_TOP_LEVEL}) +set(HASHMAP_BENCHMARK_DEFAULT ${HASHMAP_TOP_LEVEL}) +if(WIN32) + set(HASHMAP_BENCHMARK_DEFAULT OFF) +endif() +option(HASHMAP_BUILD_BENCHMARKS "Build the POSIX benchmark" ${HASHMAP_BENCHMARK_DEFAULT}) +option(HASHMAP_INSTALL "Generate HashMap install rules" ${HASHMAP_TOP_LEVEL}) +option(HASHMAP_WARNINGS_AS_ERRORS "Treat HashMap executable warnings as errors" OFF) + +add_library(HashMap INTERFACE) +add_library(HashMap::HashMap ALIAS HashMap) +target_compile_features(HashMap INTERFACE cxx_std_14) +target_include_directories(HashMap INTERFACE + "$" + "$") + +function(hashmap_executable target source) + add_executable(${target} ${source}) + target_link_libraries(${target} PRIVATE HashMap::HashMap) + set_target_properties(${target} PROPERTIES CXX_EXTENSIONS OFF) + if(MSVC) + target_compile_options(${target} PRIVATE /permissive- /W4) + if(HASHMAP_WARNINGS_AS_ERRORS) + target_compile_options(${target} PRIVATE /WX) endif() - if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|amd64)$") - target_compile_options(HashMapBenchmark PRIVATE -msse4.2) + elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang") + target_compile_options(${target} PRIVATE -Wall -Wextra -Wpedantic) + if(HASHMAP_WARNINGS_AS_ERRORS) + target_compile_options(${target} PRIVATE -Werror) endif() - target_compile_features(HashMapBenchmark PRIVATE cxx_std_17) endif() +endfunction() - add_executable(HashMapExample src/HashMapExample.cpp) - target_link_libraries(HashMapExample HashMap) - - add_executable(HashMapTest src/HashMapTest.cpp) - target_link_libraries(HashMapTest HashMap) - - enable_testing() - add_test(NAME HashMapTest COMMAND HashMapTest) - if(TARGET HashMapBenchmark) - add_test(NAME HashMapBenchmarkSmoke COMMAND HashMapBenchmark -t 4 -c 1000 -i 1000) +if(HASHMAP_BUILD_TESTS) + include(CTest) + if(BUILD_TESTING) + hashmap_executable(HashMapTest src/HashMapTest.cpp) + add_test(NAME HashMapTest COMMAND HashMapTest) endif() endif() -# Install -include(GNUInstallDirs) -include(CMakePackageConfigHelpers) - -write_basic_package_version_file( - "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake" - COMPATIBILITY SameMajorVersion -) - -export( - TARGETS ${PROJECT_NAME} - NAMESPACE ${PROJECT_NAME}:: - FILE "${PROJECT_NAME}Config.cmake" -) +if(HASHMAP_BUILD_EXAMPLES) + hashmap_executable(HashMapExample src/HashMapExample.cpp) +endif() -if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) - install( - DIRECTORY "include/" - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} - ) +if(HASHMAP_BUILD_BENCHMARKS) + if(WIN32) + message(FATAL_ERROR "HashMapBenchmark requires POSIX; disable HASHMAP_BUILD_BENCHMARKS on Windows") + endif() - install( - TARGETS ${PROJECT_NAME} - EXPORT "${PROJECT_NAME}Config" - INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} - ) + option(HASHMAP_BENCHMARK_WITH_ABSL "Use installed Abseil when available" ON) + option(HASHMAP_BENCHMARK_WITH_SPARSEHASH "Use installed sparsehash when available" ON) + hashmap_executable(HashMapBenchmark src/HashMapBenchmark.cpp) + target_compile_features(HashMapBenchmark PRIVATE cxx_std_17) + if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|amd64)$") + target_compile_options(HashMapBenchmark PRIVATE -msse4.2) + endif() - install( - EXPORT "${PROJECT_NAME}Config" - NAMESPACE ${PROJECT_NAME}:: - DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" - ) + if(HASHMAP_BENCHMARK_WITH_ABSL) + find_package(absl CONFIG QUIET) + if(TARGET absl::flat_hash_map) + target_link_libraries(HashMapBenchmark PRIVATE absl::flat_hash_map) + target_compile_definitions(HashMapBenchmark PRIVATE HASHMAP_BENCHMARK_HAS_ABSL) + endif() + endif() + if(HASHMAP_BENCHMARK_WITH_SPARSEHASH) + find_path(HASHMAP_SPARSEHASH_INCLUDE_DIR NAMES google/dense_hash_map) + mark_as_advanced(HASHMAP_SPARSEHASH_INCLUDE_DIR) + if(HASHMAP_SPARSEHASH_INCLUDE_DIR) + target_include_directories(HashMapBenchmark SYSTEM PRIVATE "${HASHMAP_SPARSEHASH_INCLUDE_DIR}") + target_compile_definitions(HashMapBenchmark PRIVATE HASHMAP_BENCHMARK_HAS_SPARSEHASH) + endif() + endif() + if(HASHMAP_BUILD_TESTS AND BUILD_TESTING) + add_test(NAME HashMapBenchmarkSmoke COMMAND HashMapBenchmark -t 4 -c 1000 -i 1000) + endif() +endif() - install( - FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake" - DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" - ) +if(HASHMAP_INSTALL) + set(HASHMAP_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/HashMap") + configure_package_config_file(cmake/HashMapConfig.cmake.in + "${CMAKE_CURRENT_BINARY_DIR}/HashMapConfig.cmake" + INSTALL_DESTINATION "${HASHMAP_INSTALL_CMAKEDIR}") + write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/HashMapConfigVersion.cmake" + VERSION ${PROJECT_VERSION} + COMPATIBILITY SameMajorVersion + ARCH_INDEPENDENT) + + install(TARGETS HashMap EXPORT HashMapTargets) + install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") + install(EXPORT HashMapTargets FILE HashMapTargets.cmake + NAMESPACE HashMap:: DESTINATION "${HASHMAP_INSTALL_CMAKEDIR}") + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/HashMapConfig.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/HashMapConfigVersion.cmake" + DESTINATION "${HASHMAP_INSTALL_CMAKEDIR}") + export(EXPORT HashMapTargets FILE "${CMAKE_CURRENT_BINARY_DIR}/HashMapTargets.cmake" + NAMESPACE HashMap::) endif() diff --git a/README.md b/README.md index b0c4d78..afaefc2 100644 --- a/README.md +++ b/README.md @@ -76,12 +76,52 @@ The rest of the member functions are implemented as for hm.erase(1); ``` +## Build and install + +The header-only `HashMap::HashMap` CMake target requires C++14. Configure with +CMake 3.20 or newer: + +```sh +cmake -S . -B build -DCMAKE_BUILD_TYPE=Release +cmake --build build --parallel +ctest --test-dir build --output-on-failure +cmake --install build --prefix /path/to/install +``` + +Standalone builds enable tests and examples, plus the benchmark on Linux and +macOS. These are disabled by default when included with `add_subdirectory`. + +| CMake option | Standalone default | Purpose | +| --- | --- | --- | +| `HASHMAP_BUILD_TESTS` | `ON` | Build tests when `BUILD_TESTING` is also enabled | +| `HASHMAP_BUILD_EXAMPLES` | `ON` | Build the example | +| `HASHMAP_BUILD_BENCHMARKS` | `ON` on POSIX, `OFF` on Windows | Build the benchmark | +| `HASHMAP_INSTALL` | `ON` | Generate installation and package files | +| `HASHMAP_WARNINGS_AS_ERRORS` | `OFF` | Treat warnings in project executables as errors | + +To consume an installed package: + +```cmake +find_package(HashMap 1 CONFIG REQUIRED) +target_link_libraries(my_app PRIVATE HashMap::HashMap) +``` + +The same target is available after `add_subdirectory(path/to/HashMap)`. +Installation respects `CMAKE_INSTALL_INCLUDEDIR` and `CMAKE_INSTALL_LIBDIR`. + ## Benchmark A benchmark `src/HashMapBenchmark.cpp` is included with the sources. The benchmark simulates a delete heavy workload where items are repeatedly inserted and deleted. +The benchmark uses `std::chrono::steady_clock` and requires no benchmark +framework or vendored dependencies. CMake enables comparisons against installed +Abseil and sparsehash when found. Set `HASHMAP_BENCHMARK_WITH_ABSL=OFF` or +`HASHMAP_BENCHMARK_WITH_SPARSEHASH=OFF` to disable either comparison. Abseil must +provide its CMake package; sparsehash must provide `google/dense_hash_map`. +No dependencies are downloaded during configuration. + The benchmark is built on Linux and macOS; Windows builds the example and tests. All containers in a run use the same hash: hardware CRC32 on x86-64 and MurmurHash3's `fmix64` integer mixer on ARM and other architectures. Hash choices diff --git a/cmake/HashMapConfig.cmake.in b/cmake/HashMapConfig.cmake.in new file mode 100644 index 0000000..da72e6a --- /dev/null +++ b/cmake/HashMapConfig.cmake.in @@ -0,0 +1,4 @@ +@PACKAGE_INIT@ + +include("${CMAKE_CURRENT_LIST_DIR}/HashMapTargets.cmake") +check_required_components(HashMap) diff --git a/src/HashMapBenchmark.cpp b/src/HashMapBenchmark.cpp index 1fe0a73..af67ede 100644 --- a/src/HashMapBenchmark.cpp +++ b/src/HashMapBenchmark.cpp @@ -12,11 +12,11 @@ #include #include -#if __has_include() +#if defined(HASHMAP_BENCHMARK_HAS_SPARSEHASH) #include #endif -#if __has_include() +#if defined(HASHMAP_BENCHMARK_HAS_ABSL) #include #endif @@ -178,7 +178,7 @@ int main(int argc, char *argv[]) { b("HashMap", hm); } -#if __has_include() +#if defined(HASHMAP_BENCHMARK_HAS_SPARSEHASH) if (type == -1 || type == 2) { // Couldn't get it to work with the huge_page_allocator google::dense_hash_map hm(count); @@ -188,7 +188,7 @@ int main(int argc, char *argv[]) { } #endif -#if __has_include() +#if defined(HASHMAP_BENCHMARK_HAS_ABSL) if (type == -1 || type == 3) { absl::flat_hash_map, huge_page_allocator>> diff --git a/vendor/benchmark b/vendor/benchmark deleted file mode 160000 index 491360b..0000000 --- a/vendor/benchmark +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 491360b833aaab96818dce256a8409f6296dd995 From 0a284d165b6aab181866cb3dfdc600893719acc1 Mon Sep 17 00:00:00 2001 From: Erik Rigtorp Date: Sun, 4 Oct 2026 19:34:49 -0400 Subject: [PATCH 2/3] Modernize CI and verify CMake consumers across platforms --- .github/workflows/ccpp.yml | 99 +++++++++++++++++------------ tests/cmake/check.cmake | 44 +++++++++++++ tests/cmake/consumer/CMakeLists.txt | 28 ++++++++ tests/cmake/consumer/main.cpp | 10 +++ 4 files changed, 141 insertions(+), 40 deletions(-) create mode 100644 tests/cmake/check.cmake create mode 100644 tests/cmake/consumer/CMakeLists.txt create mode 100644 tests/cmake/consumer/main.cpp diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml index af19e52..e16a84e 100644 --- a/.github/workflows/ccpp.yml +++ b/.github/workflows/ccpp.yml @@ -1,46 +1,65 @@ name: C/C++ CI -on: [push] +on: + push: + branches: [master] + pull_request: + workflow_dispatch: -jobs: - build-ubuntu: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v1 - - name: Build & Test - run: | - cmake -E remove_directory build - cmake -B build -S . -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS="-Werror -O2 -fsanitize=address,undefined" - cmake --build build - cd build - ctest --output-on-failure - - build-windows: +permissions: + contents: read - runs-on: windows-latest - - steps: - - uses: actions/checkout@v1 - - name: Build & Test - run: | - cmake -E remove_directory build - cmake -B build -S . - cmake --build build --config Debug - cd build - ctest -C Debug --output-on-failure - - build-macos: - - runs-on: macOS-latest +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true +jobs: + build: + name: Build (${{ matrix.name }}) + runs-on: ${{ matrix.os }} + timeout-minutes: 15 + strategy: + fail-fast: false + matrix: + include: + - name: Linux GCC + os: ubuntu-latest + compiler: g++ + flags: -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer + - name: Linux Clang + os: ubuntu-latest + compiler: clang++ + flags: -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer + - name: macOS Clang + os: macos-latest + compiler: clang++ + flags: -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer + - name: Windows MSVC + os: windows-latest + compiler: cl + flags: '' + env: + CXX: ${{ matrix.compiler }} + defaults: + run: + shell: bash steps: - - uses: actions/checkout@v1 - - name: Build & Test - run: | - cmake -E remove_directory build - cmake -B build -S . -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS="-Werror -O2 -fsanitize=address,undefined" - cmake --build build - cd build - ctest --output-on-failure + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - name: Configure + run: >- + cmake -S . -B build + -DCMAKE_BUILD_TYPE=Debug + -DCMAKE_CXX_STANDARD=14 + -DHASHMAP_WARNINGS_AS_ERRORS=ON + -DCMAKE_CXX_FLAGS="${{ matrix.flags }}" + - name: Build + run: cmake --build build --config Debug --parallel 2 + - name: Test + run: ctest --test-dir build -C Debug --output-on-failure + - name: Check CMake consumers and package relocation + run: >- + cmake -DHASHMAP_SOURCE_DIR="$GITHUB_WORKSPACE" + -DHASHMAP_CHECK_DIR="$RUNNER_TEMP/hashmap-package-check" + -P tests/cmake/check.cmake diff --git a/tests/cmake/check.cmake b/tests/cmake/check.cmake new file mode 100644 index 0000000..d277562 --- /dev/null +++ b/tests/cmake/check.cmake @@ -0,0 +1,44 @@ +cmake_minimum_required(VERSION 3.20) + +if(NOT HASHMAP_SOURCE_DIR OR NOT HASHMAP_CHECK_DIR) + message(FATAL_ERROR "Set HASHMAP_SOURCE_DIR and HASHMAP_CHECK_DIR") +endif() + +function(run) + execute_process(COMMAND ${ARGV} COMMAND_ECHO STDOUT RESULT_VARIABLE result) + if(NOT result EQUAL 0) + message(FATAL_ERROR "Command failed (${result}): ${ARGV}") + endif() +endfunction() + +function(check_consumer name) + set(build "${HASHMAP_CHECK_DIR}/${name}") + run("${CMAKE_COMMAND}" -S "${HASHMAP_SOURCE_DIR}/tests/cmake/consumer" + -B "${build}" ${ARGN}) + run("${CMAKE_COMMAND}" --build "${build}" --config Debug --parallel 2) + run("${CMAKE_CTEST_COMMAND}" --test-dir "${build}" -C Debug --output-on-failure) +endfunction() + +set(library_build "${HASHMAP_CHECK_DIR}/library") +set(prefix "${HASHMAP_CHECK_DIR}/prefix") +run("${CMAKE_COMMAND}" -S "${HASHMAP_SOURCE_DIR}" -B "${library_build}" + -DHASHMAP_BUILD_TESTS=OFF -DHASHMAP_BUILD_EXAMPLES=OFF + -DHASHMAP_BUILD_BENCHMARKS=OFF -DHASHMAP_INSTALL=ON + -DCMAKE_INSTALL_INCLUDEDIR=include -DCMAKE_INSTALL_LIBDIR=lib) +run("${CMAKE_COMMAND}" --build "${library_build}" --config Debug) +run("${CMAKE_COMMAND}" --install "${library_build}" --config Debug --prefix "${prefix}") + +check_consumer(embedded "-DHASHMAP_SOURCE_DIR=${HASHMAP_SOURCE_DIR}") +check_consumer(build-tree "-DHashMap_DIR=${library_build}") +check_consumer(installed "-DCMAKE_PREFIX_PATH=${prefix}") + +set(custom_build "${HASHMAP_CHECK_DIR}/custom-library") +set(custom_prefix "${HASHMAP_CHECK_DIR}/custom-prefix") +set(relocated_prefix "${HASHMAP_CHECK_DIR}/relocated-prefix") +run("${CMAKE_COMMAND}" -S "${HASHMAP_SOURCE_DIR}" -B "${custom_build}" + -DHASHMAP_BUILD_TESTS=OFF -DHASHMAP_BUILD_EXAMPLES=OFF + -DHASHMAP_BUILD_BENCHMARKS=OFF -DHASHMAP_INSTALL=ON + -DCMAKE_INSTALL_INCLUDEDIR=custom/include -DCMAKE_INSTALL_LIBDIR=custom/lib) +run("${CMAKE_COMMAND}" --install "${custom_build}" --config Debug --prefix "${custom_prefix}") +file(RENAME "${custom_prefix}" "${relocated_prefix}") +check_consumer(relocated "-DHashMap_DIR=${relocated_prefix}/custom/lib/cmake/HashMap") diff --git a/tests/cmake/consumer/CMakeLists.txt b/tests/cmake/consumer/CMakeLists.txt new file mode 100644 index 0000000..8b3cfad --- /dev/null +++ b/tests/cmake/consumer/CMakeLists.txt @@ -0,0 +1,28 @@ +cmake_minimum_required(VERSION 3.20) +project(HashMapConsumer LANGUAGES CXX) + +if(HASHMAP_SOURCE_DIR) + add_subdirectory("${HASHMAP_SOURCE_DIR}" hashmap) + foreach(target HashMapTest HashMapExample HashMapBenchmark) + if(TARGET ${target}) + message(FATAL_ERROR "Embedded HashMap unexpectedly created ${target}") + endif() + endforeach() + if(HASHMAP_INSTALL) + message(FATAL_ERROR "Embedded HashMap unexpectedly enabled installation") + endif() +else() + find_package(HashMap 1 CONFIG REQUIRED) +endif() + +get_target_property(compile_options HashMap::HashMap INTERFACE_COMPILE_OPTIONS) +if(compile_options) + message(FATAL_ERROR "HashMap leaked executable compiler options: ${compile_options}") +endif() + +add_executable(consumer main.cpp) +target_link_libraries(consumer PRIVATE HashMap::HashMap) +set_target_properties(consumer PROPERTIES + CXX_STANDARD 14 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF) +enable_testing() +add_test(NAME consumer COMMAND consumer) diff --git a/tests/cmake/consumer/main.cpp b/tests/cmake/consumer/main.cpp new file mode 100644 index 0000000..3ea0639 --- /dev/null +++ b/tests/cmake/consumer/main.cpp @@ -0,0 +1,10 @@ +#include +#include + +int main() { + rigtorp::HashMap map(0, -1); + map.emplace(0, 42); + map.emplace(1, 43); + map.erase(1); + return map.size() == 1 && map.at(0) == 42 ? 0 : 1; +} From 8e0070a77b219f37959f4d3fd90280273e622b62 Mon Sep 17 00:00:00 2001 From: Erik Rigtorp Date: Sun, 4 Oct 2026 19:36:36 -0400 Subject: [PATCH 3/3] Preserve default MSVC compiler flags in CI --- .github/workflows/ccpp.yml | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml index e16a84e..89fd2af 100644 --- a/.github/workflows/ccpp.yml +++ b/.github/workflows/ccpp.yml @@ -40,6 +40,7 @@ jobs: flags: '' env: CXX: ${{ matrix.compiler }} + HASHMAP_CXX_FLAGS: ${{ matrix.flags }} defaults: run: shell: bash @@ -48,12 +49,18 @@ jobs: with: persist-credentials: false - name: Configure - run: >- - cmake -S . -B build - -DCMAKE_BUILD_TYPE=Debug - -DCMAKE_CXX_STANDARD=14 - -DHASHMAP_WARNINGS_AS_ERRORS=ON - -DCMAKE_CXX_FLAGS="${{ matrix.flags }}" + run: | + cmake_args=() + if [[ "$RUNNER_OS" != Windows ]]; then + cmake_args+=("-DCMAKE_BUILD_TYPE=Debug") + fi + if [[ -n "$HASHMAP_CXX_FLAGS" ]]; then + cmake_args+=("-DCMAKE_CXX_FLAGS=$HASHMAP_CXX_FLAGS") + fi + cmake -S . -B build \ + -DCMAKE_CXX_STANDARD=14 \ + -DHASHMAP_WARNINGS_AS_ERRORS=ON \ + "${cmake_args[@]}" - name: Build run: cmake --build build --config Debug --parallel 2 - name: Test