Replace cmake/ with host-uk/build submodule at .core/build

Build system extracted to host-uk/build and wired in as a git
submodule following the core CLI convention (.core/<tool>/).

- CMake modules, cross-compilation profiles now from .core/build/cmake/
- Conan credentials read from environment instead of hardcoded
- Removed cmake/ directory (14 files) — all now in submodule
- Makefile, CMakeLists.txt, CMakePresets.json updated for new paths

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.core/build

@@ -0,0 +1 @@
+Subproject commit 9c9346d5494688a78ea573f3bc0547ad12b9be2a

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "docs"]
 	path = docs
 	url = https://github.com/letheanVPN/documentation.git
+[submodule ".core/build"]
+	path = .core/build
+	url = http://forge.snider.dev:4000/host-uk/build.git

CMakeLists.txt

@@ -10,7 +10,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 list(INSERT CMAKE_MODULE_PATH 0
-        "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+        "${CMAKE_CURRENT_SOURCE_DIR}/.core/build/cmake")
 
 if(POLICY CMP0043)
   cmake_policy(SET CMP0043 NEW)

CMakePresets.json

@@ -18,7 +18,7 @@
       "cacheVariables": {
         "TESTNET": "ON",
         "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_PROJECT_TOP_LEVEL_INCLUDES":"cmake/ConanProvider.cmake"
+        "CMAKE_PROJECT_TOP_LEVEL_INCLUDES":".core/build/cmake/ConanProvider.cmake"
       }
     },
     {
@@ -30,7 +30,7 @@
       "cacheVariables": {
         "TESTNET": "OFF",
         "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_PROJECT_TOP_LEVEL_INCLUDES":"cmake/ConanProvider.cmake"
+        "CMAKE_PROJECT_TOP_LEVEL_INCLUDES":".core/build/cmake/ConanProvider.cmake"
       }
     }
   ],

Makefile

@@ -4,12 +4,15 @@
 # Distributed under the MIT/X11 software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-# ------------------------------------------------------------
+# ============================================================
-# Detect the number of logical CPU cores – works on Linux,
+# Build system from host-uk/build submodule
-# macOS, BSD, and Windows (both cmd.exe and PowerShell).
+# ============================================================
-# ------------------------------------------------------------
+BUILD_SYS  := .core/build
+CMAKE_DIR  := $(BUILD_SYS)/cmake
 
-# Default to “unknown” – will be overwritten below.
+# ============================================================
+# Project Configuration
+# ============================================================
 CPU_CORES := 1
 TESTNET:= 0
 STATIC:= 0
@@ -19,21 +22,22 @@ BUILD_FOLDER:=build/release
 PRESET_BUILD:=conan-release
 PRESET_CONFIGURE:=conan-release
 
+# ------------------------------------------------------------
+# Detect the number of logical CPU cores – works on Linux,
+# macOS, BSD, and Windows (both cmd.exe and PowerShell).
+# ------------------------------------------------------------
 UNAME_S := $(shell uname -s 2>/dev/null || echo Unknown)
 
 ifeq ($(UNAME_S),Linux)
-    # Linux: try nproc first, fall back to /proc
     CPU_CORES := $(shell nproc 2>/dev/null || \
                   grep -c ^processor /proc/cpuinfo 2>/dev/null || echo 1)
 endif
 
 ifeq ($(UNAME_S),Darwin)
-    # macOS: sysctl reports the number of logical CPUs
     CPU_CORES := $(shell sysctl -n hw.logicalcpu 2>/dev/null || echo 1)
 endif
 
 ifeq ($(filter %BSD,$(UNAME_S)),%BSD)
-    # *BSD: also sysctl, but the key differs on some variants
     CPU_CORES := $(shell sysctl -n hw.ncpu 2>/dev/null || echo 1)
 endif
 
@@ -41,29 +45,27 @@ ifeq ($(OS),Windows_NT)
 
 PRESET_CONFIGURE:=conan-default
 
-    # Prefer the environment variable that Windows sets for us.
-    # It works in both cmd.exe and PowerShell.
     CPU_CORES := $(NUMBER_OF_PROCESSORS)
 
-    # If for some reason the env var is empty, fall back to PowerShell.
     ifeq ($(CPU_CORES),)
         CPU_CORES := $(shell powershell -NoProfile -Command ^ "[Environment]::ProcessorCount")
     endif
 endif
 
-# -----------------------------------------------------------------
+# Safety net
-# Safety net – ensure we always have a positive integer.
-# -----------------------------------------------------------------
 CPU_CORES := $(or $(CPU_CORES),1)
 CPU_CORES := $(shell expr $(CPU_CORES) + 0 2>/dev/null || echo 1)
 CONAN_CPU_COUNT=$(CPU_CORES)
 
-PROFILES 			:=$(patsubst cmake/profiles/%,%,$(wildcard cmake/profiles/*))
+# ============================================================
+# Paths — profiles and cmake modules from .build submodule
+# ============================================================
+PROFILES 			:=$(patsubst $(CMAKE_DIR)/profiles/%,%,$(wildcard $(CMAKE_DIR)/profiles/*))
 SORTED_PROFILES 	:=$(sort $(PROFILES))
 CONAN_CACHE 		:=$(CURDIR)/build/sdk
-CONAN_URL			:=https://artifacts.host.uk.com/artifactory/api/conan/conan-build
+CONAN_URL			:=http://forge.snider.dev:4000/api/packages/host-uk/conan
-CONAN_USER			:=public
+CONAN_USER			?=$(shell echo $$CONAN_USER)
-CONAN_PASSWORD		:=Lethean1234
+CONAN_PASSWORD		?=$(shell echo $$CONAN_PASSWORD)
 CONAN_EXECUTABLE  	:=$(CURDIR)/build/bin/conan
 CC_DOCKER_FILE	  	?=utils/docker/images/lthn-chain/Dockerfile
 SDK_PACKAGES_JSON	:=$(wildcard utils/sdk/packages/*.json)
@@ -111,10 +113,10 @@ docs: configure
 sdk:
 	$(MAKE) -C utils/sdk $(filter-out $@,$(MAKECMDGOALS)) PACKAGE_VERSION=$(BUILD_VERSION)
 
-# Rule for each profile
+# Rule for each profile — uses .build/cmake/profiles/
 $(PROFILES): conan-profile-detect
 	@echo "Building profile: $@"
-	CONAN_HOME=$(CONAN_CACHE) $(CONAN_EXECUTABLE) install . -pr:h=cmake/profiles/$@ --build=missing -s build_type=$(BUILD_TYPE)
+	CONAN_HOME=$(CONAN_CACHE) $(CONAN_EXECUTABLE) install . -pr:h=$(CMAKE_DIR)/profiles/$@ --build=missing -s build_type=$(BUILD_TYPE)
 	cmake -S . -B $(BUILD_FOLDER) -DCMAKE_TOOLCHAIN_FILE=$(BUILD_FOLDER)/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DSTATIC=$(STATIC) -DTESTNET=$(TESTNET) -DBUILD_VERSION=$(BUILD_VERSION)
 	cmake --build $(BUILD_FOLDER) --config=$(BUILD_TYPE) --parallel=$(CPU_CORES)
 	(cd $(BUILD_FOLDER) && cpack)
@@ -128,10 +130,10 @@ help:
 	@echo ""
 	@echo "Available targets:"
 	@printf "  %-42s %s\n" "make clean" "Clean all build directories"
-	@printf "  %-42s %s\n" "make get-conan" "Download and install conan locally"
+	@printf "  %-42s %s\n" "make conan-get" "Download and install conan locally"
 	@printf "  %-42s %s\n" "make release" "Build release"
-	@printf "  %-42s %s\n" "make static" "Build static release"
+	@printf "  %-42s %s\n" "make testnet" "Build testnet"
-	@printf "  %-42s %s\n" "make debug" "Build debug"
+	@printf "  %-42s %s\n" "make mainnet" "Build mainnet"
 	@printf "  %-42s %s\n" "make test" "Build & run tests"
 	@printf "  %-42s %s\n" "make docs" "Builds offline documentation website"
 	@printf "  %-42s %s\n" "make docs-dev" "Runs local doc server, for editing/adding docs"
@@ -161,9 +163,9 @@ test-debug:
 	cmake --build build/test-debug --config=Debug --parallel=$(CPU_CORES)
 	$(MAKE) test
 
-# allowing this target to error quietly saves cross brwoser file detection
+# Conan management — cmake modules from .build submodule
 conan-get:
-	cmake -P cmake/ConanGet.cmake
+	cmake -P $(CMAKE_DIR)/ConanGet.cmake
 	(CONAN_HOME=$(CONAN_CACHE) $(CONAN_EXECUTABLE) remote add conan_build $(CONAN_URL) && \
 	CONAN_HOME=$(CONAN_CACHE) $(CONAN_EXECUTABLE) remote login conan_build $(CONAN_USER) -p $(CONAN_PASSWORD)) || true
 
@@ -171,7 +173,7 @@ conan-upload:
 	CONAN_HOME=$(CONAN_CACHE) $(CONAN_EXECUTABLE) upload "*" -r=conan_build --confirm
 
 conan-profile-detect: conan-get
-	cmake -P cmake/ConanProfileSetup.cmake
+	cmake -P $(CMAKE_DIR)/ConanProfileSetup.cmake
 
 docs-dev: configure
 	@echo "Building Documentation"
@@ -181,7 +183,7 @@ $(SDK_TARGETS):
 	@# This is a proxy target. Handled by the 'sdk' rule.
 
 clean:
-	@cmake -P cmake/CleanBuild.cmake
+	@cmake -P $(CMAKE_DIR)/CleanBuild.cmake
 
 clean-build: clean
 	rm -rf build
@@ -189,5 +191,4 @@ clean-build: clean
 tags:
 	ctags -R --sort=1 --c++-kinds=+p --fields=+iaS --extra=+q --language-force=C++ src contrib tests/gtest
 
-.PHONY: all release upload-conan-cache docs docs-dev configure static static-release test test-release test-debug clean tags conan-profile-detect get-conan $(PROFILES) sdk $(SDK_TARGETS)
+.PHONY: all release upload-conan-cache docs docs-dev configure static static-release test test-release test-debug clean tags conan-profile-detect conan-get $(PROFILES) sdk $(SDK_TARGETS)
-.PHONY: go-client

cmake/CPackConfig.cmake

@@ -1,88 +0,0 @@
-
-
-if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" OR CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" OR CMAKE_BUILD_TYPE STREQUAL "")
-    set(CPACK_PACKAGE_NAME "${package_name}")
-    set(CPACK_PACKAGE_VENDOR "${package_vendor}")
-    set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${package_description}")
-    set(CPACK_PACKAGE_VERSION "${BUILD_VERSION}")
-    set(CPACK_PACKAGE_CONTACT "${package_contact}")
-    set(CPACK_PACKAGE_HOMEPAGE_URL "${package_website}")
-
-    #set(CPACK_PACKAGING_INSTALL_PREFIX "/usr/local")   # Linux/macOS default
-    #if(WIN32)
-    #    set(CPACK_PACKAGING_INSTALL_PREFIX "C:/Program Files/${PROJECT_NAME}")
-    #endif()
-
-    if(APPLE)
-        if("${package_macos_installer}" STREQUAL "DMG")
-      #      set(CPACK_GENERATOR "DragNDrop")
-#            set(CPACK_DMG_BACKGROUND_IMAGE "${CMAKE_SOURCE_DIR}/resources/dmg_background.png")
-     #       set(CPACK_DMG_VOLUME_NAME "${CPACK_PACKAGE_NAME} ${CPACK_PACKAGE_VERSION}")
-    #        message(STATUS "Registered CPACK_GENERATOR: DragNDrop")
-        else ()
-    #        set(CPACK_GENERATOR "productbuild")
-      #      set(CPACK_PRODUCTBUILD_IDENTIFIER "${package_macos_pkg_productbuild_identifier}")
-#            set(CPACK_PRODUCTBUILD_SIGNING_IDENTITY "Developer ID Installer: Your Company (TEAMID)")
-      #      message(STATUS "Registered CPACK_GENERATOR: productbuild")
-        endif ()
-    elseif(WIN32)
-         set(CPACK_GENERATOR "NSIS")
-         set(CPACK_NSIS_MODIFY_PATH ON)
-         set(CPACK_NSIS_HELP_LINK "https://lt.hn/getting-started/chain.html")
-         set(CPACK_NSIS_URL_INFO_ABOUT "https://lt.hn")
-         set(CPACK_NSIS_CONTACT "support@lt.hn")
-         set(CPACK_NSIS_UNINSTALL_NAME "Lethean CLI")
-         set(CPACK_NSIS_BRANDING_TEXT "Lethean Community")
-         set(CPACK_NSIS_MUI_FINISHPAGE_RUN "lethean-testnet-chain-node.exe")
-
-         message(STATUS "Registered CPACK_GENERATOR: Inno exe")
-#        set(CPACK_WIX_PRODUCT_ICON "${CMAKE_SOURCE_DIR}/resources/windows_icon.ico")
-#        set(CPACK_WIX_LICENSE_RTF "${CMAKE_SOURCE_DIR}/LICENSE.rtf")
-#        set(CPACK_WIX_UPGRADE_GUID "D3F5A9C1-4B2E-4F5A-9C71-123456789ABC") # change once per major version
-    else()
-        set(CPACK_GENERATOR "DEB")
-        set(CPACK_GENERATOR "RPM")
-        message(STATUS "Registered CPACK_GENERATOR: deb")
-        set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${package_contact}")
-        set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.28)")
-        set(CPACK_DEBIAN_PACKAGE_SECTION "utils")
-        set(CPACK_DEBIAN_ARCHITECTURE "${CMAKE_SYSTEM_PROCESSOR}")
-        # post‑install script (e.g., to register a systemd service)
-#        set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA
-#                "${CMAKE_SOURCE_DIR}/scripts/postinstall.sh")
-    endif()
-
-    list(APPEND CPACK_GENERATOR "TXZ" "ZIP")
-    message(STATUS "Registered CPACK_GENERATOR: tgz")
-    message(STATUS "Registered CPACK_GENERATOR: zip")
-    set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
-    set(CPACK_ARCHIVE_COMPONENT_INSTALL OFF)
-    set(CPACK_COMPONENTS_ALL)
-    set(CPACK_MONOLITHIC_INSTALL OFF)
-    set(CPACK_PACKAGE_CHECKSUM SHA256)
-    message(STATUS "Using SHA256 Checksums")
-
-    set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE.txt")
-    set(CPACK_RESOURCE_FILE_README "${CMAKE_SOURCE_DIR}/README.md")
-
-    set(CPACK_PACKAGE_DIRECTORY "${CMAKE_SOURCE_DIR}/build/packages")
-
-    install(FILES README.md LICENSE.txt
-            DESTINATION "share/doc/${PROJECT_NAME}"
-    )
-
-    set(_arch "${CMAKE_SYSTEM_PROCESSOR}")
-
-    if(_arch MATCHES "AMD64|x86_64")
-        set(_arch "x86_64")
-    elseif(_arch MATCHES "arm64|aarch64")
-        set(_arch "arm64")
-    endif()
-
-    string(TOLOWER "${CMAKE_SYSTEM_NAME}" _sys_name_lc)
-
-    set(CPACK_PACKAGE_FILE_NAME
-            "${package_name}-${CPACK_PACKAGE_VERSION}-${_sys_name_lc}-${_arch}")
-
-    include(CPack)
-endif()

cmake/CleanBuild.cmake

@@ -1,76 +0,0 @@
-# cmake/CleanBuild.cmake
-
-# Function to selectively clean the build directory.
-#
-# This function will remove most of the generated build files from the build
-# directory, while preserving specific directories that contain downloaded
-# tools or generated documentation.
-#
-# Golden Rules:
-# - never delete build/
-# - never delete build/bin
-# - never delete build/docs
-# - never delete build/sdk (non cache)
-#
-# It will:
-# - purge build files
-# - clean up conan build files, cached sources can always remain.
-function(selective_clean_build_dir)
-    if(EXISTS "${CMAKE_SOURCE_DIR}/build")
-        message(STATUS "Selectively cleaning build directory: ${CMAKE_SOURCE_DIR}/build")
-
-        # List of top-level items in the build directory to keep.
-        set(golden_items
-            "${CMAKE_SOURCE_DIR}/build/.ccache"
-            "${CMAKE_SOURCE_DIR}/build/bin"
-            "${CMAKE_SOURCE_DIR}/build/docs"
-            "${CMAKE_SOURCE_DIR}/build/sdk"
-        )
-
-        # Get all top-level items in the build directory.
-        file(GLOB top_level_items "${CMAKE_SOURCE_DIR}/build/*")
-
-        foreach(item ${top_level_items})
-            list(FIND golden_items "${item}" is_golden)
-            if(is_golden STREQUAL "-1")
-                string(FIND "${item}" "${CMAKE_SOURCE_DIR}/build" is_prefixed)
-                if(is_prefixed EQUAL 0)
-                    message(STATUS "Removing: ${item}")
-                    if(IS_DIRECTORY "${item}")
-                        file(REMOVE_RECURSE "${item}")
-                    else()
-                        file(REMOVE "${item}")
-                    endif()
-                else()
-                    message(WARNING "Safety check failed: Will not remove '${item}' because it is not prefixed with CMAKE_SOURCE_DIR/build.")
-                endif()
-            else()
-                message(STATUS "Keeping golden item: ${item}")
-            endif()
-        endforeach()
-
-        message(STATUS "Selective clean complete.")
-    else()
-        message(STATUS "Build directory not found, skipping clean.")
-    endif()
-endfunction()
-
-function(reset_conan_presets)
-    set(CONAN_PRESETS_FILE "${CMAKE_SOURCE_DIR}/ConanPresets.json")
-
-    set(NEW_CONTENT [[{
-    "version": 4,
-    "vendor": {
-        "conan": {}
-    },
-    "include": [
-
-    ]
-}]])
-    message(STATUS "Resetting ${CONAN_PRESETS_FILE} to a clean state.")
-    file(WRITE "${CONAN_PRESETS_FILE}" "${NEW_CONTENT}")
-    message(STATUS "${CONAN_PRESETS_FILE} has been successfully reset.")
-endfunction()
-
-selective_clean_build_dir()
-reset_conan_presets()

cmake/ConanGet.cmake

@@ -1,102 +0,0 @@
-# cmake/ConanGet.cmake
-
-# This module downloads and installs Conan if it's not found.
-
-# Set the Conan version
-set(CONAN_VERSION 2.21.0)
-
-# Set the download URLs
-set(CONAN_URL_MACOS_ARM "https://github.com/conan-io/conan/releases/download/${CONAN_VERSION}/conan-${CONAN_VERSION}-macos-arm64.tgz")
-set(CONAN_URL_MACOS_INTEL "https://github.com/conan-io/conan/releases/download/${CONAN_VERSION}/conan-${CONAN_VERSION}-macos-x86_64.tgz")
-set(CONAN_URL_WINDOWS_X86_64 "https://github.com/conan-io/conan/releases/download/${CONAN_VERSION}/conan-${CONAN_VERSION}-windows-x86_64.zip")
-set(CONAN_URL_WINDOWS_ARM64 "https://github.com/conan-io/conan/releases/download/${CONAN_VERSION}/conan-${CONAN_VERSION}-windows-arm64.zip")
-set(CONAN_URL_LINUX_X86_64 "https://github.com/conan-io/conan/releases/download/${CONAN_VERSION}/conan-${CONAN_VERSION}-linux-x86_64.tgz")
-set(CONAN_URL_LINUX_AARCH64 "https://github.com/conan-io/conan/releases/download/${CONAN_VERSION}/conan-${CONAN_VERSION}-linux-aarch64.tgz")
-
-# Set the installation directory
-if(NOT CMAKE_BINARY_DIR)
-  set(CMAKE_BINARY_DIR "${CONAN_INSTALL_DIR}")
-endif()
-if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
-  set(CONAN_INSTALL_DIR "${CMAKE_SOURCE_DIR}/build/bin")
-  set(CONAN_EXECUTABLE "${CMAKE_SOURCE_DIR}/build/bin/conan.exe")
-else ()
-  set(CONAN_INSTALL_DIR "${CMAKE_SOURCE_DIR}/build")
-  set(CONAN_EXECUTABLE "${CONAN_INSTALL_DIR}/bin/conan")
-endif ()
-# Check if Conan is already installed
-if(NOT EXISTS "${CONAN_EXECUTABLE}")
-  message(STATUS "Conan not found. Downloading and installing...")
-
-  file(MAKE_DIRECTORY "${CONAN_INSTALL_DIR}")
-
-  # Determine the processor architecture, with a fallback
-  if(CMAKE_HOST_SYSTEM_PROCESSOR)
-    set(HOST_PROCESSOR ${CMAKE_HOST_SYSTEM_PROCESSOR})
-  else()
-    cmake_host_system_information(RESULT HOST_PROCESSOR QUERY OS_PLATFORM)
-  endif()
-
-  # Detect the operating system and architecture
-  message(STATUS "Detecting OS and architecture: ${HOST_PROCESSOR} on ${CMAKE_HOST_SYSTEM_NAME}")
-  if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
-    if(HOST_PROCESSOR MATCHES "arm64")
-      set(CONAN_URL ${CONAN_URL_MACOS_ARM})
-      set(CONAN_ARCHIVE_TYPE "tgz")
-    else()
-      set(CONAN_URL ${CONAN_URL_MACOS_INTEL})
-      set(CONAN_ARCHIVE_TYPE "tgz")
-    endif()
-  elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
-    if(HOST_PROCESSOR MATCHES "ARM64")
-      set(CONAN_URL ${CONAN_URL_WINDOWS_ARM64})
-      set(CONAN_ARCHIVE_TYPE "zip")
-    else()
-      set(CONAN_URL ${CONAN_URL_WINDOWS_X86_64})
-      set(CONAN_ARCHIVE_TYPE "zip")
-    endif()
-  elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
-    if(HOST_PROCESSOR MATCHES "aarch64|arm64|ARM64")
-      set(CONAN_URL ${CONAN_URL_LINUX_AARCH64})
-      set(CONAN_ARCHIVE_TYPE "tgz")
-    else()
-      set(CONAN_URL ${CONAN_URL_LINUX_X86_64})
-      set(CONAN_ARCHIVE_TYPE "tgz")
-    endif()
-  else()
-    message(FATAL_ERROR "Unsupported operating system: ${CMAKE_HOST_SYSTEM_NAME}")
-  endif()
-
-  # Download and extract Conan
-  set(CONAN_ARCHIVE "${CMAKE_BINARY_DIR}/conan.${CONAN_ARCHIVE_TYPE}")
-
-  message(STATUS "Downloading ${CONAN_URL} to ${CONAN_ARCHIVE}")
-  file(DOWNLOAD "${CONAN_URL}" "${CONAN_ARCHIVE}" SHOW_PROGRESS)
-
-  message(STATUS "Extracting ${CONAN_ARCHIVE} to ${CONAN_INSTALL_DIR}")
-  if(CONAN_ARCHIVE_TYPE STREQUAL "tgz")
-    execute_process(
-      COMMAND ${CMAKE_COMMAND} -E tar xzf "${CONAN_ARCHIVE}"
-      WORKING_DIRECTORY "${CONAN_INSTALL_DIR}"
-      RESULT_VARIABLE result
-    )
-  elseif(CONAN_ARCHIVE_TYPE STREQUAL "zip")
-    # CMake -E tar can handle zip files
-    execute_process(
-      COMMAND ${CMAKE_COMMAND} -E tar xf "${CONAN_ARCHIVE}"
-      WORKING_DIRECTORY "${CONAN_INSTALL_DIR}"
-      RESULT_VARIABLE result
-    )
-  endif()
-
-  if(NOT result EQUAL 0)
-    message(FATAL_ERROR "Failed to extract Conan archive.")
-  endif()
-
-  # Clean up the archive
-  file(REMOVE "${CONAN_ARCHIVE}")
-
-  message(STATUS "Conan installed successfully at ${CONAN_EXECUTABLE}")
-else()
-  message(STATUS "Conan already installed at ${CONAN_EXECUTABLE}")
-endif()

cmake/ConanProfileSetup.cmake

@@ -1,38 +0,0 @@
-set(CONAN_HOME "${CMAKE_SOURCE_DIR}/build/sdk")
-set(DEFAULT_PROFILE "${CONAN_HOME}/profiles/default")
-if(WIN32)
-    set(CONAN_EXECUTABLE "${CMAKE_SOURCE_DIR}/build/bin/conan.exe")
-else()
-    set(CONAN_EXECUTABLE "${CMAKE_SOURCE_DIR}/build/bin/conan")
-endif()
-if(NOT EXISTS "${DEFAULT_PROFILE}")
-    message(STATUS "Conan default profile not found. Detecting a new one...")
-    set(ENV{CONAN_HOME} "${CONAN_HOME}")
-    execute_process(
-            COMMAND "${CONAN_EXECUTABLE}" profile detect --name=default --force
-            WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-            RESULT_VARIABLE return_code
-    )
-    unset(ENV{CONAN_HOME})
-
-    if(NOT return_code EQUAL 0)
-        message(FATAL_ERROR "Conan profile detection failed with exit code: ${return_code}")
-    endif()
-endif()
-
-message(STATUS "Appending custom settings to Conan default profile...")
-
-set(CUSTOM_SETTINGS "
-compiler.cppstd=17
-")
-
-#if(WIN32)
-#    message(STATUS "Windows detected. Appending static runtime setting.")
-#    string(APPEND CUSTOM_SETTINGS "
-#compiler.runtime=static
-#")
-#endif()
-
-file(APPEND "${DEFAULT_PROFILE}" "${CUSTOM_SETTINGS}")
-
-message(STATUS "Conan profile setup is complete.")

cmake/ConanProvider.cmake

@@ -1,698 +0,0 @@
-# The MIT License (MIT)
-#
-# Copyright (c) 2024 JFrog
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-set(CONAN_MINIMUM_VERSION 2.0.5)
-
-# Create a new policy scope and set the minimum required cmake version so the
-# features behind a policy setting like if(... IN_LIST ...) behaves as expected
-# even if the parent project does not specify a minimum cmake version or a minimum
-# version less than this module requires (e.g. 3.0) before the first project() call.
-# (see: https://cmake.org/cmake/help/latest/variable/CMAKE_PROJECT_TOP_LEVEL_INCLUDES.html)
-#
-# The policy-affecting calls like cmake_policy(SET...) or `cmake_minimum_required` only
-# affects the current policy scope, i.e. between the PUSH and POP in this case.
-#
-# https://cmake.org/cmake/help/book/mastering-cmake/chapter/Policies.html#the-policy-stack
-cmake_policy(PUSH)
-cmake_minimum_required(VERSION 3.24)
-
-
-function(detect_os os os_api_level os_sdk os_subsystem os_version)
-    # it could be cross compilation
-    message(STATUS "CMake-Conan: cmake_system_name=${CMAKE_SYSTEM_NAME}")
-    if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic")
-        if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-            set(${os} Macos PARENT_SCOPE)
-        elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX")
-            set(${os} Neutrino PARENT_SCOPE)
-        elseif(CMAKE_SYSTEM_NAME STREQUAL "CYGWIN")
-            set(${os} Windows PARENT_SCOPE)
-            set(${os_subsystem} cygwin PARENT_SCOPE)
-        elseif(CMAKE_SYSTEM_NAME MATCHES "^MSYS")
-            set(${os} Windows PARENT_SCOPE)
-            set(${os_subsystem} msys2 PARENT_SCOPE)
-        elseif(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
-            # https://github.com/emscripten-core/emscripten/blob/4.0.6/cmake/Modules/Platform/Emscripten.cmake#L17C1-L17C34
-            set(${os} Emscripten PARENT_SCOPE)
-        else()
-            set(${os} ${CMAKE_SYSTEM_NAME} PARENT_SCOPE)
-        endif()
-        if(CMAKE_SYSTEM_NAME STREQUAL "Android")
-            if(DEFINED ANDROID_PLATFORM)
-                string(REGEX MATCH "[0-9]+" _os_api_level ${ANDROID_PLATFORM})
-            elseif(DEFINED CMAKE_SYSTEM_VERSION)
-                set(_os_api_level ${CMAKE_SYSTEM_VERSION})
-            endif()
-            message(STATUS "CMake-Conan: android api level=${_os_api_level}")
-            set(${os_api_level} ${_os_api_level} PARENT_SCOPE)
-        endif()
-        if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS")
-            # CMAKE_OSX_SYSROOT contains the full path to the SDK for MakeFile/Ninja
-            # generators, but just has the original input string for Xcode.
-            if(NOT IS_DIRECTORY ${CMAKE_OSX_SYSROOT})
-                set(_os_sdk ${CMAKE_OSX_SYSROOT})
-            else()
-                if(CMAKE_OSX_SYSROOT MATCHES Simulator)
-                    set(apple_platform_suffix simulator)
-                else()
-                    set(apple_platform_suffix os)
-                endif()
-                if(CMAKE_OSX_SYSROOT MATCHES AppleTV)
-                    set(_os_sdk "appletv${apple_platform_suffix}")
-                elseif(CMAKE_OSX_SYSROOT MATCHES iPhone)
-                    set(_os_sdk "iphone${apple_platform_suffix}")
-                elseif(CMAKE_OSX_SYSROOT MATCHES Watch)
-                    set(_os_sdk "watch${apple_platform_suffix}")
-                endif()
-            endif()
-            if(DEFINED os_sdk)
-                message(STATUS "CMake-Conan: cmake_osx_sysroot=${CMAKE_OSX_SYSROOT}")
-                set(${os_sdk} ${_os_sdk} PARENT_SCOPE)
-            endif()
-            if(DEFINED CMAKE_OSX_DEPLOYMENT_TARGET)
-                message(STATUS "CMake-Conan: cmake_osx_deployment_target=${CMAKE_OSX_DEPLOYMENT_TARGET}")
-                set(${os_version} ${CMAKE_OSX_DEPLOYMENT_TARGET} PARENT_SCOPE)
-            endif()
-        endif()
-    endif()
-endfunction()
-
-
-function(detect_arch arch)
-    # CMAKE_OSX_ARCHITECTURES can contain multiple architectures, but Conan only supports one.
-    # Therefore this code only finds one. If the recipes support multiple architectures, the
-    # build will work. Otherwise, there will be a linker error for the missing architecture(s).
-    if(DEFINED CMAKE_OSX_ARCHITECTURES)
-        string(REPLACE " " ";" apple_arch_list "${CMAKE_OSX_ARCHITECTURES}")
-        list(LENGTH apple_arch_list apple_arch_count)
-        if(apple_arch_count GREATER 1)
-            message(WARNING "CMake-Conan: Multiple architectures detected, this will only work if Conan recipe(s) produce fat binaries.")
-        endif()
-    endif()
-    if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS" AND NOT CMAKE_OSX_ARCHITECTURES STREQUAL "")
-        set(host_arch ${CMAKE_OSX_ARCHITECTURES})
-    elseif(MSVC)
-        set(host_arch ${CMAKE_CXX_COMPILER_ARCHITECTURE_ID})
-    else()
-        set(host_arch ${CMAKE_SYSTEM_PROCESSOR})
-    endif()
-    if(host_arch MATCHES "aarch64|arm64|ARM64")
-        set(_arch armv8)
-    elseif(host_arch MATCHES "armv7|armv7-a|armv7l|ARMV7")
-        set(_arch armv7)
-    elseif(host_arch MATCHES armv7s)
-        set(_arch armv7s)
-    elseif(host_arch MATCHES "i686|i386|X86")
-        set(_arch x86)
-    elseif(host_arch MATCHES "AMD64|amd64|x86_64|x64")
-        set(_arch x86_64)
-    endif()
-    if(EMSCRIPTEN)
-        # https://github.com/emscripten-core/emscripten/blob/4.0.6/cmake/Modules/Platform/Emscripten.cmake#L294C1-L294C80
-        set(_arch wasm)
-    endif()
-    message(STATUS "CMake-Conan: cmake_system_processor=${_arch}")
-    set(${arch} ${_arch} PARENT_SCOPE)
-endfunction()
-
-
-function(detect_cxx_standard cxx_standard)
-    set(${cxx_standard} ${CMAKE_CXX_STANDARD} PARENT_SCOPE)
-    if(CMAKE_CXX_EXTENSIONS)
-        set(${cxx_standard} "gnu${CMAKE_CXX_STANDARD}" PARENT_SCOPE)
-    endif()
-endfunction()
-
-
-macro(detect_gnu_libstdcxx)
-    # _conan_is_gnu_libstdcxx true if GNU libstdc++
-    check_cxx_source_compiles("
-    #include <cstddef>
-    #if !defined(__GLIBCXX__) && !defined(__GLIBCPP__)
-    static_assert(false);
-    #endif
-    int main(){}" _conan_is_gnu_libstdcxx)
-
-    # _conan_gnu_libstdcxx_is_cxx11_abi true if C++11 ABI
-    check_cxx_source_compiles("
-    #include <string>
-    static_assert(sizeof(std::string) != sizeof(void*), \"using libstdc++\");
-    int main () {}" _conan_gnu_libstdcxx_is_cxx11_abi)
-
-    set(_conan_gnu_libstdcxx_suffix "")
-    if(_conan_gnu_libstdcxx_is_cxx11_abi)
-        set(_conan_gnu_libstdcxx_suffix "11")
-    endif()
-    unset (_conan_gnu_libstdcxx_is_cxx11_abi)
-endmacro()
-
-
-macro(detect_libcxx)
-    # _conan_is_libcxx true if LLVM libc++
-    check_cxx_source_compiles("
-    #include <cstddef>
-    #if !defined(_LIBCPP_VERSION)
-       static_assert(false);
-    #endif
-    int main(){}" _conan_is_libcxx)
-endmacro()
-
-
-function(detect_lib_cxx lib_cxx)
-    if(CMAKE_SYSTEM_NAME STREQUAL "Android")
-        message(STATUS "CMake-Conan: android_stl=${CMAKE_ANDROID_STL_TYPE}")
-        set(${lib_cxx} ${CMAKE_ANDROID_STL_TYPE} PARENT_SCOPE)
-        return()
-    endif()
-
-    include(CheckCXXSourceCompiles)
-
-    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-        detect_gnu_libstdcxx()
-        set(${lib_cxx} "libstdc++${_conan_gnu_libstdcxx_suffix}" PARENT_SCOPE)
-    elseif(CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
-        set(${lib_cxx} "libc++" PARENT_SCOPE)
-    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
-        # Check for libc++
-        detect_libcxx()
-        if(_conan_is_libcxx)
-            set(${lib_cxx} "libc++" PARENT_SCOPE)
-            return()
-        endif()
-
-        # Check for libstdc++
-        detect_gnu_libstdcxx()
-        if(_conan_is_gnu_libstdcxx)
-            set(${lib_cxx} "libstdc++${_conan_gnu_libstdcxx_suffix}" PARENT_SCOPE)
-            return()
-        endif()
-
-        # TODO: it would be an error if we reach this point
-    elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-        # Do nothing - compiler.runtime and compiler.runtime_type
-        # should be handled separately: https://github.com/conan-io/cmake-conan/pull/516
-        return()
-    else()
-        # TODO: unable to determine, ask user to provide a full profile file instead
-    endif()
-endfunction()
-
-
-function(detect_compiler compiler compiler_version compiler_runtime compiler_runtime_type)
-    if(DEFINED CMAKE_CXX_COMPILER_ID)
-        set(_compiler ${CMAKE_CXX_COMPILER_ID})
-        set(_compiler_version ${CMAKE_CXX_COMPILER_VERSION})
-    else()
-        if(NOT DEFINED CMAKE_C_COMPILER_ID)
-            message(FATAL_ERROR "C or C++ compiler not defined")
-        endif()
-        set(_compiler ${CMAKE_C_COMPILER_ID})
-        set(_compiler_version ${CMAKE_C_COMPILER_VERSION})
-    endif()
-
-    message(STATUS "CMake-Conan: CMake compiler=${_compiler}")
-    message(STATUS "CMake-Conan: CMake compiler version=${_compiler_version}")
-
-    if(_compiler MATCHES MSVC)
-        set(_compiler "msvc")
-        string(SUBSTRING ${MSVC_VERSION} 0 3 _compiler_version)
-        # Configure compiler.runtime and compiler.runtime_type settings for MSVC
-        if(CMAKE_MSVC_RUNTIME_LIBRARY)
-            set(_msvc_runtime_library ${CMAKE_MSVC_RUNTIME_LIBRARY})
-        else()
-            set(_msvc_runtime_library MultiThreaded$<$<CONFIG:Debug>:Debug>DLL) # default value documented by CMake
-        endif()
-
-        set(_KNOWN_MSVC_RUNTIME_VALUES "")
-        list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded MultiThreadedDLL)
-        list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreadedDebug MultiThreadedDebugDLL)
-        list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded$<$<CONFIG:Debug>:Debug> MultiThreaded$<$<CONFIG:Debug>:Debug>DLL)
-
-        # only accept the 6 possible values, otherwise we don't don't know to map this
-        if(NOT _msvc_runtime_library IN_LIST _KNOWN_MSVC_RUNTIME_VALUES)
-            message(FATAL_ERROR "CMake-Conan: unable to map MSVC runtime: ${_msvc_runtime_library} to Conan settings")
-        endif()
-
-        # Runtime is "dynamic" in all cases if it ends in DLL
-        if(_msvc_runtime_library MATCHES ".*DLL$")
-            set(_compiler_runtime "dynamic")
-        else()
-            set(_compiler_runtime "static")
-        endif()
-        message(STATUS "CMake-Conan: CMake compiler.runtime=${_compiler_runtime}")
-
-        # Only define compiler.runtime_type when explicitly requested
-        # If a generator expression is used, let Conan handle it conditional on build_type
-        if(NOT _msvc_runtime_library MATCHES "<CONFIG:Debug>:Debug>")
-            if(_msvc_runtime_library MATCHES "Debug")
-                set(_compiler_runtime_type "Debug")
-            else()
-                set(_compiler_runtime_type "Release")
-            endif()
-            message(STATUS "CMake-Conan: CMake compiler.runtime_type=${_compiler_runtime_type}")
-        endif()
-
-        unset(_KNOWN_MSVC_RUNTIME_VALUES)
-
-    elseif(_compiler MATCHES AppleClang)
-        set(_compiler "apple-clang")
-        string(REPLACE "." ";" VERSION_LIST ${_compiler_version})
-        list(GET VERSION_LIST 0 _compiler_version)
-    elseif(_compiler MATCHES Clang)
-        set(_compiler "clang")
-        string(REPLACE "." ";" VERSION_LIST ${_compiler_version})
-        list(GET VERSION_LIST 0 _compiler_version)
-    elseif(_compiler MATCHES GNU)
-        set(_compiler "gcc")
-        string(REPLACE "." ";" VERSION_LIST ${_compiler_version})
-        list(GET VERSION_LIST 0 _compiler_version)
-    endif()
-
-    message(STATUS "CMake-Conan: [settings] compiler=${_compiler}")
-    message(STATUS "CMake-Conan: [settings] compiler.version=${_compiler_version}")
-    if (_compiler_runtime)
-        message(STATUS "CMake-Conan: [settings] compiler.runtime=${_compiler_runtime}")
-    endif()
-    if (_compiler_runtime_type)
-        message(STATUS "CMake-Conan: [settings] compiler.runtime_type=${_compiler_runtime_type}")
-    endif()
-
-    set(${compiler} ${_compiler} PARENT_SCOPE)
-    set(${compiler_version} ${_compiler_version} PARENT_SCOPE)
-    set(${compiler_runtime} ${_compiler_runtime} PARENT_SCOPE)
-    set(${compiler_runtime_type} ${_compiler_runtime_type} PARENT_SCOPE)
-endfunction()
-
-
-function(detect_build_type build_type)
-    get_property(multiconfig_generator GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-    if(NOT multiconfig_generator)
-        # Only set when we know we are in a single-configuration generator
-        # Note: we may want to fail early if `CMAKE_BUILD_TYPE` is not defined
-        set(${build_type} ${CMAKE_BUILD_TYPE} PARENT_SCOPE)
-    endif()
-endfunction()
-
-
-macro(set_conan_compiler_if_appleclang lang command output_variable)
-    if(CMAKE_${lang}_COMPILER_ID STREQUAL "AppleClang")
-        execute_process(COMMAND xcrun --find ${command}
-                OUTPUT_VARIABLE _xcrun_out OUTPUT_STRIP_TRAILING_WHITESPACE)
-        cmake_path(GET _xcrun_out PARENT_PATH _xcrun_toolchain_path)
-        cmake_path(GET CMAKE_${lang}_COMPILER PARENT_PATH _compiler_parent_path)
-        if ("${_xcrun_toolchain_path}" STREQUAL "${_compiler_parent_path}")
-            set(${output_variable} "")
-        endif()
-        unset(_xcrun_out)
-        unset(_xcrun_toolchain_path)
-        unset(_compiler_parent_path)
-    endif()
-endmacro()
-
-
-macro(append_compiler_executables_configuration)
-    set(_conan_c_compiler "")
-    set(_conan_cpp_compiler "")
-    set(_conan_rc_compiler "")
-    set(_conan_compilers_list "")
-    if(CMAKE_C_COMPILER)
-        set(_conan_c_compiler "\"c\":\"${CMAKE_C_COMPILER}\"")
-        set_conan_compiler_if_appleclang(C cc _conan_c_compiler)
-        list(APPEND _conan_compilers_list ${_conan_c_compiler})
-    else()
-        message(WARNING "CMake-Conan: The C compiler is not defined. "
-                "Please define CMAKE_C_COMPILER or enable the C language.")
-    endif()
-    if(CMAKE_CXX_COMPILER)
-        set(_conan_cpp_compiler "\"cpp\":\"${CMAKE_CXX_COMPILER}\"")
-        set_conan_compiler_if_appleclang(CXX c++ _conan_cpp_compiler)
-        list(APPEND _conan_compilers_list ${_conan_cpp_compiler})
-    else()
-        message(WARNING "CMake-Conan: The C++ compiler is not defined. "
-                "Please define CMAKE_CXX_COMPILER or enable the C++ language.")
-    endif()
-    if(CMAKE_RC_COMPILER)
-        set(_conan_rc_compiler "\"rc\":\"${CMAKE_RC_COMPILER}\"")
-        list(APPEND _conan_compilers_list ${_conan_rc_compiler})
-        # Not necessary to warn if RC not defined
-    endif()
-    if(NOT "x${_conan_compilers_list}" STREQUAL "x")
-        string(REPLACE ";" "," _conan_compilers_list "${_conan_compilers_list}")
-        string(APPEND profile "tools.build:compiler_executables={${_conan_compilers_list}}\n")
-    endif()
-    unset(_conan_c_compiler)
-    unset(_conan_cpp_compiler)
-    unset(_conan_rc_compiler)
-    unset(_conan_compilers_list)
-endmacro()
-
-
-function(detect_host_profile output_file)
-    detect_os(os os_api_level os_sdk os_subsystem os_version)
-    detect_arch(arch)
-    detect_compiler(compiler compiler_version compiler_runtime compiler_runtime_type)
-    detect_cxx_standard(compiler_cppstd)
-    detect_lib_cxx(compiler_libcxx)
-    detect_build_type(build_type)
-
-    set(profile "")
-    string(APPEND profile "[settings]\n")
-    if(arch)
-        string(APPEND profile arch=${arch} "\n")
-    endif()
-    if(os)
-        string(APPEND profile os=${os} "\n")
-    endif()
-    if(os_api_level)
-        string(APPEND profile os.api_level=${os_api_level} "\n")
-    endif()
-    if(os_version)
-        string(APPEND profile os.version=${os_version} "\n")
-    endif()
-    if(os_sdk)
-        string(APPEND profile os.sdk=${os_sdk} "\n")
-    endif()
-    if(os_subsystem)
-        string(APPEND profile os.subsystem=${os_subsystem} "\n")
-    endif()
-    if(compiler)
-        string(APPEND profile compiler=${compiler} "\n")
-    endif()
-    if(compiler_version)
-        string(APPEND profile compiler.version=${compiler_version} "\n")
-    endif()
-    if(compiler_runtime)
-        string(APPEND profile compiler.runtime=${compiler_runtime} "\n")
-    endif()
-    if(compiler_runtime_type)
-        string(APPEND profile compiler.runtime_type=${compiler_runtime_type} "\n")
-    endif()
-    if(compiler_cppstd)
-        string(APPEND profile compiler.cppstd=${compiler_cppstd} "\n")
-    endif()
-    if(compiler_libcxx)
-        string(APPEND profile compiler.libcxx=${compiler_libcxx} "\n")
-    endif()
-    if(build_type)
-        string(APPEND profile "build_type=${build_type}\n")
-    endif()
-
-    if(NOT DEFINED output_file)
-        set(file_name "${CMAKE_BINARY_DIR}/profile")
-    else()
-        set(file_name ${output_file})
-    endif()
-
-    string(APPEND profile "[conf]\n")
-    string(APPEND profile "tools.cmake.cmaketoolchain:generator=${CMAKE_GENERATOR}\n")
-
-    # propagate compilers via profile
-    append_compiler_executables_configuration()
-
-    if(os STREQUAL "Android")
-        string(APPEND profile "tools.android:ndk_path=${CMAKE_ANDROID_NDK}\n")
-    endif()
-
-    message(STATUS "CMake-Conan: Creating profile ${file_name}")
-    file(WRITE ${file_name} ${profile})
-    message(STATUS "CMake-Conan: Profile: \n${profile}")
-endfunction()
-
-
-function(conan_profile_detect_default)
-    message(STATUS "CMake-Conan: Checking if a default profile exists")
-    execute_process(COMMAND ${CONAN_COMMAND} profile path default
-            RESULT_VARIABLE return_code
-            OUTPUT_VARIABLE conan_stdout
-            ERROR_VARIABLE conan_stderr
-            ECHO_ERROR_VARIABLE    # show the text output regardless
-            ECHO_OUTPUT_VARIABLE
-            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-    if(NOT ${return_code} EQUAL "0")
-        message(STATUS "CMake-Conan: The default profile doesn't exist, detecting it.")
-        execute_process(COMMAND ${CONAN_COMMAND} profile detect
-                RESULT_VARIABLE return_code
-                OUTPUT_VARIABLE conan_stdout
-                ERROR_VARIABLE conan_stderr
-                ECHO_ERROR_VARIABLE    # show the text output regardless
-                ECHO_OUTPUT_VARIABLE
-                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-    endif()
-endfunction()
-
-
-function(conan_install)
-    set(conan_output_folder ${CMAKE_BINARY_DIR}/conan)
-    # Invoke "conan install" with the provided arguments
-    set(conan_args ${conan_args} -of=${conan_output_folder})
-    message(STATUS "CMake-Conan: conan install ${CMAKE_SOURCE_DIR} ${conan_args} ${ARGN}")
-
-
-    # In case there was not a valid cmake executable in the PATH, we inject the
-    # same we used to invoke the provider to the PATH
-    if(DEFINED PATH_TO_CMAKE_BIN)
-        set(old_path $ENV{PATH})
-        set(ENV{PATH} "$ENV{PATH}:${PATH_TO_CMAKE_BIN}")
-    endif()
-
-    execute_process(COMMAND ${CONAN_COMMAND} install ${CMAKE_SOURCE_DIR} ${conan_args} ${ARGN} --format=json
-            RESULT_VARIABLE return_code
-            OUTPUT_VARIABLE conan_stdout
-            ERROR_VARIABLE conan_stderr
-            ECHO_ERROR_VARIABLE    # show the text output regardless
-            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
-    if(DEFINED PATH_TO_CMAKE_BIN)
-        set(ENV{PATH} "${old_path}")
-    endif()
-
-    if(NOT "${return_code}" STREQUAL "0")
-        message(FATAL_ERROR "Conan install failed='${return_code}'")
-    endif()
-
-    # the files are generated in a folder that depends on the layout used, if
-    # one is specified, but we don't know a priori where this is.
-    # TODO: this can be made more robust if Conan can provide this in the json output
-    string(JSON conan_generators_folder GET "${conan_stdout}" graph nodes 0 generators_folder)
-    cmake_path(CONVERT ${conan_generators_folder} TO_CMAKE_PATH_LIST conan_generators_folder)
-
-    message(STATUS "CMake-Conan: CONAN_GENERATORS_FOLDER=${conan_generators_folder}")
-    set_property(GLOBAL PROPERTY CONAN_GENERATORS_FOLDER "${conan_generators_folder}")
-    # reconfigure on conanfile changes
-    string(JSON conanfile GET "${conan_stdout}" graph nodes 0 label)
-    message(STATUS "CMake-Conan: CONANFILE=${CMAKE_SOURCE_DIR}/${conanfile}")
-    set_property(DIRECTORY ${CMAKE_SOURCE_DIR} APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/${conanfile}")
-    # success
-    set_property(GLOBAL PROPERTY CONAN_INSTALL_SUCCESS TRUE)
-
-endfunction()
-
-
-function(conan_get_version conan_command conan_current_version)
-    execute_process(
-            COMMAND ${conan_command} --version
-            OUTPUT_VARIABLE conan_output
-            RESULT_VARIABLE conan_result
-            OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-    if(conan_result)
-        message(FATAL_ERROR "CMake-Conan: Error when trying to run Conan")
-    endif()
-
-    string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" conan_version ${conan_output})
-    set(${conan_current_version} ${conan_version} PARENT_SCOPE)
-endfunction()
-
-
-function(conan_version_check)
-    set(options )
-    set(one_value_args MINIMUM CURRENT)
-    set(multi_value_args )
-    cmake_parse_arguments(conan_version_check
-            "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN})
-
-    if(NOT conan_version_check_MINIMUM)
-        message(FATAL_ERROR "CMake-Conan: Required parameter MINIMUM not set!")
-    endif()
-    if(NOT conan_version_check_CURRENT)
-        message(FATAL_ERROR "CMake-Conan: Required parameter CURRENT not set!")
-    endif()
-
-    if(conan_version_check_CURRENT VERSION_LESS conan_version_check_MINIMUM)
-        message(FATAL_ERROR "CMake-Conan: Conan version must be ${conan_version_check_MINIMUM} or later")
-    endif()
-endfunction()
-
-
-macro(construct_profile_argument argument_variable profile_list)
-    set(${argument_variable} "")
-    if("${profile_list}" STREQUAL "CONAN_HOST_PROFILE")
-        set(_arg_flag "--profile:host=")
-    elseif("${profile_list}" STREQUAL "CONAN_BUILD_PROFILE")
-        set(_arg_flag "--profile:build=")
-    endif()
-
-    set(_profile_list "${${profile_list}}")
-    list(TRANSFORM _profile_list REPLACE "auto-cmake" "${CMAKE_BINARY_DIR}/conan_host_profile")
-    list(TRANSFORM _profile_list PREPEND ${_arg_flag})
-    set(${argument_variable} ${_profile_list})
-
-    unset(_arg_flag)
-    unset(_profile_list)
-endmacro()
-
-
-macro(conan_provide_dependency method package_name)
-    set_property(GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED TRUE)
-    get_property(_conan_install_success GLOBAL PROPERTY CONAN_INSTALL_SUCCESS)
-    if(NOT _conan_install_success)
-        if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
-            set(CONAN_COMMAND "${CMAKE_SOURCE_DIR}/build/bin/conan.exe")
-        else ()
-            set(CONAN_COMMAND "${CMAKE_SOURCE_DIR}/build/bin/conan")
-        endif ()
-        if(NOT EXISTS ${CONAN_COMMAND})
-            message(STATUS "CMake-Conan: Local conan not found, attempting to download it.")
-            execute_process(COMMAND "${CMAKE_COMMAND}" -P "${CMAKE_SOURCE_DIR}/cmake/ConanGet.cmake"
-                    RESULT_VARIABLE result
-                    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}")
-            if(NOT result EQUAL 0)
-                message(FATAL_ERROR "Failed to download conan.")
-            endif()
-        endif()
-        if(NOT EXISTS ${CONAN_COMMAND})
-            message(FATAL_ERROR "Conan executable not found at ${CONAN_COMMAND} after trying to download it. Also, make sure it has execution permissions.")
-        endif()
-        conan_get_version(${CONAN_COMMAND} CONAN_CURRENT_VERSION)
-        conan_version_check(MINIMUM ${CONAN_MINIMUM_VERSION} CURRENT ${CONAN_CURRENT_VERSION})
-        message(STATUS "CMake-Conan: first find_package() found. Installing dependencies with Conan")
-        if("default" IN_LIST CONAN_HOST_PROFILE OR "default" IN_LIST CONAN_BUILD_PROFILE)
-            conan_profile_detect_default()
-        endif()
-        if("auto-cmake" IN_LIST CONAN_HOST_PROFILE)
-            detect_host_profile(${CMAKE_BINARY_DIR}/conan_host_profile)
-        endif()
-        construct_profile_argument(_host_profile_flags CONAN_HOST_PROFILE)
-        construct_profile_argument(_build_profile_flags CONAN_BUILD_PROFILE)
-        if(EXISTS "${CMAKE_SOURCE_DIR}/conanfile.py")
-            file(READ "${CMAKE_SOURCE_DIR}/conanfile.py" outfile)
-            if(NOT "${outfile}" MATCHES ".*CMakeDeps.*")
-                message(WARNING "Cmake-conan: CMakeDeps generator was not defined in the conanfile")
-            endif()
-            set(generator "")
-        elseif (EXISTS "${CMAKE_SOURCE_DIR}/conanfile.txt")
-            file(READ "${CMAKE_SOURCE_DIR}/conanfile.txt" outfile)
-            if(NOT "${outfile}" MATCHES ".*CMakeDeps.*")
-                message(WARNING "Cmake-conan: CMakeDeps generator was not defined in the conanfile. "
-                        "Please define the generator as it will be mandatory in the future")
-            endif()
-            set(generator "-g;CMakeDeps")
-        endif()
-        get_property(_multiconfig_generator GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-        if(NOT _multiconfig_generator)
-            message(STATUS "CMake-Conan: Installing single configuration ${CMAKE_BUILD_TYPE}")
-            conan_install(${_host_profile_flags} ${_build_profile_flags} ${CONAN_INSTALL_ARGS} ${generator})
-        else()
-            message(STATUS "CMake-Conan: Installing both Debug and Release")
-            conan_install(${_host_profile_flags} ${_build_profile_flags} -s build_type=Release ${CONAN_INSTALL_ARGS} ${generator})
-            conan_install(${_host_profile_flags} ${_build_profile_flags} -s build_type=Debug ${CONAN_INSTALL_ARGS} ${generator})
-        endif()
-        unset(_host_profile_flags)
-        unset(_build_profile_flags)
-        unset(_multiconfig_generator)
-        unset(_conan_install_success)
-    else()
-        message(STATUS "CMake-Conan: find_package(${ARGV1}) found, 'conan install' already ran")
-        unset(_conan_install_success)
-    endif()
-
-    get_property(_conan_generators_folder GLOBAL PROPERTY CONAN_GENERATORS_FOLDER)
-
-    # Ensure that we consider Conan-provided packages ahead of any other,
-    # irrespective of other settings that modify the search order or search paths
-    # This follows the guidelines from the find_package documentation
-    #  (https://cmake.org/cmake/help/latest/command/find_package.html):
-    #       find_package (<PackageName> PATHS paths... NO_DEFAULT_PATH)
-    #       find_package (<PackageName>)
-
-    # Filter out `REQUIRED` from the argument list, as the first call may fail
-    set(_find_args_${package_name} "${ARGN}")
-    list(REMOVE_ITEM _find_args_${package_name} "REQUIRED")
-    if(NOT "MODULE" IN_LIST _find_args_${package_name})
-        find_package(${package_name} ${_find_args_${package_name}} BYPASS_PROVIDER PATHS "${_conan_generators_folder}" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
-        unset(_find_args_${package_name})
-    endif()
-
-    # Invoke find_package a second time - if the first call succeeded,
-    # this will simply reuse the result. If not, fall back to CMake default search
-    # behaviour, also allowing modules to be searched.
-    if(NOT ${package_name}_FOUND)
-        list(FIND CMAKE_MODULE_PATH "${_conan_generators_folder}" _index)
-        if(_index EQUAL -1)
-            list(PREPEND CMAKE_MODULE_PATH "${_conan_generators_folder}")
-        endif()
-        unset(_index)
-        find_package(${package_name} ${ARGN} BYPASS_PROVIDER)
-        list(REMOVE_ITEM CMAKE_MODULE_PATH "${_conan_generators_folder}")
-    endif()
-endmacro()
-
-
-cmake_language(
-        SET_DEPENDENCY_PROVIDER conan_provide_dependency
-        SUPPORTED_METHODS FIND_PACKAGE
-)
-
-
-macro(conan_provide_dependency_check)
-    set(_conan_provide_dependency_invoked FALSE)
-    get_property(_conan_provide_dependency_invoked GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED)
-    if(NOT _conan_provide_dependency_invoked)
-        message(WARNING "Conan is correctly configured as dependency provider, "
-                "but Conan has not been invoked. Please add at least one "
-                "call to `find_package()`.")
-        if(DEFINED CONAN_COMMAND)
-            # supress warning in case `CONAN_COMMAND` was specified but unused.
-            set(_conan_command ${CONAN_COMMAND})
-            unset(_conan_command)
-        endif()
-    endif()
-    unset(_conan_provide_dependency_invoked)
-endmacro()
-
-
-# Add a deferred call at the end of processing the top-level directory
-# to check if the dependency provider was invoked at all.
-cmake_language(DEFER DIRECTORY "${CMAKE_SOURCE_DIR}" CALL conan_provide_dependency_check)
-
-# Configurable variables for Conan profiles
-set(CONAN_HOST_PROFILE "default;auto-cmake" CACHE STRING "Conan host profile")
-set(CONAN_BUILD_PROFILE "default" CACHE STRING "Conan build profile")
-set(CONAN_INSTALL_ARGS "--build=missing" CACHE STRING "Command line arguments for conan install")
-
-find_program(_cmake_program NAMES cmake NO_PACKAGE_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH NO_CMAKE_FIND_ROOT_PATH)
-if(NOT _cmake_program)
-    get_filename_component(PATH_TO_CMAKE_BIN "${CMAKE_COMMAND}" DIRECTORY)
-    set(PATH_TO_CMAKE_BIN "${PATH_TO_CMAKE_BIN}" CACHE INTERNAL "Path where the CMake executable is")
-endif()
-
-cmake_policy(POP)

cmake/DocBuilder.cmake

@@ -1,45 +0,0 @@
-set(MKDOCS_SRC "${CMAKE_SOURCE_DIR}/docs")
-set(MKDOCS_OUT "${CMAKE_BINARY_DIR}/../docs")
-
-message("MKDocs src: ${MKDOCS_SRC} > ${MKDOCS_OUT}")
-
-file(MAKE_DIRECTORY "${MKDOCS_OUT}")
-
-add_custom_target(docs
-        COMMAND ${CMAKE_COMMAND} -E env PYTHONUNBUFFERED=1
-        mkdocs build
-        --clean
-        --site-dir "${MKDOCS_OUT}"
-        --config-file "${MKDOCS_SRC}/mkdocs.yml"
-        WORKING_DIRECTORY "${MKDOCS_SRC}"
-        COMMENT "Generating documentation with MkDocs"
-        VERBATIM
-)
-
-# Optional install step
-install(DIRECTORY "${MKDOCS_OUT}/"
-        DESTINATION "share/doc/${PROJECT_NAME}")
-
-add_custom_target(install-docs
-        DEPENDS docs
-        COMMAND "${CMAKE_COMMAND}" --install . --component docs
-        COMMENT "Installing documentation")
-
-# Name of the target that launches the dev server
-add_custom_target(
-        serve_docs                     # ← invoke with `make serve_docs`
-        COMMAND ${CMAKE_COMMAND} -E env PYTHONUNBUFFERED=1
-        # On Windows we need to run the command through the shell
-        # so that the `&&` operator works correctly.
-        ${CMAKE_COMMAND} -E env
-        mkdocs serve
-        --dev-addr "127.0.0.1:8000"      # optional – explicit bind address
-        --watch "${MKDOCS_SRC}" # watch source files for changes
-        --config-file "${MKDOCS_SRC}/mkdocs.yml"
-        WORKING_DIRECTORY "${MKDOCS_SRC}"
-        USES_TERMINAL                  # tells CMake to attach the child process to the console
-        COMMENT "Starting MkDocs live‑preview server (Ctrl‑C to stop)"
-        VERBATIM
-)
-
-add_dependencies(serve_docs docs)   # ensures the static site is up‑to‑date before serving

cmake/FindCcache.cmake

@@ -1,8 +0,0 @@
-find_program(CCACHE_FOUND ccache)
-if (CCACHE_FOUND)
-    message(STATUS "Found usable ccache: ${CCACHE_FOUND}")
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_FOUND} cache_dir=${CMAKE_SOURCE_DIR}/build/.ccache")
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK    "${CCACHE_FOUND} cache_dir=${CMAKE_SOURCE_DIR}/build/.ccache")
-else()
-    message(STATUS "ccache NOT found! Please install it for faster rebuilds.")
-endif()

cmake/profiles/apple-clang-armv8

@@ -1,9 +0,0 @@
-[settings]
-os=Macos
-arch=armv8
-compiler=apple-clang
-compiler.version=13
-compiler.libcxx=libc++
-
-[conf]
-

cmake/profiles/apple-clang-x86_64

@@ -1,8 +0,0 @@
-[settings]
-os=Macos
-arch=x86_64
-compiler=apple-clang
-compiler.version=13
-compiler.libcxx=libc++
-
-[conf]

cmake/profiles/gcc-linux-armv8

@@ -1,9 +0,0 @@
-[settings]
-os=Linux
-arch=armv8
-compiler=gcc
-compiler.version=11
-compiler.libcxx=libstdc++11
-
-[conf]
-tools.cmake.cmaketoolchain:user_presets=False

cmake/profiles/gcc-linux-x86_64

@@ -1,9 +0,0 @@
-[settings]
-os=Linux
-arch=x86_64
-compiler=gcc
-compiler.version=11
-compiler.libcxx=libstdc++11
-
-[conf]
-tools.cmake.cmaketoolchain:user_presets=False

cmake/profiles/msvc-193-x86_64

@@ -1,10 +0,0 @@
-[settings]
-arch=x86_64
-compiler=msvc
-compiler.cppstd=17
-compiler.runtime=static
-compiler.version=193
-os=Windows
-
-[conf]
-tools.cmake.cmaketoolchain:user_presets=False

cmake/profiles/msvc-194-x86_64

@@ -1,8 +0,0 @@
-[settings]
-arch=x86_64
-compiler=msvc
-compiler.cppstd=17
-compiler.runtime=static
-compiler.version=194
-os=Windows
-build_type=Release

cmake/test-static-assert.c

@@ -1,6 +0,0 @@
-#include <assert.h>
-
-static_assert(1, "FAIL");
-int main(int argc, char *argv[]) {
-	return 0;
-}