This is an automated email from the ASF dual-hosted git repository.
isapego pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/ignite-3.git
The following commit(s) were added to refs/heads/main by this push:
new b3dad674a1 IGNITE-22384 Replace Conan package manager with direct
dependency management using cmake (#3851)
b3dad674a1 is described below
commit b3dad674a1afa69574153f829ac1fbbbd03e67db
Author: Dmitriy Zabotlin <[email protected]>
AuthorDate: Fri Jun 7 19:27:08 2024 +0300
IGNITE-22384 Replace Conan package manager with direct dependency
management using cmake (#3851)
Co-authored-by: dzabotlin <[email protected]>
---
modules/platforms/cpp/CMakeLists.txt | 48 +-
modules/platforms/cpp/DEVNOTES.md | 56 +-
modules/platforms/cpp/cmake/conan.cmake | 1026 --------------------
modules/platforms/cpp/cmake/dependencies.cmake | 50 +
modules/platforms/cpp/cmake/ignite_test.cmake | 31 +-
modules/platforms/cpp/ignite/client/CMakeLists.txt | 2 +-
modules/platforms/cpp/ignite/common/CMakeLists.txt | 12 +-
modules/platforms/cpp/ignite/odbc/CMakeLists.txt | 8 +-
.../platforms/cpp/ignite/protocol/CMakeLists.txt | 4 +-
modules/platforms/cpp/ignite/tuple/CMakeLists.txt | 2 +-
.../platforms/cpp/tests/client-test/CMakeLists.txt | 6 +-
.../platforms/cpp/tests/odbc-test/CMakeLists.txt | 8 +-
12 files changed, 91 insertions(+), 1162 deletions(-)
diff --git a/modules/platforms/cpp/CMakeLists.txt
b/modules/platforms/cpp/CMakeLists.txt
index fac1523dcf..00515b275d 100644
--- a/modules/platforms/cpp/CMakeLists.txt
+++ b/modules/platforms/cpp/CMakeLists.txt
@@ -23,7 +23,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_PROJECT_VERSION ${PROJECT_VERSION})
-option(ENABLE_CONAN "Use Conan package manager to get dependencies" ON)
+option(USE_LOCAL_DEPS "Use local dependencies." OFF)
option(ENABLE_CLIENT "Build Ignite.C++ Client module" ON)
option(ENABLE_ODBC "Build Ignite ODBC driver module" OFF)
option(ENABLE_TESTS "Build Ignite.C++ tests" OFF)
@@ -38,50 +38,7 @@ list(APPEND CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR})
get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-set(conan_packages
- msgpack-c/4.0.0
-)
-
-if (${ENABLE_TESTS})
- list(APPEND conan_packages
- gtest/1.12.1
- )
-endif()
-
-# Install required libraries.
-if (${ENABLE_CONAN})
- include(conan)
-
- if (is_multi_config)
- # These settings are for multi-config generators like Visual Studio.
- message(STATUS "Using a multi-config generator")
-
- conan_cmake_configure(REQUIRES ${conan_packages}
- GENERATORS cmake_find_package_multi)
-
- foreach(TYPE ${CMAKE_CONFIGURATION_TYPES})
- conan_cmake_autodetect(conan_settings BUILD_TYPE ${TYPE})
-
- conan_cmake_install(PATH_OR_REFERENCE .
- BUILD missing
- REMOTE conancenter
- SETTINGS ${conan_settings})
- endforeach()
- else()
- # These settings are for single-config generators like makefiles,
ninja.
- message(STATUS "Using a single-config generator")
-
- conan_cmake_configure(REQUIRES ${conan_packages}
- GENERATORS cmake_find_package)
-
- conan_cmake_autodetect(conan_settings)
-
- conan_cmake_install(PATH_OR_REFERENCE .
- BUILD missing
- REMOTE conancenter
- SETTINGS ${conan_settings})
- endif()
-endif()
+include(dependencies)
# Configure build paths.
if (is_multi_config)
@@ -146,7 +103,6 @@ endif()
# Setup gtest for unit & integration tests.
if (${ENABLE_TESTS})
- find_package(GTest REQUIRED)
include(GoogleTest)
enable_testing()
endif()
diff --git a/modules/platforms/cpp/DEVNOTES.md
b/modules/platforms/cpp/DEVNOTES.md
index 060b721762..6c5e4df028 100644
--- a/modules/platforms/cpp/DEVNOTES.md
+++ b/modules/platforms/cpp/DEVNOTES.md
@@ -2,59 +2,20 @@
### Prerequisites
-
* C++ compiler supporting C++ 17
* One of the build systems: make, ninja, MS Visual Studio, etc.
-* Conan C/C++ package manager 1.X (optional)
* CMake 3.10+
To build the ODBC driver, it is required to have an ODBC driver manager with
headers on your system. On Windows, it
comes with your OS. On Unix-like systems, you may need to install one; for
example, unixODBC.
-### Installing Conan Package Manager
-
-The Conan package manager can be obtained from [its website](https://conan.io).
-
-Currently, we support Conan versions 1.X. The 2.0+ versions are **not**
supported yet.
-
-One way to install Conan is as follows (need Python on your system):
-
-```shell
-pip install conan==1.59.0
-```
-
-Before use, you might need to configure the default Conan profile:
-
-```
-conan profile new --detect default
-conan profile update settings.compiler.libcxx=libstdc++11 default
-```
-
-### Avoiding Conan Package Manager
-
-It is possible to build the project without Conan if all the dependencies are
installed on the system manually.
-The project dependencies include:
-
-* msgpack-c 4.0.0
-* gtest 1.12.1
-
-When the project is configured with `-DENABLE_CONAN=OFF`, the Conan machinery
is turned off, and the dependencies are resolved using the standard means of
the build platform. For example, the project can be configured like this:
-
-```shell
-...
-cmake .. -DENABLE_CONAN=OFF -DCMAKE_BUILD_TYPE=Release
-...
-```
-
-Conan is enabled by default. All the build examples below use Conan.
-
### CMake Options and Typical Build Configurations
The CMake project supports multiple configuration options that can be used to
define exactly what and how should be
built. You can check the list of available CMake options with the `cmake -LAH`
command.
Following are the project-specific options:
-* ENABLE_CONAN={ON|OFF} - ON by default. The effect of this option is
described in the section above.
+* USE_LOCAL_DEPS={ON|OFF} - OFF by default. Indicates that build system will
use locally installed dependencies.
* ENABLE_CLIENT={ON|OFF} - ON by default. Indicates whether the C++ client
should be built.
* ENABLE_ODBC={ON|OFF} - OFF by default. Indicates whether the ODBC driver
should be built.
* ENABLE_TESTS={ON|OFF} - OFF by default. Indicates whether the tests for the
selected components should be built.
@@ -62,6 +23,13 @@ Following are the project-specific options:
idea to enable this option if you are planning on submitting a PR. If you just
want to build a project, keep this
option disabled.
+USE_LOCAL_DEPS option set to OFF implies that dependencies will be downloaded,
so you will need an internet connection.
+If you want to build project with your local dependencies you can set option
USE_LOCAL_DEPS to ON.
+In this case you have to install:
+ * msgpack-c >= 4.0.0 development package (for Ubuntu: libmsgpack-dev)
+ * Google test library >= 1.12.0 (for Ubuntu: libgtest-dev) if you want to
build tests (ENABLE_TESTS = ON)
+ * Google mock library >= 1.12.0 (for Ubuntu: libgmock-dev) if you want to
build tests (ENABLE_TESTS = ON)
+
You should also specify the general (build type) CMake options. There are two
types of build available - `Release` and `Debug`. The choice depends on how are
you going to use the resulting artifacts. If you are going to use them in
production, use the `Release` build type. If you are planning to just submit a
patch for the project, use `Debug`.
You must ALWAYS specify a build type.
@@ -100,14 +68,6 @@ cmake .. -DCMAKE_CONFIGURATION_TYPES=Release
In the following sections, you can find more detailed line-by-line
instructions and configurations for the different platforms and use cases.
-### Linux and macOS Builds
-
-When using Conan on macOS, it is typically required to specify the C++
standard library from the LLVM project:
-
-```
-conan profile update settings.compiler.libcxx=libc++11 default
-```
-
#### Building in the Debug Mode with Tests and ODBC
In this dir:
diff --git a/modules/platforms/cpp/cmake/conan.cmake
b/modules/platforms/cpp/cmake/conan.cmake
deleted file mode 100644
index 4f5f67e74c..0000000000
--- a/modules/platforms/cpp/cmake/conan.cmake
+++ /dev/null
@@ -1,1026 +0,0 @@
-# The MIT License (MIT)
-
-# Copyright (c) 2018 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.
-
-
-
-# This file comes from: https://github.com/conan-io/cmake-conan. Please refer
-# to this repository for issues and documentation.
-
-# Its purpose is to wrap and launch Conan C/C++ Package Manager when cmake is
called.
-# It will take CMake current settings (os, compiler, compiler version,
architecture)
-# and translate them to conan settings for installing and retrieving
dependencies.
-
-# It is intended to facilitate developers building projects that have conan
dependencies,
-# but it is only necessary on the end-user side. It is not necessary to create
conan
-# packages, in fact it shouldn't be use for that. Check the project
documentation.
-
-# version: 0.18.1
-
-include(CMakeParseArguments)
-
-function(_get_msvc_ide_version result)
- set(${result} "" PARENT_SCOPE)
- if(NOT MSVC_VERSION VERSION_LESS 1400 AND MSVC_VERSION VERSION_LESS 1500)
- set(${result} 8 PARENT_SCOPE)
- elseif(NOT MSVC_VERSION VERSION_LESS 1500 AND MSVC_VERSION VERSION_LESS
1600)
- set(${result} 9 PARENT_SCOPE)
- elseif(NOT MSVC_VERSION VERSION_LESS 1600 AND MSVC_VERSION VERSION_LESS
1700)
- set(${result} 10 PARENT_SCOPE)
- elseif(NOT MSVC_VERSION VERSION_LESS 1700 AND MSVC_VERSION VERSION_LESS
1800)
- set(${result} 11 PARENT_SCOPE)
- elseif(NOT MSVC_VERSION VERSION_LESS 1800 AND MSVC_VERSION VERSION_LESS
1900)
- set(${result} 12 PARENT_SCOPE)
- elseif(NOT MSVC_VERSION VERSION_LESS 1900 AND MSVC_VERSION VERSION_LESS
1910)
- set(${result} 14 PARENT_SCOPE)
- elseif(NOT MSVC_VERSION VERSION_LESS 1910 AND MSVC_VERSION VERSION_LESS
1920)
- set(${result} 15 PARENT_SCOPE)
- elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS
1930)
- set(${result} 16 PARENT_SCOPE)
- elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS
1940)
- set(${result} 17 PARENT_SCOPE)
- else()
- message(FATAL_ERROR "Conan: Unknown MSVC compiler version
[${MSVC_VERSION}]")
- endif()
-endfunction()
-
-macro(_conan_detect_build_type)
- conan_parse_arguments(${ARGV})
-
- if(ARGUMENTS_BUILD_TYPE)
- set(_CONAN_SETTING_BUILD_TYPE ${ARGUMENTS_BUILD_TYPE})
- elseif(CMAKE_BUILD_TYPE)
- set(_CONAN_SETTING_BUILD_TYPE ${CMAKE_BUILD_TYPE})
- else()
- message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE
(-DCMAKE_BUILD_TYPE=Release)")
- endif()
-
- string(TOUPPER ${_CONAN_SETTING_BUILD_TYPE}
_CONAN_SETTING_BUILD_TYPE_UPPER)
- if (_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "DEBUG")
- set(_CONAN_SETTING_BUILD_TYPE "Debug")
- elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELEASE")
- set(_CONAN_SETTING_BUILD_TYPE "Release")
- elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELWITHDEBINFO")
- set(_CONAN_SETTING_BUILD_TYPE "RelWithDebInfo")
- elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "MINSIZEREL")
- set(_CONAN_SETTING_BUILD_TYPE "MinSizeRel")
- endif()
-endmacro()
-
-macro(_conan_check_system_name)
- #handle -s os setting
- if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic")
- #use default conan os setting if CMAKE_SYSTEM_NAME is not defined
- set(CONAN_SYSTEM_NAME ${CMAKE_SYSTEM_NAME})
- if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
- set(CONAN_SYSTEM_NAME Macos)
- endif()
- if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX")
- set(CONAN_SYSTEM_NAME Neutrino)
- endif()
- set(CONAN_SUPPORTED_PLATFORMS Windows Linux Macos Android iOS FreeBSD
WindowsStore WindowsCE watchOS tvOS FreeBSD SunOS AIX Arduino Emscripten
Neutrino)
- list (FIND CONAN_SUPPORTED_PLATFORMS "${CONAN_SYSTEM_NAME}" _index)
- if (${_index} GREATER -1)
- #check if the cmake system is a conan supported one
- set(_CONAN_SETTING_OS ${CONAN_SYSTEM_NAME})
- else()
- message(FATAL_ERROR "cmake system ${CONAN_SYSTEM_NAME} is not
supported by conan. Use one of ${CONAN_SUPPORTED_PLATFORMS}")
- endif()
- endif()
-endmacro()
-
-macro(_conan_check_language)
- get_property(_languages GLOBAL PROPERTY ENABLED_LANGUAGES)
- if (";${_languages};" MATCHES ";CXX;")
- set(LANGUAGE CXX)
- set(USING_CXX 1)
- elseif (";${_languages};" MATCHES ";C;")
- set(LANGUAGE C)
- set(USING_CXX 0)
- else ()
- message(FATAL_ERROR "Conan: Neither C or C++ was detected as a
language for the project. Unabled to detect compiler version.")
- endif()
-endmacro()
-
-macro(_conan_detect_compiler)
-
- conan_parse_arguments(${ARGV})
-
- if(ARGUMENTS_ARCH)
- set(_CONAN_SETTING_ARCH ${ARGUMENTS_ARCH})
- endif()
-
- if(USING_CXX)
- set(_CONAN_SETTING_COMPILER_CPPSTD ${CMAKE_CXX_STANDARD})
- endif()
-
- if (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL GNU)
- # using GCC
- # TODO: Handle other params
- string(REPLACE "." ";" VERSION_LIST
${CMAKE_${LANGUAGE}_COMPILER_VERSION})
- list(GET VERSION_LIST 0 MAJOR)
- list(GET VERSION_LIST 1 MINOR)
- set(COMPILER_VERSION ${MAJOR}.${MINOR})
- if(${MAJOR} GREATER 4)
- set(COMPILER_VERSION ${MAJOR})
- endif()
- set(_CONAN_SETTING_COMPILER gcc)
- set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION})
- if (USING_CXX)
- conan_cmake_detect_unix_libcxx(_LIBCXX)
- set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
- endif ()
- elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Intel)
- string(REPLACE "." ";" VERSION_LIST
${CMAKE_${LANGUAGE}_COMPILER_VERSION})
- list(GET VERSION_LIST 0 MAJOR)
- list(GET VERSION_LIST 1 MINOR)
- set(COMPILER_VERSION ${MAJOR}.${MINOR})
- set(_CONAN_SETTING_COMPILER intel)
- set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION})
- if (USING_CXX)
- conan_cmake_detect_unix_libcxx(_LIBCXX)
- set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
- endif ()
- elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL AppleClang)
- # using AppleClang
- string(REPLACE "." ";" VERSION_LIST
${CMAKE_${LANGUAGE}_COMPILER_VERSION})
- list(GET VERSION_LIST 0 MAJOR)
- list(GET VERSION_LIST 1 MINOR)
- set(_CONAN_SETTING_COMPILER apple-clang)
- set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR})
- if (USING_CXX)
- conan_cmake_detect_unix_libcxx(_LIBCXX)
- set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
- endif ()
- elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang
- AND NOT "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}"
STREQUAL "MSVC"
- AND NOT "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC")
-
- string(REPLACE "." ";" VERSION_LIST
${CMAKE_${LANGUAGE}_COMPILER_VERSION})
- list(GET VERSION_LIST 0 MAJOR)
- list(GET VERSION_LIST 1 MINOR)
- set(_CONAN_SETTING_COMPILER clang)
- set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR})
- if(APPLE)
- cmake_policy(GET CMP0025 APPLE_CLANG_POLICY)
- if(NOT APPLE_CLANG_POLICY STREQUAL NEW)
- message(STATUS "Conan: APPLE and Clang detected. Assuming
apple-clang compiler. Set CMP0025 to avoid it")
- set(_CONAN_SETTING_COMPILER apple-clang)
- endif()
- endif()
- if(${_CONAN_SETTING_COMPILER} STREQUAL clang AND ${MAJOR} GREATER 7)
- set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR})
- endif()
- if (USING_CXX)
- conan_cmake_detect_unix_libcxx(_LIBCXX)
- set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
- endif ()
- elseif(${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL MSVC
- OR (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang
- AND "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}"
STREQUAL "MSVC"
- AND "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC"))
-
- set(_VISUAL "Visual Studio")
- _get_msvc_ide_version(_VISUAL_VERSION)
- if("${_VISUAL_VERSION}" STREQUAL "")
- message(FATAL_ERROR "Conan: Visual Studio not recognized")
- else()
- set(_CONAN_SETTING_COMPILER ${_VISUAL})
- set(_CONAN_SETTING_COMPILER_VERSION ${_VISUAL_VERSION})
- endif()
-
- if(NOT _CONAN_SETTING_ARCH)
- if (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "64")
- set(_CONAN_SETTING_ARCH x86_64)
- elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "^ARM")
- message(STATUS "Conan: Using default ARM architecture from
MSVC")
- set(_CONAN_SETTING_ARCH armv6)
- elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "86")
- set(_CONAN_SETTING_ARCH x86)
- else ()
- message(FATAL_ERROR "Conan: Unknown MSVC architecture
[${MSVC_${LANGUAGE}_ARCHITECTURE_ID}]")
- endif()
- endif()
-
- conan_cmake_detect_vs_runtime(_vs_runtime ${ARGV})
- message(STATUS "Conan: Detected VS runtime: ${_vs_runtime}")
- set(_CONAN_SETTING_COMPILER_RUNTIME ${_vs_runtime})
-
- if (CMAKE_GENERATOR_TOOLSET)
- set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET})
- elseif(CMAKE_VS_PLATFORM_TOOLSET AND (CMAKE_GENERATOR STREQUAL
"Ninja"))
- set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET})
- endif()
- else()
- message(FATAL_ERROR "Conan: compiler setup not recognized")
- endif()
-
-endmacro()
-
-function(conan_cmake_settings result)
- #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER})
- #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER_ID})
- #message(STATUS "VERSION " ${CMAKE_CXX_COMPILER_VERSION})
- #message(STATUS "FLAGS " ${CMAKE_LANG_FLAGS})
- #message(STATUS "LIB ARCH " ${CMAKE_CXX_LIBRARY_ARCHITECTURE})
- #message(STATUS "BUILD TYPE " ${CMAKE_BUILD_TYPE})
- #message(STATUS "GENERATOR " ${CMAKE_GENERATOR})
- #message(STATUS "GENERATOR WIN64 " ${CMAKE_CL_64})
-
- message(STATUS "Conan: Automatic detection of conan settings from cmake")
-
- conan_parse_arguments(${ARGV})
-
- _conan_detect_build_type(${ARGV})
-
- _conan_check_system_name()
-
- _conan_check_language()
-
- _conan_detect_compiler(${ARGV})
-
- # If profile is defined it is used
- if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ARGUMENTS_DEBUG_PROFILE)
- set(_APPLIED_PROFILES ${ARGUMENTS_DEBUG_PROFILE})
- elseif(CMAKE_BUILD_TYPE STREQUAL "Release" AND ARGUMENTS_RELEASE_PROFILE)
- set(_APPLIED_PROFILES ${ARGUMENTS_RELEASE_PROFILE})
- elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" AND
ARGUMENTS_RELWITHDEBINFO_PROFILE)
- set(_APPLIED_PROFILES ${ARGUMENTS_RELWITHDEBINFO_PROFILE})
- elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" AND
ARGUMENTS_MINSIZEREL_PROFILE)
- set(_APPLIED_PROFILES ${ARGUMENTS_MINSIZEREL_PROFILE})
- elseif(ARGUMENTS_PROFILE)
- set(_APPLIED_PROFILES ${ARGUMENTS_PROFILE})
- endif()
-
- foreach(ARG ${_APPLIED_PROFILES})
- set(_SETTINGS ${_SETTINGS} -pr=${ARG})
- endforeach()
- foreach(ARG ${ARGUMENTS_PROFILE_BUILD})
- conan_check(VERSION 1.24.0 REQUIRED DETECT_QUIET)
- set(_SETTINGS ${_SETTINGS} -pr:b=${ARG})
- endforeach()
-
- if(NOT _SETTINGS OR ARGUMENTS_PROFILE_AUTO STREQUAL "ALL")
- set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version
- compiler.runtime compiler.libcxx
compiler.toolset)
- endif()
-
- # remove any manually specified settings from the autodetected settings
- foreach(ARG ${ARGUMENTS_SETTINGS})
- string(REGEX MATCH "[^=]*" MANUAL_SETTING "${ARG}")
- message(STATUS "Conan: ${MANUAL_SETTING} was added as an argument. Not
using the autodetected one.")
- list(REMOVE_ITEM ARGUMENTS_PROFILE_AUTO "${MANUAL_SETTING}")
- endforeach()
-
- # Automatic from CMake
- foreach(ARG ${ARGUMENTS_PROFILE_AUTO})
- string(TOUPPER ${ARG} _arg_name)
- string(REPLACE "." "_" _arg_name ${_arg_name})
- if(_CONAN_SETTING_${_arg_name})
- set(_SETTINGS ${_SETTINGS} -s
${ARG}=${_CONAN_SETTING_${_arg_name}})
- endif()
- endforeach()
-
- foreach(ARG ${ARGUMENTS_SETTINGS})
- set(_SETTINGS ${_SETTINGS} -s ${ARG})
- endforeach()
-
- message(STATUS "Conan: Settings= ${_SETTINGS}")
-
- set(${result} ${_SETTINGS} PARENT_SCOPE)
-endfunction()
-
-
-function(conan_cmake_detect_unix_libcxx result)
- # Take into account any -stdlib in compile options
- get_directory_property(compile_options DIRECTORY
${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS)
- string(GENEX_STRIP "${compile_options}" compile_options)
-
- # Take into account any _GLIBCXX_USE_CXX11_ABI in compile definitions
- get_directory_property(defines DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMPILE_DEFINITIONS)
- string(GENEX_STRIP "${defines}" defines)
-
- foreach(define ${defines})
- if(define MATCHES "_GLIBCXX_USE_CXX11_ABI")
- if(define MATCHES "^-D")
- set(compile_options ${compile_options} "${define}")
- else()
- set(compile_options ${compile_options} "-D${define}")
- endif()
- endif()
- endforeach()
-
- # add additional compiler options ala
cmRulePlaceholderExpander::ExpandRuleVariable
- set(EXPAND_CXX_COMPILER ${CMAKE_CXX_COMPILER})
- if(CMAKE_CXX_COMPILER_ARG1)
- # CMake splits CXX="foo bar baz" into CMAKE_CXX_COMPILER="foo",
CMAKE_CXX_COMPILER_ARG1="bar baz"
- # without this, ccache, winegcc, or other wrappers might lose all
their arguments
- separate_arguments(SPLIT_CXX_COMPILER_ARG1 NATIVE_COMMAND
${CMAKE_CXX_COMPILER_ARG1})
- list(APPEND EXPAND_CXX_COMPILER ${SPLIT_CXX_COMPILER_ARG1})
- endif()
-
- if(CMAKE_CXX_COMPILE_OPTIONS_TARGET AND CMAKE_CXX_COMPILER_TARGET)
- # without --target= we may be calling the wrong underlying GCC
- list(APPEND EXPAND_CXX_COMPILER
"${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}")
- endif()
-
- if(CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN AND
CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN)
- list(APPEND EXPAND_CXX_COMPILER
"${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
- endif()
-
- if(CMAKE_CXX_COMPILE_OPTIONS_SYSROOT)
- # without --sysroot= we may find the wrong #include <string>
- if(CMAKE_SYSROOT_COMPILE)
- list(APPEND EXPAND_CXX_COMPILER
"${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT_COMPILE}")
- elseif(CMAKE_SYSROOT)
- list(APPEND EXPAND_CXX_COMPILER
"${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}")
- endif()
- endif()
-
- separate_arguments(SPLIT_CXX_FLAGS NATIVE_COMMAND ${CMAKE_CXX_FLAGS})
-
- if(CMAKE_OSX_SYSROOT)
- set(xcode_sysroot_option "--sysroot=${CMAKE_OSX_SYSROOT}")
- endif()
-
- execute_process(
- COMMAND ${CMAKE_COMMAND} -E echo "#include <string>"
- COMMAND ${EXPAND_CXX_COMPILER} ${SPLIT_CXX_FLAGS} -x c++
${xcode_sysroot_option} ${compile_options} -E -dM -
- OUTPUT_VARIABLE string_defines
- )
-
- if(string_defines MATCHES "#define __GLIBCXX__")
- # Allow -D_GLIBCXX_USE_CXX11_ABI=ON/OFF as argument to cmake
- if(DEFINED _GLIBCXX_USE_CXX11_ABI)
- if(_GLIBCXX_USE_CXX11_ABI)
- set(${result} libstdc++11 PARENT_SCOPE)
- return()
- else()
- set(${result} libstdc++ PARENT_SCOPE)
- return()
- endif()
- endif()
-
- if(string_defines MATCHES "#define _GLIBCXX_USE_CXX11_ABI 1\n")
- set(${result} libstdc++11 PARENT_SCOPE)
- else()
- # Either the compiler is missing the define because it is old, and
so
- # it can't use the new abi, or the compiler was configured to use
the
- # old abi by the user or distro (e.g. devtoolset on RHEL/CentOS)
- set(${result} libstdc++ PARENT_SCOPE)
- endif()
- else()
- set(${result} libc++ PARENT_SCOPE)
- endif()
-endfunction()
-
-function(conan_cmake_detect_vs_runtime result)
-
- conan_parse_arguments(${ARGV})
- if(ARGUMENTS_BUILD_TYPE)
- set(build_type "${ARGUMENTS_BUILD_TYPE}")
- elseif(CMAKE_BUILD_TYPE)
- set(build_type "${CMAKE_BUILD_TYPE}")
- else()
- message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE
(-DCMAKE_BUILD_TYPE=Release)")
- endif()
-
- if(build_type)
- string(TOUPPER "${build_type}" build_type)
- endif()
- set(variables CMAKE_CXX_FLAGS_${build_type} CMAKE_C_FLAGS_${build_type}
CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
- foreach(variable ${variables})
- if(NOT "${${variable}}" STREQUAL "")
- string(REPLACE " " ";" flags "${${variable}}")
- foreach (flag ${flags})
- if("${flag}" STREQUAL "/MD" OR "${flag}" STREQUAL "/MDd" OR
"${flag}" STREQUAL "/MT" OR "${flag}" STREQUAL "/MTd")
- string(SUBSTRING "${flag}" 1 -1 runtime)
- set(${result} "${runtime}" PARENT_SCOPE)
- return()
- endif()
- endforeach()
- endif()
- endforeach()
- if("${build_type}" STREQUAL "DEBUG")
- set(${result} "MDd" PARENT_SCOPE)
- else()
- set(${result} "MD" PARENT_SCOPE)
- endif()
-endfunction()
-
-function(_collect_settings result)
- set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version
- compiler.runtime compiler.libcxx compiler.toolset
- compiler.cppstd)
- foreach(ARG ${ARGUMENTS_PROFILE_AUTO})
- string(TOUPPER ${ARG} _arg_name)
- string(REPLACE "." "_" _arg_name ${_arg_name})
- if(_CONAN_SETTING_${_arg_name})
- set(detected_setings ${detected_setings}
${ARG}=${_CONAN_SETTING_${_arg_name}})
- endif()
- endforeach()
- set(${result} ${detected_setings} PARENT_SCOPE)
-endfunction()
-
-function(conan_cmake_autodetect detected_settings)
- _conan_detect_build_type(${ARGV})
- _conan_check_system_name()
- _conan_check_language()
- _conan_detect_compiler(${ARGV})
- _collect_settings(collected_settings)
- set(${detected_settings} ${collected_settings} PARENT_SCOPE)
-endfunction()
-
-macro(conan_parse_arguments)
- set(options BASIC_SETUP CMAKE_TARGETS UPDATE KEEP_RPATHS NO_LOAD
NO_OUTPUT_DIRS OUTPUT_QUIET NO_IMPORTS SKIP_STD)
- set(oneValueArgs CONANFILE ARCH BUILD_TYPE INSTALL_FOLDER OUTPUT_FOLDER
CONAN_COMMAND)
- set(multiValueArgs DEBUG_PROFILE RELEASE_PROFILE RELWITHDEBINFO_PROFILE
MINSIZEREL_PROFILE
- PROFILE REQUIRES OPTIONS IMPORTS SETTINGS BUILD ENV
GENERATORS PROFILE_AUTO
- INSTALL_ARGS CONFIGURATION_TYPES PROFILE_BUILD
BUILD_REQUIRES)
- cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN})
-endmacro()
-
-function(old_conan_cmake_install)
- # Calls "conan install"
- # Argument BUILD is equivalant to --build={missing, PkgName,...} or
- # --build when argument is 'BUILD all' (which builds all packages from
source)
- # Argument CONAN_COMMAND, to specify the conan path, e.g. in case of
running from source
- # cmake does not identify conan as command, even if it is +x and it is in
the path
- conan_parse_arguments(${ARGV})
-
- if(CONAN_CMAKE_MULTI)
- set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake_multi)
- else()
- set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake)
- endif()
-
- set(CONAN_BUILD_POLICY "")
- foreach(ARG ${ARGUMENTS_BUILD})
- if(${ARG} STREQUAL "all")
- set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build)
- break()
- else()
- set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build=${ARG})
- endif()
- endforeach()
- if(ARGUMENTS_CONAN_COMMAND)
- set(CONAN_CMD ${ARGUMENTS_CONAN_COMMAND})
- else()
- conan_check(REQUIRED)
- endif()
- set(CONAN_OPTIONS "")
- if(ARGUMENTS_CONANFILE)
- if(IS_ABSOLUTE ${ARGUMENTS_CONANFILE})
- set(CONANFILE ${ARGUMENTS_CONANFILE})
- else()
- set(CONANFILE ${CMAKE_CURRENT_SOURCE_DIR}/${ARGUMENTS_CONANFILE})
- endif()
- else()
- set(CONANFILE ".")
- endif()
- foreach(ARG ${ARGUMENTS_OPTIONS})
- set(CONAN_OPTIONS ${CONAN_OPTIONS} -o=${ARG})
- endforeach()
- if(ARGUMENTS_UPDATE)
- set(CONAN_INSTALL_UPDATE --update)
- endif()
- if(ARGUMENTS_NO_IMPORTS)
- set(CONAN_INSTALL_NO_IMPORTS --no-imports)
- endif()
- set(CONAN_INSTALL_FOLDER "")
- if(ARGUMENTS_INSTALL_FOLDER)
- set(CONAN_INSTALL_FOLDER -if=${ARGUMENTS_INSTALL_FOLDER})
- endif()
- set(CONAN_OUTPUT_FOLDER "")
- if(ARGUMENTS_OUTPUT_FOLDER)
- set(CONAN_OUTPUT_FOLDER -of=${ARGUMENTS_OUTPUT_FOLDER})
- endif()
- foreach(ARG ${ARGUMENTS_GENERATORS})
- set(CONAN_GENERATORS ${CONAN_GENERATORS} -g=${ARG})
- endforeach()
- foreach(ARG ${ARGUMENTS_ENV})
- set(CONAN_ENV_VARS ${CONAN_ENV_VARS} -e=${ARG})
- endforeach()
- set(conan_args install ${CONANFILE} ${settings} ${CONAN_ENV_VARS}
${CONAN_GENERATORS} ${CONAN_BUILD_POLICY} ${CONAN_INSTALL_UPDATE}
${CONAN_INSTALL_NO_IMPORTS} ${CONAN_OPTIONS} ${CONAN_INSTALL_FOLDER}
${ARGUMENTS_INSTALL_ARGS})
-
- string (REPLACE ";" " " _conan_args "${conan_args}")
- message(STATUS "Conan executing: ${CONAN_CMD} ${_conan_args}")
-
- if(ARGUMENTS_OUTPUT_QUIET)
- execute_process(COMMAND ${CONAN_CMD} ${conan_args}
- RESULT_VARIABLE return_code
- OUTPUT_VARIABLE conan_output
- ERROR_VARIABLE conan_output
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
- else()
- execute_process(COMMAND ${CONAN_CMD} ${conan_args}
- RESULT_VARIABLE return_code
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
- endif()
-
- if(NOT "${return_code}" STREQUAL "0")
- message(FATAL_ERROR "Conan install failed='${return_code}'")
- endif()
-
-endfunction()
-
-function(conan_cmake_install)
- if(DEFINED CONAN_COMMAND)
- set(CONAN_CMD ${CONAN_COMMAND})
- else()
- conan_check(REQUIRED)
- endif()
-
- set(installOptions UPDATE NO_IMPORTS OUTPUT_QUIET ERROR_QUIET)
- set(installOneValueArgs PATH_OR_REFERENCE REFERENCE REMOTE LOCKFILE
LOCKFILE_OUT LOCKFILE_NODE_ID INSTALL_FOLDER OUTPUT_FOLDER)
- set(installMultiValueArgs GENERATOR BUILD ENV ENV_HOST ENV_BUILD
OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE
- PROFILE_HOST PROFILE_BUILD SETTINGS
SETTINGS_HOST SETTINGS_BUILD)
- cmake_parse_arguments(ARGS "${installOptions}" "${installOneValueArgs}"
"${installMultiValueArgs}" ${ARGN})
- foreach(arg ${installOptions})
- if(ARGS_${arg})
- set(${arg} ${${arg}} ${ARGS_${arg}})
- endif()
- endforeach()
- foreach(arg ${installOneValueArgs})
- if(DEFINED ARGS_${arg})
- if("${arg}" STREQUAL "REMOTE")
- set(flag "--remote")
- elseif("${arg}" STREQUAL "LOCKFILE")
- set(flag "--lockfile")
- elseif("${arg}" STREQUAL "LOCKFILE_OUT")
- set(flag "--lockfile-out")
- elseif("${arg}" STREQUAL "LOCKFILE_NODE_ID")
- set(flag "--lockfile-node-id")
- elseif("${arg}" STREQUAL "INSTALL_FOLDER")
- set(flag "--install-folder")
- elseif("${arg}" STREQUAL "OUTPUT_FOLDER")
- set(flag "--output-folder")
- endif()
- set(${arg} ${${arg}} ${flag} ${ARGS_${arg}})
- endif()
- endforeach()
- foreach(arg ${installMultiValueArgs})
- if(DEFINED ARGS_${arg})
- if("${arg}" STREQUAL "GENERATOR")
- set(flag "--generator")
- elseif("${arg}" STREQUAL "BUILD")
- set(flag "--build")
- elseif("${arg}" STREQUAL "ENV")
- set(flag "--env")
- elseif("${arg}" STREQUAL "ENV_HOST")
- set(flag "--env:host")
- elseif("${arg}" STREQUAL "ENV_BUILD")
- set(flag "--env:build")
- elseif("${arg}" STREQUAL "OPTIONS")
- set(flag "--options")
- elseif("${arg}" STREQUAL "OPTIONS_HOST")
- set(flag "--options:host")
- elseif("${arg}" STREQUAL "OPTIONS_BUILD")
- set(flag "--options:build")
- elseif("${arg}" STREQUAL "PROFILE")
- set(flag "--profile")
- elseif("${arg}" STREQUAL "PROFILE_HOST")
- set(flag "--profile:host")
- elseif("${arg}" STREQUAL "PROFILE_BUILD")
- set(flag "--profile:build")
- elseif("${arg}" STREQUAL "SETTINGS")
- set(flag "--settings")
- elseif("${arg}" STREQUAL "SETTINGS_HOST")
- set(flag "--settings:host")
- elseif("${arg}" STREQUAL "SETTINGS_BUILD")
- set(flag "--settings:build")
- endif()
- list(LENGTH ARGS_${arg} numargs)
- foreach(item ${ARGS_${arg}})
- if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD")
- set(${arg} "--build")
- break()
- endif()
- set(${arg} ${${arg}} ${flag} ${item})
- endforeach()
- endif()
- endforeach()
- if(DEFINED UPDATE)
- set(UPDATE --update)
- endif()
- if(DEFINED NO_IMPORTS)
- set(NO_IMPORTS --no-imports)
- endif()
- set(install_args install ${PATH_OR_REFERENCE} ${REFERENCE} ${UPDATE}
${NO_IMPORTS} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID}
${INSTALL_FOLDER} ${OUTPUT_FOLDER}
- ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST}
${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD}
- ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD}
${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD})
-
- string(REPLACE ";" " " _install_args "${install_args}")
- message(STATUS "Conan executing: ${CONAN_CMD} ${_install_args}")
-
- if(ARGS_OUTPUT_QUIET)
- set(OUTPUT_OPT OUTPUT_QUIET)
- endif()
- if(ARGS_ERROR_QUIET)
- set(ERROR_OPT ERROR_QUIET)
- endif()
-
- execute_process(COMMAND ${CONAN_CMD} ${install_args}
- RESULT_VARIABLE return_code
- ${OUTPUT_OPT}
- ${ERROR_OPT}
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
- if(NOT "${return_code}" STREQUAL "0")
- if (ARGS_ERROR_QUIET)
- message(WARNING "Conan install failed='${return_code}'")
- else()
- message(FATAL_ERROR "Conan install failed='${return_code}'")
- endif()
- endif()
-
-endfunction()
-
-function(conan_cmake_lock_create)
- if(DEFINED CONAN_COMMAND)
- set(CONAN_CMD ${CONAN_COMMAND})
- else()
- conan_check(REQUIRED)
- endif()
-
- set(lockCreateOptions UPDATE BASE OUTPUT_QUIET ERROR_QUIET)
- set(lockCreateOneValueArgs PATH REFERENCE REMOTE LOCKFILE LOCKFILE_OUT)
- set(lockCreateMultiValueArgs BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST
OPTIONS OPTIONS_BUILD PROFILE
- PROFILE_HOST PROFILE_BUILD SETTINGS
SETTINGS_HOST SETTINGS_BUILD)
- cmake_parse_arguments(ARGS "${lockCreateOptions}"
"${lockCreateOneValueArgs}" "${lockCreateMultiValueArgs}" ${ARGN})
- foreach(arg ${lockCreateOptions})
- if(ARGS_${arg})
- set(${arg} ${${arg}} ${ARGS_${arg}})
- endif()
- endforeach()
- foreach(arg ${lockCreateOneValueArgs})
- if(DEFINED ARGS_${arg})
- if("${arg}" STREQUAL "REMOTE")
- set(flag "--remote")
- elseif("${arg}" STREQUAL "LOCKFILE")
- set(flag "--lockfile")
- elseif("${arg}" STREQUAL "LOCKFILE_OUT")
- set(flag "--lockfile-out")
- endif()
- set(${arg} ${${arg}} ${flag} ${ARGS_${arg}})
- endif()
- endforeach()
- foreach(arg ${lockCreateMultiValueArgs})
- if(DEFINED ARGS_${arg})
- if("${arg}" STREQUAL "BUILD")
- set(flag "--build")
- elseif("${arg}" STREQUAL "ENV")
- set(flag "--env")
- elseif("${arg}" STREQUAL "ENV_HOST")
- set(flag "--env:host")
- elseif("${arg}" STREQUAL "ENV_BUILD")
- set(flag "--env:build")
- elseif("${arg}" STREQUAL "OPTIONS")
- set(flag "--options")
- elseif("${arg}" STREQUAL "OPTIONS_HOST")
- set(flag "--options:host")
- elseif("${arg}" STREQUAL "OPTIONS_BUILD")
- set(flag "--options:build")
- elseif("${arg}" STREQUAL "PROFILE")
- set(flag "--profile")
- elseif("${arg}" STREQUAL "PROFILE_HOST")
- set(flag "--profile:host")
- elseif("${arg}" STREQUAL "PROFILE_BUILD")
- set(flag "--profile:build")
- elseif("${arg}" STREQUAL "SETTINGS")
- set(flag "--settings")
- elseif("${arg}" STREQUAL "SETTINGS_HOST")
- set(flag "--settings:host")
- elseif("${arg}" STREQUAL "SETTINGS_BUILD")
- set(flag "--settings:build")
- endif()
- list(LENGTH ARGS_${arg} numargs)
- foreach(item ${ARGS_${arg}})
- if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD")
- set(${arg} "--build")
- break()
- endif()
- set(${arg} ${${arg}} ${flag} ${item})
- endforeach()
- endif()
- endforeach()
- if(DEFINED UPDATE)
- set(UPDATE --update)
- endif()
- if(DEFINED BASE)
- set(BASE --base)
- endif()
- set(lock_create_Args lock create ${PATH} ${REFERENCE} ${UPDATE} ${BASE}
${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER}
- ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST}
${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD}
- ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD}
${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD})
-
- string(REPLACE ";" " " _lock_create_Args "${lock_create_Args}")
- message(STATUS "Conan executing: ${CONAN_CMD} ${_lock_create_Args}")
-
- if(ARGS_OUTPUT_QUIET)
- set(OUTPUT_OPT OUTPUT_QUIET)
- endif()
- if(ARGS_ERROR_QUIET)
- set(ERROR_OPT ERROR_QUIET)
- endif()
-
- execute_process(COMMAND ${CONAN_CMD} ${lock_create_Args}
- RESULT_VARIABLE return_code
- ${OUTPUT_OPT}
- ${ERROR_OPT}
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
- if(NOT "${return_code}" STREQUAL "0")
- if (ARGS_ERROR_QUIET)
- message(WARNING "Conan lock create failed='${return_code}'")
- else()
- message(FATAL_ERROR "Conan lock create failed='${return_code}'")
- endif()
- endif()
-endfunction()
-
-function(conan_cmake_setup_conanfile)
- conan_parse_arguments(${ARGV})
- if(ARGUMENTS_CONANFILE)
- get_filename_component(_CONANFILE_NAME ${ARGUMENTS_CONANFILE} NAME)
- # configure_file will make sure cmake re-runs when conanfile is updated
- configure_file(${ARGUMENTS_CONANFILE}
${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk COPYONLY)
- file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk)
- else()
- conan_cmake_generate_conanfile(ON ${ARGV})
- endif()
-endfunction()
-
-function(conan_cmake_configure)
- conan_cmake_generate_conanfile(OFF ${ARGV})
-endfunction()
-
-# Generate, writing in disk a conanfile.txt with the requires, options, and
imports
-# specified as arguments
-# This will be considered as temporary file, generated in
CMAKE_CURRENT_BINARY_DIR)
-function(conan_cmake_generate_conanfile DEFAULT_GENERATOR)
-
- conan_parse_arguments(${ARGV})
-
- set(_FN "${CMAKE_CURRENT_BINARY_DIR}/conanfile.txt")
- file(WRITE ${_FN} "")
-
- if(DEFINED ARGUMENTS_REQUIRES)
- file(APPEND ${_FN} "[requires]\n")
- foreach(REQUIRE ${ARGUMENTS_REQUIRES})
- file(APPEND ${_FN} ${REQUIRE} "\n")
- endforeach()
- endif()
-
- if (DEFAULT_GENERATOR OR DEFINED ARGUMENTS_GENERATORS)
- file(APPEND ${_FN} "[generators]\n")
- if (DEFAULT_GENERATOR)
- file(APPEND ${_FN} "cmake\n")
- endif()
- if (DEFINED ARGUMENTS_GENERATORS)
- foreach(GENERATOR ${ARGUMENTS_GENERATORS})
- file(APPEND ${_FN} ${GENERATOR} "\n")
- endforeach()
- endif()
- endif()
-
- if(DEFINED ARGUMENTS_BUILD_REQUIRES)
- file(APPEND ${_FN} "[build_requires]\n")
- foreach(BUILD_REQUIRE ${ARGUMENTS_BUILD_REQUIRES})
- file(APPEND ${_FN} ${BUILD_REQUIRE} "\n")
- endforeach()
- endif()
-
- if(DEFINED ARGUMENTS_IMPORTS)
- file(APPEND ${_FN} "[imports]\n")
- foreach(IMPORTS ${ARGUMENTS_IMPORTS})
- file(APPEND ${_FN} ${IMPORTS} "\n")
- endforeach()
- endif()
-
- if(DEFINED ARGUMENTS_OPTIONS)
- file(APPEND ${_FN} "[options]\n")
- foreach(OPTION ${ARGUMENTS_OPTIONS})
- file(APPEND ${_FN} ${OPTION} "\n")
- endforeach()
- endif()
-
-endfunction()
-
-
-macro(conan_load_buildinfo)
- if(CONAN_CMAKE_MULTI)
- set(_CONANBUILDINFO conanbuildinfo_multi.cmake)
- else()
- set(_CONANBUILDINFO conanbuildinfo.cmake)
- endif()
- if(ARGUMENTS_INSTALL_FOLDER)
- set(_CONANBUILDINFOFOLDER ${ARGUMENTS_INSTALL_FOLDER})
- else()
- set(_CONANBUILDINFOFOLDER ${CMAKE_CURRENT_BINARY_DIR})
- endif()
- # Checks for the existence of conanbuildinfo.cmake, and loads it
- # important that it is macro, so variables defined at parent scope
- if(EXISTS "${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}")
- message(STATUS "Conan: Loading ${_CONANBUILDINFO}")
- include(${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO})
- else()
- message(FATAL_ERROR "${_CONANBUILDINFO} doesn't exist in
${CMAKE_CURRENT_BINARY_DIR}")
- endif()
-endmacro()
-
-
-macro(conan_cmake_run)
- conan_parse_arguments(${ARGV})
-
- if(ARGUMENTS_CONFIGURATION_TYPES AND NOT CMAKE_CONFIGURATION_TYPES)
- message(WARNING "CONFIGURATION_TYPES should only be specified for
multi-configuration generators")
- elseif(ARGUMENTS_CONFIGURATION_TYPES AND ARGUMENTS_BUILD_TYPE)
- message(WARNING "CONFIGURATION_TYPES and BUILD_TYPE arguments should
not be defined at the same time.")
- endif()
-
- if(CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE AND NOT
CONAN_EXPORTED
- AND NOT ARGUMENTS_BUILD_TYPE)
- set(CONAN_CMAKE_MULTI ON)
- if (NOT ARGUMENTS_CONFIGURATION_TYPES)
- set(ARGUMENTS_CONFIGURATION_TYPES "Release;Debug")
- endif()
- message(STATUS "Conan: Using cmake-multi generator")
- else()
- set(CONAN_CMAKE_MULTI OFF)
- endif()
-
- if(NOT CONAN_EXPORTED)
- conan_cmake_setup_conanfile(${ARGV})
- if(CONAN_CMAKE_MULTI)
- foreach(CMAKE_BUILD_TYPE ${ARGUMENTS_CONFIGURATION_TYPES})
- set(ENV{CONAN_IMPORT_PATH} ${CMAKE_BUILD_TYPE})
- conan_cmake_settings(settings ${ARGV})
- old_conan_cmake_install(SETTINGS ${settings} ${ARGV})
- endforeach()
- set(CMAKE_BUILD_TYPE)
- else()
- conan_cmake_settings(settings ${ARGV})
- old_conan_cmake_install(SETTINGS ${settings} ${ARGV})
- endif()
- endif()
-
- if (NOT ARGUMENTS_NO_LOAD)
- conan_load_buildinfo()
- endif()
-
- if(ARGUMENTS_BASIC_SETUP)
- foreach(_option CMAKE_TARGETS KEEP_RPATHS NO_OUTPUT_DIRS SKIP_STD)
- if(ARGUMENTS_${_option})
- if(${_option} STREQUAL "CMAKE_TARGETS")
- list(APPEND _setup_options "TARGETS")
- else()
- list(APPEND _setup_options ${_option})
- endif()
- endif()
- endforeach()
- conan_basic_setup(${_setup_options})
- endif()
-endmacro()
-
-macro(conan_check)
- # Checks conan availability in PATH
- # Arguments REQUIRED, DETECT_QUIET and VERSION are optional
- # Example usage:
- # conan_check(VERSION 1.0.0 REQUIRED)
- set(options REQUIRED DETECT_QUIET)
- set(oneValueArgs VERSION)
- cmake_parse_arguments(CONAN "${options}" "${oneValueArgs}" "" ${ARGN})
- if(NOT CONAN_DETECT_QUIET)
- message(STATUS "Conan: checking conan executable")
- endif()
-
- find_program(CONAN_CMD conan)
- if(NOT CONAN_CMD AND CONAN_REQUIRED)
- message(FATAL_ERROR "Conan executable not found! Please install
conan.")
- endif()
- if(NOT CONAN_DETECT_QUIET)
- message(STATUS "Conan: Found program ${CONAN_CMD}")
- endif()
- execute_process(COMMAND ${CONAN_CMD} --version
- RESULT_VARIABLE return_code
- OUTPUT_VARIABLE CONAN_VERSION_OUTPUT
- ERROR_VARIABLE CONAN_VERSION_OUTPUT)
-
- if(NOT "${return_code}" STREQUAL "0")
- message(FATAL_ERROR "Conan --version failed='${return_code}'")
- endif()
-
- if(NOT CONAN_DETECT_QUIET)
- string(STRIP "${CONAN_VERSION_OUTPUT}" _CONAN_VERSION_OUTPUT)
- message(STATUS "Conan: Version found ${_CONAN_VERSION_OUTPUT}")
- endif()
-
- if(DEFINED CONAN_VERSION)
- string(REGEX MATCH ".*Conan version ([0-9]+\\.[0-9]+\\.[0-9]+)" FOO
- "${CONAN_VERSION_OUTPUT}")
- if(${CMAKE_MATCH_1} VERSION_LESS ${CONAN_VERSION})
- message(FATAL_ERROR "Conan outdated. Installed: ${CMAKE_MATCH_1}, \
- required: ${CONAN_VERSION}. Consider updating via 'pip \
- install conan==${CONAN_VERSION}'.")
- endif()
- endif()
-endmacro()
-
-function(conan_add_remote)
- # Adds a remote
- # Arguments URL and NAME are required, INDEX, COMMAND and VERIFY_SSL are
optional
- # Example usage:
- # conan_add_remote(NAME bincrafters INDEX 1
- # URL https://api.bintray.com/conan/bincrafters/public-conan
- # VERIFY_SSL True)
- set(oneValueArgs URL NAME INDEX COMMAND VERIFY_SSL)
- cmake_parse_arguments(CONAN "" "${oneValueArgs}" "" ${ARGN})
-
- if(DEFINED CONAN_INDEX)
- set(CONAN_INDEX_ARG "-i ${CONAN_INDEX}")
- endif()
- if(DEFINED CONAN_COMMAND)
- set(CONAN_CMD ${CONAN_COMMAND})
- else()
- conan_check(REQUIRED DETECT_QUIET)
- endif()
- set(CONAN_VERIFY_SSL_ARG "True")
- if(DEFINED CONAN_VERIFY_SSL)
- set(CONAN_VERIFY_SSL_ARG ${CONAN_VERIFY_SSL})
- endif()
- message(STATUS "Conan: Adding ${CONAN_NAME} remote repository
(${CONAN_URL}) verify ssl (${CONAN_VERIFY_SSL_ARG})")
- execute_process(COMMAND ${CONAN_CMD} remote add ${CONAN_NAME}
${CONAN_INDEX_ARG} -f ${CONAN_URL} ${CONAN_VERIFY_SSL_ARG}
- RESULT_VARIABLE return_code)
- if(NOT "${return_code}" STREQUAL "0")
- message(FATAL_ERROR "Conan remote failed='${return_code}'")
- endif()
-endfunction()
-
-macro(conan_config_install)
- # install a full configuration from a local or remote zip file
- # Argument ITEM is required, arguments TYPE, SOURCE, TARGET and VERIFY_SSL
are optional
- # Example usage:
- # conan_config_install(ITEM https://github.com/conan-io/cmake-conan.git
- # TYPE git SOURCE source-folder TARGET target-folder VERIFY_SSL
false)
- set(oneValueArgs ITEM TYPE SOURCE TARGET VERIFY_SSL)
- set(multiValueArgs ARGS)
- cmake_parse_arguments(CONAN "" "${oneValueArgs}" "${multiValueArgs}"
${ARGN})
-
- if(DEFINED CONAN_COMMAND)
- set(CONAN_CMD ${CONAN_COMMAND})
- else()
- conan_check(REQUIRED)
- endif()
-
- if(DEFINED CONAN_VERIFY_SSL)
- set(CONAN_VERIFY_SSL_ARG "--verify-ssl=${CONAN_VERIFY_SSL}")
- endif()
-
- if(DEFINED CONAN_TYPE)
- set(CONAN_TYPE_ARG "--type=${CONAN_TYPE}")
- endif()
-
- if(DEFINED CONAN_ARGS)
- set(CONAN_ARGS_ARGS "--args=\"${CONAN_ARGS}\"")
- endif()
-
- if(DEFINED CONAN_SOURCE)
- set(CONAN_SOURCE_ARGS "--source-folder=${CONAN_SOURCE}")
- endif()
-
- if(DEFINED CONAN_TARGET)
- set(CONAN_TARGET_ARGS "--target-folder=${CONAN_TARGET}")
- endif()
-
- set (CONAN_CONFIG_INSTALL_ARGS ${CONAN_VERIFY_SSL_ARG}
- ${CONAN_TYPE_ARG}
- ${CONAN_ARGS_ARGS}
- ${CONAN_SOURCE_ARGS}
- ${CONAN_TARGET_ARGS})
-
- message(STATUS "Conan: Installing config from ${CONAN_ITEM}")
- execute_process(COMMAND ${CONAN_CMD} config install ${CONAN_ITEM}
${CONAN_CONFIG_INSTALL_ARGS}
- RESULT_VARIABLE return_code)
- if(NOT "${return_code}" STREQUAL "0")
- message(FATAL_ERROR "Conan config failed='${return_code}'")
- endif()
-endmacro()
diff --git a/modules/platforms/cpp/cmake/dependencies.cmake
b/modules/platforms/cpp/cmake/dependencies.cmake
new file mode 100644
index 0000000000..b01c05d45b
--- /dev/null
+++ b/modules/platforms/cpp/cmake/dependencies.cmake
@@ -0,0 +1,50 @@
+if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.24.0")
+ # Avoid warning about DOWNLOAD_EXTRACT_TIMESTAMP:
+ cmake_policy(SET CMP0135 NEW)
+endif()
+
+# Policy about variables override by options
+# https://cmake.org/cmake/help/latest/policy/CMP0077.html
+set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
+
+set(MSGPACK_BUILD_TESTS OFF)
+set(MSGPACK_GEN_COVERAGE OFF)
+set(MSGPACK_BUILD_EXAMPLES OFF)
+
+if (${USE_LOCAL_DEPS})
+ find_package(msgpack REQUIRED)
+ if (${msgpack_FOUND})
+ # ALIAS for the msgpack-c version lower than 6.0.0
+ add_library(msgpack-c-static ALIAS msgpackc-static)
+ message(STATUS "SYSTEM MSGPACK FOUND: " ${msgpack_VERSION})
+ endif()
+
+ if (${ENABLE_TESTS})
+ find_package(GTest REQUIRED)
+ if (${GTest_FOUND})
+ if (TARGET GTest::Main AND NOT TARGET GTest::gtest_main)
+ add_library(GTest::gtest_main ALIAS GTest::Main)
+ endif()
+ message(STATUS "SYSTEM GTEST FOUND: " ${GTest_VERSION})
+ endif()
+ endif()
+else()
+ include(FetchContent)
+ message(STATUS "DOWNLOAD MSGPACK")
+ FetchContent_Declare(
+ msgpack-c
+ URL
https://github.com/msgpack/msgpack-c/releases/download/c-6.0.1/msgpack-c-6.0.1.tar.gz
+ URL_HASH MD5=090df53a59b845767fcfc48221b30ee9
+ )
+ FetchContent_MakeAvailable(msgpack-c)
+
+ if (${ENABLE_TESTS})
+ message(STATUS "DOWNLOAD GTEST")
+ FetchContent_Declare(
+ googletest
+ URL
https://github.com/google/googletest/archive/refs/tags/v1.14.0.tar.gz
+ URL_HASH MD5=c8340a482851ef6a3fe618a082304cfc
+ )
+ FetchContent_MakeAvailable(googletest)
+ endif()
+endif()
diff --git a/modules/platforms/cpp/cmake/ignite_test.cmake
b/modules/platforms/cpp/cmake/ignite_test.cmake
index 108fcf704e..b900141401 100644
--- a/modules/platforms/cpp/cmake/ignite_test.cmake
+++ b/modules/platforms/cpp/cmake/ignite_test.cmake
@@ -15,28 +15,29 @@
# limitations under the License.
#
-# ignite_test(<test-name> <test-src> [LIBS <lib>...])
+# ignite_test(<test-name> [DISCOVER] SOURCES <test-src>... [LIBS <lib>...])
#
# Function to add a unit test.
-function(ignite_test TEST_NAME TEST_SOURCE)
+function(ignite_test TEST_NAME)
if (NOT ${ENABLE_TESTS})
return()
endif()
- cmake_parse_arguments(IGNITE_TEST "" "" "LIBS" ${ARGN})
+ set(OPTIONAL_ARGUMENT_TAGS DISCOVER)
+ set(SINGLE_ARGUMENT_TAGS)
+ set(MULTI_ARGUMENT_TAGS LIBS SOURCES)
- add_executable(${TEST_NAME} ${TEST_SOURCE})
+ cmake_parse_arguments(IGNITE_TEST
+ "${OPTIONAL_ARGUMENT_TAGS}"
+ "${SINGLE_ARGUMENT_TAGS}"
+ "${MULTI_ARGUMENT_TAGS}"
+ ${ARGN})
- # Older versions of CMake provide the GTest::Main target while newer
versions
- # provide the GTest::gtest_main target. The old target is deprecated but
still
- # available for now. However Conan-generated build recipe takes over
original
- # CMake behavior and provides the new target only. This mess is handled
here.
- # So we can build with and without Conan, with newer and with older CMake.
- if (TARGET GTest::gtest_main)
- target_link_libraries(${TEST_NAME} ${IGNITE_TEST_LIBS} GTest::gtest
GTest::gtest_main)
- else()
- target_link_libraries(${TEST_NAME} ${IGNITE_TEST_LIBS} GTest::GTest
GTest::Main)
- endif()
+ add_executable(${TEST_NAME} ${IGNITE_TEST_SOURCES})
+
+ target_link_libraries(${TEST_NAME} ${IGNITE_TEST_LIBS} GTest::gtest_main
GTest::gmock_main)
- gtest_discover_tests(${TEST_NAME} XML_OUTPUT_DIR
${CMAKE_BINARY_DIR}/Testing/Result)
+ if(${IGNITE_TEST_DISCOVER})
+ gtest_discover_tests(${TEST_NAME} XML_OUTPUT_DIR
${CMAKE_BINARY_DIR}/Testing/Result)
+ endif()
endfunction()
diff --git a/modules/platforms/cpp/ignite/client/CMakeLists.txt
b/modules/platforms/cpp/ignite/client/CMakeLists.txt
index c9d763ba10..bc7210d1cd 100644
--- a/modules/platforms/cpp/ignite/client/CMakeLists.txt
+++ b/modules/platforms/cpp/ignite/client/CMakeLists.txt
@@ -103,4 +103,4 @@ if (${INSTALL_IGNITE_FILES})
ignite_install_headers(FILES ${PUBLIC_HEADERS} DESTINATION
${IGNITE_INCLUDEDIR}/client)
endif()
-ignite_test(utils_test detail/utils_test.cpp LIBS ${TARGET}-obj ${LIBRARIES})
+ignite_test(utils_test DISCOVER SOURCES detail/utils_test.cpp LIBS
${TARGET}-obj ${LIBRARIES})
diff --git a/modules/platforms/cpp/ignite/common/CMakeLists.txt
b/modules/platforms/cpp/ignite/common/CMakeLists.txt
index a4a8701fbf..28ae4574c8 100644
--- a/modules/platforms/cpp/ignite/common/CMakeLists.txt
+++ b/modules/platforms/cpp/ignite/common/CMakeLists.txt
@@ -58,9 +58,9 @@ if (${INSTALL_IGNITE_FILES})
ignite_install_headers(FILES ${PUBLIC_HEADERS} DESTINATION
${IGNITE_INCLUDEDIR}/common)
endif()
-ignite_test(bits_test bits_test.cpp LIBS ${TARGET})
-ignite_test(bytes_test bytes_test.cpp LIBS ${TARGET})
-ignite_test(uuid_test uuid_test.cpp LIBS ${TARGET})
-ignite_test(bignum_test bignum_test.cpp LIBS ${TARGET})
-ignite_test(bit_array_test bit_array_test.cpp LIBS ${TARGET})
-ignite_test(primitive_test primitive_test.cpp LIBS ${TARGET})
+ignite_test(bits_test DISCOVER SOURCES bits_test.cpp LIBS ${TARGET})
+ignite_test(bytes_test DISCOVER SOURCES bytes_test.cpp LIBS ${TARGET})
+ignite_test(uuid_test DISCOVER SOURCES uuid_test.cpp LIBS ${TARGET})
+ignite_test(bignum_test DISCOVER SOURCES bignum_test.cpp LIBS ${TARGET})
+ignite_test(bit_array_test DISCOVER SOURCES bit_array_test.cpp LIBS ${TARGET})
+ignite_test(primitive_test DISCOVER SOURCES primitive_test.cpp LIBS ${TARGET})
diff --git a/modules/platforms/cpp/ignite/odbc/CMakeLists.txt
b/modules/platforms/cpp/ignite/odbc/CMakeLists.txt
index 3ff43b914b..53e4946400 100644
--- a/modules/platforms/cpp/ignite/odbc/CMakeLists.txt
+++ b/modules/platforms/cpp/ignite/odbc/CMakeLists.txt
@@ -99,8 +99,8 @@ if (${INSTALL_IGNITE_FILES})
)
endif()
-ignite_test(connection_info_test config/connection_info_test.cpp LIBS
${TARGET}-obj ${LIBRARIES})
-ignite_test(config_tools_test config/config_tools_test.cpp LIBS ${TARGET}-obj
${LIBRARIES})
-ignite_test(string_utils_test string_utils_test.cpp LIBS ${TARGET}-obj
${LIBRARIES})
-ignite_test(application_data_buffer_test app/application_data_buffer_test.cpp
LIBS ${TARGET}-obj ${LIBRARIES})
+ignite_test(connection_info_test DISCOVER SOURCES
config/connection_info_test.cpp LIBS ${TARGET}-obj ${LIBRARIES})
+ignite_test(config_tools_test DISCOVER SOURCES config/config_tools_test.cpp
LIBS ${TARGET}-obj ${LIBRARIES})
+ignite_test(string_utils_test DISCOVER SOURCES string_utils_test.cpp LIBS
${TARGET}-obj ${LIBRARIES})
+ignite_test(application_data_buffer_test DISCOVER SOURCES
app/application_data_buffer_test.cpp LIBS ${TARGET}-obj ${LIBRARIES})
diff --git a/modules/platforms/cpp/ignite/protocol/CMakeLists.txt
b/modules/platforms/cpp/ignite/protocol/CMakeLists.txt
index 31aa14dc12..b83786d8f9 100644
--- a/modules/platforms/cpp/ignite/protocol/CMakeLists.txt
+++ b/modules/platforms/cpp/ignite/protocol/CMakeLists.txt
@@ -19,8 +19,6 @@ project(ignite-protocol)
set(TARGET ${PROJECT_NAME})
-find_package(msgpack)
-
set(SOURCES
bitset_span.h
buffer_adapter.cpp buffer_adapter.h
@@ -34,7 +32,7 @@ set(SOURCES
)
add_library(${TARGET} OBJECT ${SOURCES})
-target_link_libraries(${TARGET} ignite-common msgpackc)
+target_link_libraries(${TARGET} ignite-common msgpack-c-static)
set_target_properties(${TARGET} PROPERTIES VERSION ${CMAKE_PROJECT_VERSION})
set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE 1)
diff --git a/modules/platforms/cpp/ignite/tuple/CMakeLists.txt
b/modules/platforms/cpp/ignite/tuple/CMakeLists.txt
index 9691ccc2fb..ad32f1c386 100644
--- a/modules/platforms/cpp/ignite/tuple/CMakeLists.txt
+++ b/modules/platforms/cpp/ignite/tuple/CMakeLists.txt
@@ -34,7 +34,7 @@ add_library(${TARGET} STATIC ${SOURCES})
target_link_libraries(${TARGET} ignite-common)
-ignite_test(tuple_test tuple_test.cpp LIBS ${TARGET})
+ignite_test(tuple_test DISCOVER SOURCES tuple_test.cpp LIBS ${TARGET})
if (${INSTALL_IGNITE_FILES})
install(TARGETS ${TARGET}
diff --git a/modules/platforms/cpp/tests/client-test/CMakeLists.txt
b/modules/platforms/cpp/tests/client-test/CMakeLists.txt
index ff944b3191..a50ce864f3 100644
--- a/modules/platforms/cpp/tests/client-test/CMakeLists.txt
+++ b/modules/platforms/cpp/tests/client-test/CMakeLists.txt
@@ -37,8 +37,4 @@ set(SOURCES
transactions_test.cpp
)
-add_executable(${TARGET} ${SOURCES})
-target_link_libraries(${TARGET} ignite-test-common ignite-client GTest::GTest)
-
-set(TEST_TARGET IgniteClientTest)
-add_test(NAME ${TEST_TARGET} COMMAND ${TARGET})
+ignite_test(${TARGET} SOURCES ${SOURCES} LIBS ignite-test-common ignite-client)
diff --git a/modules/platforms/cpp/tests/odbc-test/CMakeLists.txt
b/modules/platforms/cpp/tests/odbc-test/CMakeLists.txt
index 05125ad6d7..b8825eafb1 100644
--- a/modules/platforms/cpp/tests/odbc-test/CMakeLists.txt
+++ b/modules/platforms/cpp/tests/odbc-test/CMakeLists.txt
@@ -34,14 +34,8 @@ set(SOURCES
transaction_test.cpp
)
-add_executable(${TARGET} ${SOURCES})
-target_link_libraries(${TARGET} ignite-test-common ignite-client
${ODBC_LIBRARY} GTest::GTest)
+ignite_test(${TARGET} SOURCES ${SOURCES} LIBS ignite-test-common ignite-client
${ODBC_LIBRARY})
if (WIN32)
remove_definitions(-DUNICODE=1)
-else()
- add_definitions(-DBOOST_TEST_DYN_LINK)
endif()
-
-set(TEST_TARGET IgniteOdbcTest)
-add_test(NAME ${TEST_TARGET} COMMAND ${TARGET})
