unit testst for utility-max3 supplied

.qtcreator/cmake-helper/LICENSE.conan

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2019 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.

.qtcreator/cmake-helper/conan_provider.cmake

@@ -1,657 +0,0 @@
-# https://github.com/conan-io/cmake-conan/blob/develop2/conan_provider.cmake
-# commit: f6464d1e13ef7a47c569f5061f9607ea63339d39
-#
-# The MIT License (MIT)
-#
-# Copyright (c) 2019 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)
-
-
-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)
-        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()
-    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 ${CMAKE_CXX_COMPILER_VERSION})
-        list(GET VERSION_LIST 0 _COMPILER_VERSION)
-    elseif(_COMPILER MATCHES Clang)
-        set(_COMPILER "clang")
-        string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION})
-        list(GET VERSION_LIST 0 _COMPILER_VERSION)
-    elseif(_COMPILER MATCHES GNU)
-        set(_COMPILER "gcc")
-        string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_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 "")
-    if(CMAKE_C_COMPILER)
-        set(_conan_c_compiler "\"c\":\"${CMAKE_C_COMPILER}\",")
-        set_conan_compiler_if_appleclang(C cc _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)
-    else()
-        message(WARNING "CMake-Conan: The C++ compiler is not defined. "
-                        "Please define CMAKE_CXX_COMPILER or enable the C++ language.")
-    endif()
-
-    # QtCreator: see https://github.com/conan-io/cmake-conan/pull/689 for details
-    if(NOT "x${_conan_c_compiler}${_conan_cpp_compiler}" STREQUAL "x"
-       AND NOT CMAKE_C_COMPILER_ID STREQUAL "MSVC")
-        string(APPEND PROFILE "tools.build:compiler_executables={${_conan_c_compiler}${_conan_cpp_compiler}}\n")
-    endif()
-    unset(_conan_c_compiler)
-    unset(_conan_cpp_compiler)
-endmacro()
-
-
-function(detect_host_profile output_file)
-    detect_os(MYOS MYOS_API_LEVEL MYOS_SDK MYOS_SUBSYSTEM MYOS_VERSION)
-    detect_arch(MYARCH)
-    detect_compiler(MYCOMPILER MYCOMPILER_VERSION MYCOMPILER_RUNTIME MYCOMPILER_RUNTIME_TYPE)
-    detect_cxx_standard(MYCXX_STANDARD)
-    detect_lib_cxx(MYLIB_CXX)
-    detect_build_type(MYBUILD_TYPE)
-
-    set(PROFILE "")
-    string(APPEND PROFILE "[settings]\n")
-    if(MYARCH)
-        string(APPEND PROFILE arch=${MYARCH} "\n")
-    endif()
-    if(MYOS)
-        string(APPEND PROFILE os=${MYOS} "\n")
-    endif()
-    if(MYOS_API_LEVEL)
-        string(APPEND PROFILE os.api_level=${MYOS_API_LEVEL} "\n")
-    endif()
-    if(MYOS_VERSION)
-        string(APPEND PROFILE os.version=${MYOS_VERSION} "\n")
-    endif()
-    if(MYOS_SDK)
-        string(APPEND PROFILE os.sdk=${MYOS_SDK} "\n")
-    endif()
-    if(MYOS_SUBSYSTEM)
-        string(APPEND PROFILE os.subsystem=${MYOS_SUBSYSTEM} "\n")
-    endif()
-    if(MYCOMPILER)
-        string(APPEND PROFILE compiler=${MYCOMPILER} "\n")
-    endif()
-    if(MYCOMPILER_VERSION)
-        string(APPEND PROFILE compiler.version=${MYCOMPILER_VERSION} "\n")
-    endif()
-    if(MYCOMPILER_RUNTIME)
-        string(APPEND PROFILE compiler.runtime=${MYCOMPILER_RUNTIME} "\n")
-    endif()
-    if(MYCOMPILER_RUNTIME_TYPE)
-        string(APPEND PROFILE compiler.runtime_type=${MYCOMPILER_RUNTIME_TYPE} "\n")
-    endif()
-    if(MYCXX_STANDARD)
-        string(APPEND PROFILE compiler.cppstd=${MYCXX_STANDARD} "\n")
-    endif()
-    if(MYLIB_CXX)
-        string(APPEND PROFILE compiler.libcxx=${MYLIB_CXX} "\n")
-    endif()
-    if(MYBUILD_TYPE)
-        string(APPEND PROFILE "build_type=${MYBUILD_TYPE}\n")
-    endif()
-
-    if(NOT DEFINED output_file)
-        set(_FN "${CMAKE_BINARY_DIR}/profile")
-    else()
-        set(_FN ${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(MYOS STREQUAL "Android")
-        string(APPEND PROFILE "tools.android:ndk_path=${CMAKE_ANDROID_NDK}\n")
-    endif()
-
-    message(STATUS "CMake-Conan: Creating profile ${_FN}")
-    file(WRITE ${_FN} ${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)
-    cmake_parse_arguments(ARGS CONAN_ARGS ${ARGN})
-    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}'")
-    else()
-        # 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("conan stdout: ${conan_stdout}")
-        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)
-    endif()
-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(oneValueArgs MINIMUM CURRENT)
-    set(multiValueArgs )
-    cmake_parse_arguments(CONAN_VERSION_CHECK
-        "${options}" "${oneValueArgs}" "${multiValueArgs}" ${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)
-        find_program(CONAN_COMMAND "conan" REQUIRED)
-        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()
-
-#[=[ not needed by Qt Creator, and if not commented it would break the auto-setup feature
-
-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()
-

.qtcreator/cmake-helper/maintenance_tool_provider.cmake

@@ -1,266 +0,0 @@
-function(qt_maintenance_tool_get_component_platform platform_dir component_platform)
-  # Mapping between platform file directory and component platform
-  set(map_llvm-mingw_64 win64_llvm_mingw)
-  set(map_mingw_64 win64_mingw)
-  set(map_msvc2019_64 win64_msvc2019_64)
-  set(map_msvc2022_64 win64_msvc2022_64)
-  set(map_msvc2022_arm64 win64_msvc2022_arm64)
-  set(map_gcc_64 linux_gcc_64)
-  set(map_gcc_arm64 linux_gcc_arm64)
-  set(map_ios ios)
-  set(map_macos clang_64)
-  set(map_android_arm64_v8a android)
-  set(map_android_armv7 android)
-  set(map_android_x86 android)
-  set(map_android_x86_64 android)
-  set(map_wasm_multithread wasm_multithread)
-  set(map_wasm_singlethread wasm_singlethread)
-
-  if (platform_dir STREQUAL "msvc2022_arm64" AND QT_HOST_PATH)
-    set(${component_platform} "win64_msvc2022_arm64_cross_compiled" PARENT_SCOPE)
-    return()
-  endif()
-
-  set(${component_platform} ${map_${platform_dir}} PARENT_SCOPE)
-endfunction()
-
-function(qt_maintenance_tool_get_addons addon_list)
-  set(${addon_list}
-    qt3d
-    qt5compat
-    qtcanvaspainter
-    qtcharts
-    qtconnectivity
-    qtcoap
-    qtdatavis3d
-    qtgraphs
-    qtgrpc
-    qthttpserver
-    qtimageformats
-    qtlocation
-    qtlottie
-    qtmultimedia
-    qtnetworkauth
-    qtpositioning
-    qtquick3d
-    qtquick3dphysics
-    qtquickeffectmaker
-    qtquicktimeline
-    qtopenapi
-    qtremoteobjects
-    qtscxml
-    qtsensors
-    qtserialbus
-    qtserialport
-    qtshadertools
-    qtspeech
-    qttasktree
-    qtvirtualkeyboard
-    qtwebchannel
-    qtwebsockets
-    qtwebview
-
-    # found in commercial version
-    qtapplicationmanager
-    qtinterfraceframework
-    qtlanguageserver
-    qtmqtt
-    qtstatemachine
-    qtopcua
-    tqtc-qtvncserver
-
-    PARENT_SCOPE
-  )
-endfunction()
-
-function(qt_maintenance_tool_get_extensions extensions)
-  set(${extensions}
-    qtinsighttracker
-    qtpdf
-    qtwebengine
-
-    PARENT_SCOPE
-  )
-endfunction()
-
-function(qt_maintenance_tool_get_standalone_addons standalone_addons_list)
-  set(${standalone_addons_list}
-    qtquick3d
-    qt5compat
-    qtshadertools
-    qtquicktimeline
-
-    PARENT_SCOPE
-  )
-endfunction()
-
-function(qt_maintenance_tool_install qt_major_version qt_package_list)
-  if (QT_QMAKE_EXECUTABLE MATCHES ".*/(.*)/(.*)/bin/qmake")
-    set(qt_version_number ${CMAKE_MATCH_1})
-    string(REPLACE "." "" qt_version_number_dotless ${qt_version_number})
-    set(qt_build_flavor ${CMAKE_MATCH_2})
-
-    set(additional_addons "")
-    qt_maintenance_tool_get_extensions(__qt_extensions)
-    if (qt_version_number VERSION_LESS 6.8.0)
-      set(additional_addons ${__qt_extensions})
-    endif()
-    if (WIN32)
-      list(APPEND additional_addons qtactiveqt)
-    endif()
-    if (UNIX AND NOT APPLE)
-      list(APPEND additional_addons qtwaylandcompositor)
-    endif()
-
-    qt_maintenance_tool_get_component_platform(${qt_build_flavor} component_platform)
-    if (NOT component_platform)
-      message(STATUS
-        "Qt Creator: Could not find the component platform for '${qt_build_flavor}' "
-        "required by the MaintenanceTool. This can happen with a non Qt SDK installation "
-        "(e.g. system Linux or macOS homebrew).")
-      return()
-    endif()
-
-    set(installer_component_list "")
-    foreach (qt_package_name IN LISTS qt_package_list)
-      string(TOLOWER "${qt_package_name}" qt_package_name_lowercase)
-
-      qt_maintenance_tool_get_addons(__qt_addons)
-      if (qt_version_number VERSION_LESS 6.8.0)
-        qt_maintenance_tool_get_standalone_addons(__standalone_addons)
-        foreach(standalone_addon IN LISTS __standalone_addons)
-          list(REMOVE_ITEM __qt_addons ${standalone_addon})
-        endforeach()
-      endif()
-
-      # Is the package an addon?
-      set(install_addon FALSE)
-      foreach(addon IN LISTS __qt_addons additional_addons)
-        string(REGEX MATCH "^${addon}$" is_addon "qt${qt_package_name_lowercase}")
-        if (is_addon)
-          list(
-            APPEND installer_component_list
-            "qt.qt${qt_major_version}.${qt_version_number_dotless}.addons.${addon}"
-          )
-          set(install_addon TRUE)
-          break()
-        endif()
-      endforeach()
-
-      if (NOT install_addon)
-        set(install_extension FALSE)
-        foreach(extension IN LISTS __qt_extensions)
-          string(REGEX MATCH "^${extension}$" is_extension "qt${qt_package_name_lowercase}")
-          if (is_extension)
-            list(
-              APPEND installer_component_list
-              "extensions.${extension}.${qt_version_number_dotless}.${component_platform}"
-            )
-            set(install_extension TRUE)
-            break()
-          endif()
-        endforeach()
-
-        if (NOT install_extension)
-          set(install_standalone_addon FALSE)
-          foreach(standalone_addon IN LISTS __standalone_addons)
-            string(REGEX MATCH "^${standalone_addon}$" is_standalone_addon "qt${qt_package_name_lowercase}")
-            if (is_standalone_addon)
-              list(
-                APPEND installer_component_list
-                "qt.qt${qt_major_version}.${qt_version_number_dotless}.${standalone_addon}"
-              )
-              set(install_standalone_addon TRUE)
-              break()
-            endif()
-          endforeach()
-
-          if(NOT install_standalone_addon)
-            # Install the Desktop package
-            list(
-              APPEND installer_component_list
-              "qt.qt${qt_major_version}.${qt_version_number_dotless}.${component_platform}"
-            )
-          endif()
-        endif()
-      endif()
-    endforeach()
-
-    # THIS MESSAGE IS PARSED IN THE CMakeOutputParser
-    message(WARNING "Qt packages are missing: ${qt_version_number}, ${qt_build_flavor}, ${installer_component_list}\n"
-                    "If you are using the Qt Online Installer, check the Issues view in Qt Creator "
-                    "for a link that installs the missing component.")
-  endif()
-endfunction()
-
-macro(qt_maintenance_tool_dependency method package_name)
-  # Work around upstream cmake issue: https://gitlab.kitware.com/cmake/cmake/-/issues/27169
-  if(ANDROID
-      AND CMAKE_VERSION VERSION_GREATER_EQUAL 3.29
-      AND NOT ANDROID_USE_LEGACY_TOOLCHAIN_FILE
-      AND NOT CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS
-      AND NOT QT_NO_SET_MAINTENANCE_TOOL_PROVIDER_POLICY_CMP0155
-    )
-    message(DEBUG
-      "Setting policy CMP0155 to OLD inside qt_maintenance_tool_dependency to avoid "
-      "issues with not being able to find the Threads package when targeting Android with "
-      "cmake_minimum_required(3.29) and CMAKE_CXX_STANDARD >= 20."
-    )
-    # We don't create an explicit policy stack entry before changing the policy, because setting
-    # the policy value bubbles it up to the parent find_package() scope, which is fine, that's
-    # exactly the scope we want to modify.
-    cmake_policy(SET CMP0155 OLD)
-  endif()
-
-  if (${package_name} MATCHES "^Qt([5-9])(.*)$")
-    set(__qt_dependency_qt_major_version ${CMAKE_MATCH_1})
-    set(__qt_dependency_qt_package_name ${CMAKE_MATCH_2})
-
-    # https://cmake.org/cmake/help/latest/command/find_package.html
-    set(__qt_dependency_options
-      CONFIG NO_MODULE MODULE REQUIRED EXACT QUIET GLOBAL NO_POLICY_SCOPE NO_DEFAULT_PATH NO_PACKAGE_ROOT_PATH
-      NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_PACKAGE_REGISTRY
-      NO_CMAKE_SYSTEM_PATH NO_CMAKE_INSTALL_PREFIX NO_CMAKE_SYSTEM_PACKAGE_REGISTRY CMAKE_FIND_ROOT_PATH_BOTH
-      ONLY_CMAKE_FIND_ROOT_PATH NO_CMAKE_FIND_ROOT_PATH
-    )
-    set(__qt_dependency_oneValueArgs REGISTRY_VIEW)
-    set(__qt_dependency_multiValueArgs COMPONENTS OPTIONAL_COMPONENTS NAMES CONFIGS HINTS PATHS PATH_SUFFIXES)
-    cmake_parse_arguments(__qt_dependency_arg "${__qt_dependency_options}" "${__qt_dependency_oneValueArgs}" "${__qt_dependency_multiValueArgs}" ${ARGN})
-
-    if (__qt_dependency_arg_REQUIRED AND __qt_dependency_arg_COMPONENTS)
-      # Install missing COMPONENTS.
-      set(__qt_dependency_pkgs_to_install "")
-      foreach(pkg IN LISTS __qt_dependency_arg_COMPONENTS)
-        find_package(Qt${__qt_dependency_qt_major_version}${pkg}
-          PATHS ${CMAKE_PREFIX_PATH} ${CMAKE_MODULE_PATH} NO_DEFAULT_PATH BYPASS_PROVIDER QUIET)
-        if (NOT Qt${__qt_dependency_qt_major_version}${pkg}_FOUND)
-          list(APPEND __qt_dependency_pkgs_to_install ${pkg})
-        endif()
-      endforeach()
-      if (__qt_dependency_pkgs_to_install)
-        qt_maintenance_tool_install("${__qt_dependency_qt_major_version}" "${__qt_dependency_pkgs_to_install}")
-      endif()
-    elseif(__qt_dependency_arg_REQUIRED AND NOT __qt_dependency_qt_package_name)
-      # Install the Desktop package if Qt::Core is missing
-      find_package(Qt${__qt_dependency_qt_major_version}Core
-        PATHS ${CMAKE_PREFIX_PATH} ${CMAKE_MODULE_PATH} NO_DEFAULT_PATH BYPASS_PROVIDER QUIET)
-      if (NOT Qt${__qt_dependency_qt_major_version}$Core_FOUND)
-        qt_maintenance_tool_install("${__qt_dependency_qt_major_version}" Core)
-      endif()
-    endif()
-
-    find_package(${package_name} ${ARGN}
-      PATHS ${CMAKE_PREFIX_PATH} ${CMAKE_MODULE_PATH} NO_DEFAULT_PATH BYPASS_PROVIDER QUIET)
-    if (NOT ${package_name}_FOUND AND __qt_dependency_arg_REQUIRED)
-      qt_maintenance_tool_install("${__qt_dependency_qt_major_version}" "${__qt_dependency_qt_package_name}")
-      find_package(${package_name} ${ARGN} BYPASS_PROVIDER)
-    endif()
-  else()
-    find_package(${package_name} ${ARGN} BYPASS_PROVIDER)
-  endif()
-endmacro()
-
-cmake_language(
-    SET_DEPENDENCY_PROVIDER qt_maintenance_tool_dependency
-    SUPPORTED_METHODS FIND_PACKAGE
-)

.qtcreator/cmake-helper/package-manager.cmake

@@ -1,325 +0,0 @@
-if (EXISTS "${CMAKE_SOURCE_DIR}/QtCreatorPackageManager.cmake")
-  include("${CMAKE_SOURCE_DIR}/QtCreatorPackageManager.cmake")
-endif()
-
-if (NOT QT_CREATOR_ENABLE_PACKAGE_MANAGER_SETUP)
-  return()
-endif()
-
-macro(qtc_auto_setup_compiler_standard toolchainFile)
-  foreach(lang_var C CXX CUDA OBJC OBJCXX)
-    foreach(prop_var STANDARD STANDARD_REQUIRED EXTENSIONS)
-      if (CMAKE_${lang_var}_${prop_var})
-        file(APPEND "${toolchainFile}"
-             "set(CMAKE_${lang_var}_${prop_var} ${CMAKE_${lang_var}_${prop_var}})\n")
-      endif()
-    endforeach()
-  endforeach()
-
-  # If the ENV{ANDROID_NDK_HOME} exists pass it via the ANDROID_NDK variable
-  if (DEFINED ENV{ANDROID_NDK_HOME})
-      set(ANDROID_NDK "$ENV{ANDROID_NDK_HOME}")
-  endif()
-
-  # Forward important CMake variables to the package manager in the toolchain file
-  foreach(fwd_var CMAKE_MSVC_RUNTIME_LIBRARY CMAKE_SYSROOT
-                  CMAKE_OSX_SYSROOT CMAKE_OSX_ARCHITECTURES
-                  ANDROID_ABI ANDROID_NDK)
-    if (${fwd_var})
-      file(APPEND "${toolchainFile}"
-          "set(${fwd_var} \"${${fwd_var}}\")\n")
-    endif()
-  endforeach()
-endmacro()
-
-#
-# conan
-#
-macro(qtc_auto_setup_conan)
-  foreach(file conanfile.txt conanfile.py)
-    if (EXISTS "${CMAKE_SOURCE_DIR}/${file}")
-      set(conanfile_txt "${CMAKE_SOURCE_DIR}/${file}")
-      break()
-    endif()
-  endforeach()
-
-  if (conanfile_txt AND NOT QT_CREATOR_SKIP_CONAN_SETUP)
-    option(QT_CREATOR_SKIP_CONAN_SETUP "Skip Qt Creator's conan package manager auto-setup" OFF)
-    set(QT_CREATOR_CONAN_BUILD_POLICY "missing" CACHE STRING "Qt Creator's conan package manager auto-setup build policy. This is used for the BUILD property of cmake_conan_run")
-
-    set_property(
-      DIRECTORY "${CMAKE_SOURCE_DIR}"
-      APPEND
-      PROPERTY CMAKE_CONFIGURE_DEPENDS "${conanfile_txt}")
-
-    find_program(conan_program conan)
-    if (NOT conan_program)
-      message(WARNING "Qt Creator: conan executable not found. "
-                      "Package manager auto-setup will be skipped. "
-                      "To disable this warning set QT_CREATOR_SKIP_CONAN_SETUP to ON.")
-      return()
-    endif()
-    execute_process(COMMAND ${conan_program} --version
-      RESULT_VARIABLE result_code
-      OUTPUT_VARIABLE conan_version_output
-      ERROR_VARIABLE conan_version_output)
-    if (NOT result_code EQUAL 0)
-      message(FATAL_ERROR "conan --version failed='${result_code}: ${conan_version_output}")
-    endif()
-
-    string(REGEX REPLACE ".*Conan version ([0-9].[0-9]).*" "\\1" conan_version "${conan_version_output}")
-
-    set(conanfile_timestamp_file "${CMAKE_BINARY_DIR}/conan-dependencies/conanfile.timestamp")
-    file(TIMESTAMP "${conanfile_txt}" conanfile_timestamp)
-
-    set(do_conan_installation ON)
-    if (EXISTS "${conanfile_timestamp_file}")
-      file(READ "${conanfile_timestamp_file}" old_conanfile_timestamp)
-      if ("${conanfile_timestamp}" STREQUAL "${old_conanfile_timestamp}")
-        set(do_conan_installation OFF)
-      endif()
-    endif()
-
-    set(conanfile_build_policy_file "${CMAKE_BINARY_DIR}/conan-dependencies/conanfile.buildpolicy")
-    if (EXISTS "${conanfile_build_policy_file}")
-      file(READ "${conanfile_build_policy_file}" build_policy)
-      if (NOT "${build_policy}" STREQUAL "${QT_CREATOR_CONAN_BUILD_POLICY}")
-        set(do_conan_installation ON)
-      endif()
-    endif()
-
-    if (do_conan_installation)
-      message(STATUS "Qt Creator: conan package manager auto-setup. "
-                     "Skip this step by setting QT_CREATOR_SKIP_CONAN_SETUP to ON.")
-
-      file(COPY "${conanfile_txt}" DESTINATION "${CMAKE_BINARY_DIR}/conan-dependencies/")
-
-      # conanfile should have a generator specified, when both file and conan_install
-      # specifcy the CMakeDeps or CMakeConfigDeps generator, conan_install will issue an error
-      file(READ "${conanfile_txt}" conanfile_text_content)
-      if (NOT "${conanfile_text_content}" MATCHES ".*(CMakeDeps|CMakeConfigDeps).*")
-        message(WARNING "Qt Creator: CMakeDeps or CMakeConfigDeps generator was not defined in the conanfile.")
-      endif()
-
-      file(WRITE "${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake" "
-        set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\")
-        set(CMAKE_CXX_COMPILER \"${CMAKE_CXX_COMPILER}\")
-        ")
-      qtc_auto_setup_compiler_standard("${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake")
-
-      if (CMAKE_TOOLCHAIN_FILE)
-        file(APPEND "${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake"
-          "include(\"${CMAKE_TOOLCHAIN_FILE}\")\n")
-      endif()
-
-      file(WRITE "${CMAKE_BINARY_DIR}/conan-dependencies/CMakeLists.txt" "
-        cmake_minimum_required(VERSION 3.15)
-
-        unset(CMAKE_PROJECT_INCLUDE_BEFORE CACHE)
-        project(conan-setup)
-
-        if (${conan_version} VERSION_GREATER_EQUAL 2.0)
-          set(CONAN_COMMAND \"${conan_program}\")
-          include(\"${CMAKE_CURRENT_LIST_DIR}/conan_provider.cmake\")
-          conan_profile_detect_default()
-          detect_host_profile(\"${CMAKE_BINARY_DIR}/conan-dependencies/conan_host_profile\")
-
-          set(build_types \${CMAKE_BUILD_TYPE})
-          if (CMAKE_CONFIGURATION_TYPES)
-            set(build_types \${CMAKE_CONFIGURATION_TYPES})
-          endif()
-
-          foreach(type \${build_types})
-            conan_install(
-              -pr \"${CMAKE_BINARY_DIR}/conan-dependencies/conan_host_profile\"
-              --build=${QT_CREATOR_CONAN_BUILD_POLICY}
-              -s build_type=\${type}
-            )
-          endforeach()
-
-          get_property(CONAN_INSTALL_SUCCESS GLOBAL PROPERTY CONAN_INSTALL_SUCCESS)
-          if (CONAN_INSTALL_SUCCESS)
-            get_property(CONAN_GENERATORS_FOLDER GLOBAL PROPERTY CONAN_GENERATORS_FOLDER)
-            file(TO_CMAKE_PATH \"\${CONAN_GENERATORS_FOLDER}\" CONAN_GENERATORS_FOLDER)
-            file(WRITE \"${CMAKE_BINARY_DIR}/conan-dependencies/conan_paths.cmake\" \"
-              list(PREPEND CMAKE_PREFIX_PATH \\\"\${CONAN_GENERATORS_FOLDER}\\\")
-              list(PREPEND CMAKE_MODULE_PATH \\\"\${CONAN_GENERATORS_FOLDER}\\\")
-              list(PREPEND CMAKE_FIND_ROOT_PATH \\\"\${CONAN_GENERATORS_FOLDER}\\\")
-              list(REMOVE_DUPLICATES CMAKE_PREFIX_PATH)
-              list(REMOVE_DUPLICATES CMAKE_MODULE_PATH)
-              list(REMOVE_DUPLICATES CMAKE_FIND_ROOT_PATH)
-              set(CMAKE_PREFIX_PATH \\\"\\\${CMAKE_PREFIX_PATH}\\\" CACHE STRING \\\"\\\" FORCE)
-              set(CMAKE_MODULE_PATH \\\"\\\${CMAKE_MODULE_PATH}\\\" CACHE STRING \\\"\\\" FORCE)
-              set(CMAKE_FIND_ROOT_PATH \\\"\\\${CMAKE_FIND_ROOT_PATH}\\\" CACHE STRING \\\"\\\" FORCE)
-            \")
-          endif()
-        else()
-          include(\"${CMAKE_CURRENT_LIST_DIR}/conan.cmake\")
-          conan_cmake_run(
-            CONANFILE \"${conanfile_txt}\"
-            INSTALL_FOLDER \"${CMAKE_BINARY_DIR}/conan-dependencies\"
-            GENERATORS cmake_paths cmake_find_package json
-            BUILD ${QT_CREATOR_CONAN_BUILD_POLICY}
-            ENV CONAN_CMAKE_TOOLCHAIN_FILE=\"${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake\"
-          )
-        endif()
-      ")
-
-      if (NOT DEFINED CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
-          set(CMAKE_CONFIGURATION_TYPES "Debug;Release")
-      endif()
-
-      execute_process(COMMAND ${CMAKE_COMMAND}
-        -S "${CMAKE_BINARY_DIR}/conan-dependencies/"
-        -B "${CMAKE_BINARY_DIR}/conan-dependencies/build"
-        -C "${CMAKE_BINARY_DIR}/qtcsettings.cmake"
-        -D "CMAKE_TOOLCHAIN_FILE=${CMAKE_BINARY_DIR}/conan-dependencies/toolchain.cmake"
-        -G ${CMAKE_GENERATOR}
-        -D CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-        -D "CMAKE_CONFIGURATION_TYPES=${CMAKE_CONFIGURATION_TYPES}"
-        RESULT_VARIABLE result
-      )
-      if (result EQUAL 0)
-        file(WRITE "${conanfile_timestamp_file}" "${conanfile_timestamp}")
-        file(WRITE "${conanfile_build_policy_file}" ${QT_CREATOR_CONAN_BUILD_POLICY})
-      else()
-        message(WARNING "Qt Creator's conan package manager auto-setup failed. Consider setting "
-                        "QT_CREATOR_SKIP_CONAN_SETUP to ON and reconfigure to skip this step.")
-        return()
-      endif()
-    endif()
-
-    include("${CMAKE_BINARY_DIR}/conan-dependencies/conan_paths.cmake")
-  endif()
-  unset(conanfile_txt)
-endmacro()
-qtc_auto_setup_conan()
-
-#
-# vcpkg
-#
-macro(qtc_auto_setup_vcpkg)
-  if (EXISTS "${CMAKE_SOURCE_DIR}/vcpkg.json" AND NOT QT_CREATOR_SKIP_VCPKG_SETUP)
-    option(QT_CREATOR_SKIP_VCPKG_SETUP "Skip Qt Creator's vcpkg package manager auto-setup" OFF)
-
-    set_property(
-      DIRECTORY "${CMAKE_SOURCE_DIR}"
-      APPEND
-      PROPERTY CMAKE_CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/vcpkg.json")
-
-    find_program(vcpkg_program vcpkg
-      PATHS ${CMAKE_SOURCE_DIR}/vcpkg ${CMAKE_SOURCE_DIR}/3rdparty/vcpkg $ENV{VCPKG_ROOT}
-      NO_DEFAULT_PATH
-    )
-    if (NOT vcpkg_program)
-      message(WARNING "Qt Creator: vcpkg executable not found. "
-                      "Package manager auto-setup will be skipped. "
-                      "To disable this warning set QT_CREATOR_SKIP_VCPKG_SETUP to ON.")
-      return()
-    endif()
-    execute_process(COMMAND ${vcpkg_program} version
-      RESULT_VARIABLE result_code
-      OUTPUT_VARIABLE vcpkg_version_output
-      ERROR_VARIABLE vcpkg_version_output)
-    if (NOT result_code EQUAL 0)
-      message(FATAL_ERROR "vcpkg version failed='${result_code}: ${vcpkg_version_output}")
-    endif()
-
-    # Resolve any symlinks
-    get_filename_component(vpkg_program_real_path ${vcpkg_program} REALPATH)
-    get_filename_component(vpkg_root ${vpkg_program_real_path} DIRECTORY)
-
-    if (NOT EXISTS "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake")
-      message(STATUS "Qt Creator: vcpkg package manager auto-setup. "
-                     "Skip this step by setting QT_CREATOR_SKIP_VCPKG_SETUP to ON.")
-
-      file(WRITE "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" "
-        set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\")
-        set(CMAKE_CXX_COMPILER \"${CMAKE_CXX_COMPILER}\")
-        ")
-      qtc_auto_setup_compiler_standard("${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake")
-
-      # If set explicitly in Qt Creator's CMake parameters, just set it in the toolchain
-      if (VCPKG_TARGET_TRIPLET)
-        file(APPEND "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake"
-          "set(VCPKG_TARGET_TRIPLET \"${VCPKG_TARGET_TRIPLET}\")\n")
-      endif()
-
-      if (CMAKE_TOOLCHAIN_FILE AND NOT
-          CMAKE_TOOLCHAIN_FILE STREQUAL "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake")
-        file(APPEND "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake"
-          "include(\"${CMAKE_TOOLCHAIN_FILE}\")\n")
-      endif()
-
-      file(APPEND "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" [=[
-        if (VCPKG_TARGET_TRIPLET)
-          set(vcpkg_triplet ${VCPKG_TARGET_TRIPLET})
-        else()
-          if (ANDROID_ABI)
-            if (ANDROID_ABI STREQUAL "armeabi-v7a")
-              set(vcpkg_triplet arm-neon-android)
-            elseif (ANDROID_ABI STREQUAL "arm64-v8a")
-              set(vcpkg_triplet arm64-android)
-            elseif (ANDROID_ABI STREQUAL "x86")
-                set(vcpkg_triplet x86-android)
-            elseif (ANDROID_ABI STREQUAL "x86_64")
-                set(vcpkg_triplet x64-android)
-            else()
-                message(FATAL_ERROR "Unsupported Android ABI: ${ANDROID_ABI}")
-            endif()
-            set(ENV{ANDROID_NDK_HOME} "${ANDROID_NDK}")
-          elseif (WIN32)
-            if ("$ENV{PROCESSOR_ARCHITECTURE}" STREQUAL "ARM64")
-              set(vcpkg_triplet arm64-mingw-static)
-            else()
-              set(vcpkg_triplet x64-mingw-static)
-            endif()
-            if (CMAKE_CXX_COMPILER MATCHES ".*/(.*)/cl.exe")
-              string(TOLOWER ${CMAKE_MATCH_1} host_arch_lowercase)
-              set(vcpkg_triplet ${host_arch_lowercase}-windows)
-            endif()
-          elseif(APPLE)
-            # We're too early to use CMAKE_HOST_SYSTEM_PROCESSOR
-            execute_process(
-              COMMAND uname -m
-              OUTPUT_VARIABLE __apple_host_system_processor
-              OUTPUT_STRIP_TRAILING_WHITESPACE)
-            if (__apple_host_system_processor MATCHES "arm64")
-              set(vcpkg_triplet arm64-osx)
-            else()
-              set(vcpkg_triplet x64-osx)
-            endif()
-          else()
-            # We're too early to use CMAKE_HOST_SYSTEM_PROCESSOR
-            execute_process(
-              COMMAND uname -m
-              OUTPUT_VARIABLE __linux_host_system_processor
-              OUTPUT_STRIP_TRAILING_WHITESPACE)
-            if (__linux_host_system_processor MATCHES "aarch64")
-              set(vcpkg_triplet arm64-linux)
-            else()
-              set(vcpkg_triplet x64-linux)
-            endif()
-          endif()
-        endif()
-
-        set(VCPKG_TARGET_TRIPLET ${vcpkg_triplet})
-      ]=])
-
-      file(APPEND "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" "
-        include(\"${vpkg_root}/scripts/buildsystems/vcpkg.cmake\")
-      ")
-    endif()
-
-    set(CMAKE_TOOLCHAIN_FILE "${CMAKE_BINARY_DIR}/vcpkg-dependencies/toolchain.cmake" CACHE PATH "" FORCE)
-
-    # Save CMAKE_PREFIX_PATH and CMAKE_MODULE_PATH as cache variables
-    if (CMAKE_VERSION GREATER_EQUAL "3.19")
-      cmake_language(DEFER CALL list REMOVE_DUPLICATES CMAKE_PREFIX_PATH)
-      cmake_language(DEFER CALL list REMOVE_DUPLICATES CMAKE_MODULE_PATH)
-      cmake_language(DEFER CALL set CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH}" CACHE STRING "" FORCE)
-      cmake_language(DEFER CALL set CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" CACHE STRING "" FORCE)
-    endif()
-  endif()
-endmacro()
-qtc_auto_setup_vcpkg()

.qtcreator/cmake-helper/qtcreator-project.cmake

@@ -1,112 +0,0 @@
-#
-# Internal Qt Creator variable reference
-#
-foreach(qtcreator_var
-    QT_QMAKE_EXECUTABLE CMAKE_PREFIX_PATH CMAKE_C_COMPILER CMAKE_CXX_COMPILER
-    CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELWITHDEBINFO)
-  set(__just_reference_${qtcreator_var} ${${qtcreator_var}})
-endforeach()
-
-option(QT_CREATOR_SOURCE_GROUPS "Qt Creator source groups extensions" ON)
-if (QT_CREATOR_SOURCE_GROUPS)
-  source_group("Resources" REGULAR_EXPRESSION "\\.(pdf|plist|png|jpeg|jpg|storyboard|xcassets|qrc|svg|gif|ico|webp)$")
-  source_group("Forms" REGULAR_EXPRESSION "\\.(ui)$")
-  source_group("State charts" REGULAR_EXPRESSION "\\.(scxml)$")
-  source_group("Source Files" REGULAR_EXPRESSION
-    "\\.(C|F|M|c|c\\+\\+|cc|cpp|mpp|cxx|ixx|cppm|ccm|cxxm|c\\+\\+m|cu|f|f90|for|fpp|ftn|m|mm|rc|def|r|odl|idl|hpj|bat|qml|js)$"
-  )
-endif()
-
-#
-# Make sure the "cmake-helper" files are writable. See QTCREATORBUG-34151
-#
-if (CMAKE_VERSION GREATER_EQUAL "3.19" AND NOT QTCREATOR_CMAKE_HELPER_DIRECTORY)
-  set(QTCREATOR_CMAKE_HELPER_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}" CACHE INTERNAL "")
-  cmake_language(DEFER CALL
-    file CHMOD "${QTCREATOR_CMAKE_HELPER_DIRECTORY}"
-      DIRECTORY_PERMISSIONS
-        OWNER_READ OWNER_WRITE OWNER_EXECUTE
-        GROUP_READ GROUP_EXECUTE
-        WORLD_READ WORLD_EXECUTE)
-  cmake_language(DEFER CALL
-    file CHMOD_RECURSE "${QTCREATOR_CMAKE_HELPER_DIRECTORY}"
-      FILE_PERMISSIONS
-        OWNER_READ OWNER_WRITE
-        GROUP_READ
-        WORLD_READ)
-endif()
-
-#
-# Set a better default value for CMAKE_INSTALL_PREFIX
-#
-function(qtc_modify_default_install_prefix)
-  # If at configure time the user didn't specify a CMAKE_INSTALL_PREFIX variable
-  # Modules/CMakeGenericSystem.cmake will set a default value
-  # to CMAKE_INSTALL_PREFIX and set CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT to ON
-
-  # In practice there are cases when CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT is
-  # set to ON and a custom CMAKE_INSTALL_PREFIX is set
-
-  # Do the original CMAKE_INSTALL_PREFIX detection
-  if(CMAKE_HOST_UNIX)
-    set(original_cmake_install_prefix "/usr/local")
-  else()
-    GetDefaultWindowsPrefixBase(CMAKE_GENERIC_PROGRAM_FILES)
-    set(original_cmake_install_prefix
-      "${CMAKE_GENERIC_PROGRAM_FILES}/${PROJECT_NAME}")
-    unset(CMAKE_GENERIC_PROGRAM_FILES)
-  endif()
-
-  # When the user code didn't modify the CMake set CMAKE_INSTALL_PREFIX
-  # then set the "/tmp" better value for CMAKE_INSTALL_PREFIX
-  if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND
-      CMAKE_INSTALL_PREFIX STREQUAL "${original_cmake_install_prefix}")
-    set_property(CACHE CMAKE_INSTALL_PREFIX PROPERTY VALUE "/tmp")
-  endif()
-endfunction()
-if (CMAKE_VERSION GREATER_EQUAL "3.19")
-  cmake_language(DEFER CALL qtc_modify_default_install_prefix)
-endif()
-
-# Store the C/C++ object output extension
-if (CMAKE_VERSION GREATER_EQUAL "3.19")
-  cmake_language(DEFER CALL set CMAKE_C_OUTPUT_EXTENSION "${CMAKE_C_OUTPUT_EXTENSION}" CACHE STRING "" FORCE)
-  cmake_language(DEFER CALL set CMAKE_CXX_OUTPUT_EXTENSION "${CMAKE_CXX_OUTPUT_EXTENSION}" CACHE STRING "" FORCE)
-endif()
-
-#
-# QML Debugging
-#
-if (QT_ENABLE_QML_DEBUG)
-  add_compile_definitions($<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:QT_QML_DEBUG>)
-endif()
-
-#
-# Package manager auto-setup
-#
-if (QT_CREATOR_ENABLE_PACKAGE_MANAGER_SETUP)
-  include(${CMAKE_CURRENT_LIST_DIR}/package-manager.cmake)
-endif()
-
-#
-# MaintenanceTool
-#
-if (QT_CREATOR_ENABLE_MAINTENANCE_TOOL_PROVIDER)
-  function(qtc_maintenance_provider_missing_variable_message variable)
-    message(STATUS "Qt Creator: ${variable} was not set. "
-                  "Qt MaintenanceTool cannot be used to install missing Qt modules that you specify in find_package(). "
-                  "To disable this message set QT_CREATOR_ENABLE_MAINTENANCE_TOOL_PROVIDER to OFF.")
-  endfunction()
-
-  if (NOT QT_QMAKE_EXECUTABLE)
-    qtc_maintenance_provider_missing_variable_message(QT_QMAKE_EXECUTABLE)
-    return()
-  endif()
-
-  if (CMAKE_VERSION GREATER_EQUAL "3.24")
-    list(APPEND CMAKE_PROJECT_TOP_LEVEL_INCLUDES ${CMAKE_CURRENT_LIST_DIR}/maintenance_tool_provider.cmake)
-  else()
-    message(WARNING "Qt Creator: CMake version 3.24 is needed for MaintenanceTool find_package() provider. "
-                    "To disable this warning set QT_CREATOR_ENABLE_MAINTENANCE_TOOL_PROVIDER to OFF.")
-  endif()
-endif()

app/CMakeFiles/app_autogen.dir/ParseCache.txt

@@ -1,2 +0,0 @@
-# Generated by CMake. Changes will be overwritten.
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/main.cpp

app/CMakeFiles/app_lib_autogen.dir/ParseCache.txt

@@ -1,15 +0,0 @@
-# Generated by CMake. Changes will be overwritten.
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/datamodel.h
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/datamodel.cpp
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/pid.cpp
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/pwm.cpp
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/filter.h
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/filter.cpp
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/main.cpp
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/pid.h
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/dataset.h
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/pwm.h
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/climate-algorithm.cpp
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/text-templates.h
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/dataset.cpp
-/home/k4/tmp/bbr-algo/BinderBeispielRegler/app/climate-algorithm.h

app/datamodel.cpp

@@ -27,3 +27,8 @@ DataModel::DataModel()
 
     Kennfeld_Ueberhitzung = Kennfeld_Ueberhitzung_Default;
 }
+
+void* DataModel::CurrentData(void)
+{
+    return nullptr;
+}

app/datamodel.h

@@ -11,7 +11,7 @@ Copyright:   Binder GmbH TUT
 Purpose:     Definitions, constants used by the datamodel are collected here
 Notes:       [Any relevant details, such as dependencies, usage examples, or known issues.]
 */
-
+#include <QList>
 #include "dataset.h"
 
 
@@ -69,6 +69,8 @@ private:
          {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20},
          {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20},
          {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}};
+
+     void* CurrentData(void);
 };
 
 

app/util.cpp

@@ -0,0 +1,6 @@
+
+
+namespace UTILITY_FUNCTIONS {
+
+
+}

app/util.h

@@ -0,0 +1,52 @@
+#ifndef UTIL_H
+#define UTIL_H
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+
+
+#define MAX std::max
+#define MIN std::min
+
+namespace UTILITY_FUNCTIONS {
+
+
+inline double limit(double x, double lo, double hi) {
+    return (x < lo) ? lo : (x > hi) ? hi : x;
+}
+
+inline double max3(double a, double b, double c) {
+    return std::max(a, std::max(b, c));
+}
+inline double min3(double a, double b, double c) {
+    return std::min(a, std::min(b, c));
+}
+
+
+inline bool is_valid(double x) { return std::isfinite(x); }
+
+// ST: REAL_TO_INT(x) i.d.R. trunc Richtung 0. Bei Siemens oft ROUND? Du nutzt
+// häufig +0.5.
+inline int real_to_int(double x) { return static_cast<int>(x); }
+
+// Platzhalter für GET_VALUE_* (kommt vermutlich aus Parameter-/Recipe-System)
+inline std::int32_t GET_VALUE_DINT(int /*a*/, int /*b*/, int /*c*/, int /*d*/) {
+    // TODO: an dein Parameter-System anbinden
+    return 0;
+}
+inline double GET_VALUE_REAL(int /*a*/, int /*b*/, int /*c*/, int /*d*/) {
+    // TODO: an dein Parameter-System anbinden
+    return 0.0;
+}
+
+class Util{
+public:
+
+};
+
+} // namespace UTILITY_FUNCTIONS
+
+
+
+#endif // UTIL_H

tests/CMakeLists.txt

@@ -1,6 +1,8 @@
 find_package(GTest REQUIRED)
 
-add_executable(tests filter-test.cpp)
+add_executable(tests filter-test.cpp
+                     util-test.cpp
+)
 target_link_libraries(tests  GTest::gtest_main app_lib)
 
 include(GoogleTest)

tests/cmake_test_discovery_59830ebc3a.json

@@ -1,5 +1,5 @@
 {
-  "tests": 3,
+  "tests": 11,
   "name": "AllTests",
   "testsuites": [
     {
@@ -22,6 +22,52 @@
           "line": 20
         }
       ]
+    },
+    {
+      "name": "UtilityTest_max3",
+      "tests": 8,
+      "testsuite": [
+        {
+          "name": "param_3_is_max",
+          "file": "\/home\/k4\/tmp\/bbr-algo\/BinderBeispielRegler\/tests\/util-test.cpp",
+          "line": 25
+        },
+        {
+          "name": "param_2_is_max",
+          "file": "\/home\/k4\/tmp\/bbr-algo\/BinderBeispielRegler\/tests\/util-test.cpp",
+          "line": 31
+        },
+        {
+          "name": "param_1_is_max",
+          "file": "\/home\/k4\/tmp\/bbr-algo\/BinderBeispielRegler\/tests\/util-test.cpp",
+          "line": 37
+        },
+        {
+          "name": "all_params_equal",
+          "file": "\/home\/k4\/tmp\/bbr-algo\/BinderBeispielRegler\/tests\/util-test.cpp",
+          "line": 43
+        },
+        {
+          "name": "all_params_zero",
+          "file": "\/home\/k4\/tmp\/bbr-algo\/BinderBeispielRegler\/tests\/util-test.cpp",
+          "line": 49
+        },
+        {
+          "name": "2_params_negative_one_is_zero",
+          "file": "\/home\/k4\/tmp\/bbr-algo\/BinderBeispielRegler\/tests\/util-test.cpp",
+          "line": 55
+        },
+        {
+          "name": "all_params_negative_one_is_max",
+          "file": "\/home\/k4\/tmp\/bbr-algo\/BinderBeispielRegler\/tests\/util-test.cpp",
+          "line": 61
+        },
+        {
+          "name": "all_params_type_double",
+          "file": "\/home\/k4\/tmp\/bbr-algo\/BinderBeispielRegler\/tests\/util-test.cpp",
+          "line": 67
+        }
+      ]
     }
   ]
 }

tests/tests[1]_tests.cmake

@@ -22,4 +22,68 @@ set_tests_properties([=[PT1FilterTest.FilterFactorEffect]=]
     WORKING_DIRECTORY [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests]==]
     SKIP_REGULAR_EXPRESSION [==[\[  SKIPPED \]]==]
 )
-set(  tests_TESTS PT1FilterTest.InitialOutputIsZero PT1FilterTest.StepResponse PT1FilterTest.FilterFactorEffect)
+add_test([=[UtilityTest_max3.param_3_is_max]=]  /home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/tests [==[--gtest_filter=UtilityTest_max3.param_3_is_max]==] --gtest_also_run_disabled_tests)
+set_tests_properties([=[UtilityTest_max3.param_3_is_max]=]
+  PROPERTIES
+    
+    DEF_SOURCE_LINE [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/util-test.cpp:25]==]
+    WORKING_DIRECTORY [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests]==]
+    SKIP_REGULAR_EXPRESSION [==[\[  SKIPPED \]]==]
+)
+add_test([=[UtilityTest_max3.param_2_is_max]=]  /home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/tests [==[--gtest_filter=UtilityTest_max3.param_2_is_max]==] --gtest_also_run_disabled_tests)
+set_tests_properties([=[UtilityTest_max3.param_2_is_max]=]
+  PROPERTIES
+    
+    DEF_SOURCE_LINE [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/util-test.cpp:31]==]
+    WORKING_DIRECTORY [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests]==]
+    SKIP_REGULAR_EXPRESSION [==[\[  SKIPPED \]]==]
+)
+add_test([=[UtilityTest_max3.param_1_is_max]=]  /home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/tests [==[--gtest_filter=UtilityTest_max3.param_1_is_max]==] --gtest_also_run_disabled_tests)
+set_tests_properties([=[UtilityTest_max3.param_1_is_max]=]
+  PROPERTIES
+    
+    DEF_SOURCE_LINE [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/util-test.cpp:37]==]
+    WORKING_DIRECTORY [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests]==]
+    SKIP_REGULAR_EXPRESSION [==[\[  SKIPPED \]]==]
+)
+add_test([=[UtilityTest_max3.all_params_equal]=]  /home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/tests [==[--gtest_filter=UtilityTest_max3.all_params_equal]==] --gtest_also_run_disabled_tests)
+set_tests_properties([=[UtilityTest_max3.all_params_equal]=]
+  PROPERTIES
+    
+    DEF_SOURCE_LINE [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/util-test.cpp:43]==]
+    WORKING_DIRECTORY [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests]==]
+    SKIP_REGULAR_EXPRESSION [==[\[  SKIPPED \]]==]
+)
+add_test([=[UtilityTest_max3.all_params_zero]=]  /home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/tests [==[--gtest_filter=UtilityTest_max3.all_params_zero]==] --gtest_also_run_disabled_tests)
+set_tests_properties([=[UtilityTest_max3.all_params_zero]=]
+  PROPERTIES
+    
+    DEF_SOURCE_LINE [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/util-test.cpp:49]==]
+    WORKING_DIRECTORY [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests]==]
+    SKIP_REGULAR_EXPRESSION [==[\[  SKIPPED \]]==]
+)
+add_test([=[UtilityTest_max3.2_params_negative_one_is_zero]=]  /home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/tests [==[--gtest_filter=UtilityTest_max3.2_params_negative_one_is_zero]==] --gtest_also_run_disabled_tests)
+set_tests_properties([=[UtilityTest_max3.2_params_negative_one_is_zero]=]
+  PROPERTIES
+    
+    DEF_SOURCE_LINE [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/util-test.cpp:55]==]
+    WORKING_DIRECTORY [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests]==]
+    SKIP_REGULAR_EXPRESSION [==[\[  SKIPPED \]]==]
+)
+add_test([=[UtilityTest_max3.all_params_negative_one_is_max]=]  /home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/tests [==[--gtest_filter=UtilityTest_max3.all_params_negative_one_is_max]==] --gtest_also_run_disabled_tests)
+set_tests_properties([=[UtilityTest_max3.all_params_negative_one_is_max]=]
+  PROPERTIES
+    
+    DEF_SOURCE_LINE [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/util-test.cpp:61]==]
+    WORKING_DIRECTORY [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests]==]
+    SKIP_REGULAR_EXPRESSION [==[\[  SKIPPED \]]==]
+)
+add_test([=[UtilityTest_max3.all_params_type_double]=]  /home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/tests [==[--gtest_filter=UtilityTest_max3.all_params_type_double]==] --gtest_also_run_disabled_tests)
+set_tests_properties([=[UtilityTest_max3.all_params_type_double]=]
+  PROPERTIES
+    
+    DEF_SOURCE_LINE [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests/util-test.cpp:67]==]
+    WORKING_DIRECTORY [==[/home/k4/tmp/bbr-algo/BinderBeispielRegler/tests]==]
+    SKIP_REGULAR_EXPRESSION [==[\[  SKIPPED \]]==]
+)
+set(  tests_TESTS PT1FilterTest.InitialOutputIsZero PT1FilterTest.StepResponse PT1FilterTest.FilterFactorEffect UtilityTest_max3.param_3_is_max UtilityTest_max3.param_2_is_max UtilityTest_max3.param_1_is_max UtilityTest_max3.all_params_equal UtilityTest_max3.all_params_zero UtilityTest_max3.2_params_negative_one_is_zero UtilityTest_max3.all_params_negative_one_is_max UtilityTest_max3.all_params_type_double)

tests/util-test.cpp

@@ -0,0 +1,74 @@
+/*
+File:        util-test.cpp
+Description: This is a C++ source file containing  unit tests for util.cpp.
+Rev:         0.1
+Created:     01.04.26
+Author:      Uwe Jakobeit
+Copyright:   Binder GmbH
+Purpose:     Testing utility functions
+Notes:       [Any relevant details, such as dependencies, usage examples, or known issues.]
+*/
+
+
+#include <gtest/gtest.h>
+
+#include <limits>
+
+#include "util.h"
+
+using namespace UTILITY_FUNCTIONS;
+
+//----------- Test of utility function 'max3' ---------
+// Magic numbers for simplicity ( exceptionally allowed here )
+
+// test if param 3 is max value
+TEST(UtilityTest_max3, param_3_is_max) {
+    double max = max3(1.0f, 2.0f, 3.0f);
+    EXPECT_DOUBLE_EQ(max, 3.0f);
+}
+
+// test if param 2 is max value
+TEST(UtilityTest_max3, param_2_is_max) {
+    double max = max3(1.0f, 3.0f, 2.0f);
+    EXPECT_DOUBLE_EQ(max, 3.0f);
+}
+
+// test if param 1 is max value
+TEST(UtilityTest_max3, param_1_is_max) {
+    double max = max3( 3.0f, 1.0f, 2.0f);
+    EXPECT_DOUBLE_EQ(max, 3.0f);
+}
+
+// test all params are max value
+TEST(UtilityTest_max3, all_params_equal) {
+    double max = max3( 3.0f, 3.0f, 3.0f);
+    EXPECT_DOUBLE_EQ(max, 3.0f);
+}
+
+// test all params are zero
+TEST(UtilityTest_max3, all_params_zero) {
+    double max = max3( 0.0f, 0.0f, 0.0f);
+    EXPECT_DOUBLE_EQ(max, 0.0f);
+}
+
+// test 2 params negatve, one is zero
+TEST(UtilityTest_max3, 2_params_negative_one_is_zero) {
+    double max = max3( -2.0f, -1.0f, 0.0f);
+    EXPECT_DOUBLE_EQ(max, 0.0f);
+}
+
+// test 2 params negatve, one is zero
+TEST(UtilityTest_max3, all_params_negative_one_is_max) {
+    double max = max3( -2.0f, -1.0f, -3.0f);
+    EXPECT_DOUBLE_EQ(max, -1.0f);
+}
+
+
+TEST(UtilityTest_max3, all_params_type_double) {
+    double max = max3( std::numeric_limits<double>::max(), 0.0f, 0.0f);
+
+    EXPECT_DOUBLE_EQ(max, std::numeric_limits<double>::max());
+}
+
+
+