cassandra-cpp-driver: add version 2.16.2, support conan v2

recipes/cassandra-cpp-driver/all/conandata.yml

@@ -1,10 +1,36 @@
 sources:
+  "2.16.2":
+    url: "https://github.com/datastax/cpp-driver/archive/2.16.2.tar.gz"
+    sha256: "de60751bd575b5364c2c5a17a24a40f3058264ea2ee6fef19de126ae550febc9"
   "2.15.3":
-    url: "https://github.com/datastax/cpp-driver/archive/2.15.3.zip"
-    sha256: "494b35418f1eaa86d80572a4254b7fae88a1341dcda83788ed038ce4f39117cb"
+    url: "https://github.com/datastax/cpp-driver/archive/2.15.3.tar.gz"
+    sha256: "eccb53c5151621c3b647fc83781a542cfb93e76687b4178ebce418fc4c817293"
 patches:
+  "2.16.2":
+    - patch_file: "patches/2.16.2/fix-cmake.patch"
+      patch_description: "use cci package"
+      patch_type: "conan"
+    - patch_file: "patches/2.15.3/fix-rapidjson.patch"
+      patch_description: "fix include path for cci package"
+      patch_type: "conan"
+    - patch_file: "patches/2.15.3/fix-atomic.patch"
+      patch_description: "Adapt MemoryOrder definition for C++ 20"
+      patch_type: "portability"
+      patch_source: "https://github.com/datastax/cpp-driver/pull/533"
+    - patch_file: "patches/2.15.3/remove-attribute-for-msvc.patch"
+      patch_description: "remove attribute for msvc"
+      patch_type: "portability"
   "2.15.3":
-    - base_path: "source_subfolder"
-      patch_file: "patches/2.15.3/fix-cmake.patch"
-    - base_path: "source_subfolder"
-      patch_file: "patches/2.15.3/fix-rapidjson.patch"
+    - patch_file: "patches/2.15.3/fix-cmake.patch"
+      patch_description: "use cci package"
+      patch_type: "conan"
+    - patch_file: "patches/2.15.3/fix-rapidjson.patch"
+      patch_description: "fix include path for cci package"
+      patch_type: "conan"
+    - patch_file: "patches/2.15.3/fix-atomic.patch"
+      patch_description: "Adapt MemoryOrder definition for C++ 20"
+      patch_type: "portability"
+      patch_source: "https://github.com/datastax/cpp-driver/pull/533"
+    - patch_file: "patches/2.15.3/remove-attribute-for-msvc.patch"
+      patch_description: "remove attribute for msvc"
+      patch_type: "portability"

recipes/cassandra-cpp-driver/all/conanfile.py

@@ -1,19 +1,20 @@
-from conans import ConanFile, CMake, tools
-from conans.errors import ConanInvalidConfiguration
+from conan import ConanFile
+from conan.errors import ConanInvalidConfiguration
+from conan.tools.files import apply_conandata_patches, export_conandata_patches, get, copy, replace_in_file, rm
+from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
+from conan.tools.build import check_min_cppstd
 import os
 
-required_conan_version = ">=1.33.0"
-
+required_conan_version = ">=1.53.0"
 
 class CassandraCppDriverConan(ConanFile):
     name = "cassandra-cpp-driver"
+    description = "DataStax C/C++ Driver for Apache Cassandra and DataStax Products"
     license = "Apache-2.0"
     url = "https://github.com/conan-io/conan-center-index"
     homepage = "https://docs.datastax.com/en/developer/cpp-driver/"
-    description = "DataStax C/C++ Driver for Apache Cassandra and DataStax Products"
-    topics = ("cassandra", "cpp-driver", "database", "conan-recipe")
-
-    settings = "os", "compiler", "build_type", "arch"
+    topics = ("cassandra", "cpp-driver", "database",)
+    settings = "os", "arch", "compiler", "build_type"
     options = {
         "shared": [True, False],
         "fPIC": [True, False],
@@ -34,19 +35,14 @@ class CassandraCppDriverConan(ConanFile):
         "with_kerberos": False,
         "use_timerfd": True,
     }
-
     short_paths = True
-    generators = "cmake"
-    exports_sources = [
-        "CMakeLists.txt",
-        "patches/*"
-    ]
-
-    _cmake = None
 
     @property
-    def _source_subfolder(self):
-        return "source_subfolder"
+    def _min_cppstd(self):
+        return 11
+
+    def export_sources(self):
+        export_conandata_patches(self)
 
     def config_options(self):
         if self.settings.os == "Windows":
@@ -55,24 +51,30 @@ def config_options(self):
 
     def configure(self):
         if self.options.shared:
-            del self.options.fPIC
+            self.options.rm_safe("fPIC")
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
 
     def requirements(self):
-        self.requires("libuv/1.44.1")
+        self.requires("libuv/1.46.0")
         self.requires("http_parser/2.9.4")
-        self.requires("rapidjson/cci.20211112")
+        self.requires("rapidjson/cci.20220822")
 
         if self.options.with_openssl:
-            self.requires("openssl/1.1.1q")
+            self.requires("openssl/[>=1.1 <4]")
 
         if self.options.with_zlib:
-            self.requires("minizip/1.2.12")
-            self.requires("zlib/1.2.12")
+            self.requires("minizip/1.2.13")
+            self.requires("zlib/1.2.13")
 
         if self.options.use_atomic == "boost":
-            self.requires("boost/1.79.0")
+            self.requires("boost/1.82.0")
 
     def validate(self):
+        if self.info.settings.compiler.cppstd:
+            check_min_cppstd(self, self._min_cppstd)
+
         if self.options.use_atomic == "boost":
             # Compilation error on Linux
             if self.settings.os == "Linux":
@@ -84,69 +86,69 @@ def validate(self):
                 "Kerberos is not supported at the moment")
 
     def source(self):
-        tools.get(**self.conan_data["sources"][self.version],
-                  destination=self._source_subfolder, strip_root=True)
-
-    def _patch_sources(self):
-        for patch in self.conan_data.get("patches", {}).get(self.version, []):
-            tools.patch(**patch)
-        tools.replace_in_file(os.path.join(self._source_subfolder, "CMakeLists.txt"),
-                              "\"${CMAKE_CXX_COMPILER_ID}\" STREQUAL \"Clang\"",
-                              "\"${CMAKE_CXX_COMPILER_ID}\" STREQUAL \"Clang\" OR \"${CMAKE_CXX_COMPILER_ID}\" STREQUAL \"AppleClang\"")
-
-    def _configure_cmake(self):
-        if self._cmake:
-            return self._cmake
-
-        self._cmake = CMake(self)
-        self._cmake.definitions["VERSION"] = self.version
-        self._cmake.definitions["CASS_BUILD_EXAMPLES"] = False
-        self._cmake.definitions["CASS_BUILD_INTEGRATION_TESTS"] = False
-        self._cmake.definitions["CASS_BUILD_SHARED"] = self.options.shared
-        self._cmake.definitions["CASS_BUILD_STATIC"] = not self.options.shared
-        self._cmake.definitions["CASS_BUILD_TESTS"] = False
-        self._cmake.definitions["CASS_BUILD_UNIT_TESTS"] = False
-        self._cmake.definitions["CASS_DEBUG_CUSTOM_ALLOC"] = False
-        self._cmake.definitions["CASS_INSTALL_HEADER_IN_SUBDIR"] = self.options.install_header_in_subdir
-        self._cmake.definitions["CASS_INSTALL_PKG_CONFIG"] = False
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["VERSION"] = self.version
+        tc.variables["CASS_BUILD_EXAMPLES"] = False
+        tc.variables["CASS_BUILD_INTEGRATION_TESTS"] = False
+        tc.variables["CASS_BUILD_SHARED"] = self.options.shared
+        tc.variables["CASS_BUILD_STATIC"] = not self.options.shared
+        tc.variables["CASS_BUILD_TESTS"] = False
+        tc.variables["CASS_BUILD_UNIT_TESTS"] = False
+        tc.variables["CASS_DEBUG_CUSTOM_ALLOC"] = False
+        tc.variables["CASS_INSTALL_HEADER_IN_SUBDIR"] = self.options.install_header_in_subdir
+        tc.variables["CASS_INSTALL_PKG_CONFIG"] = False
 
         if self.options.use_atomic == "boost":
-            self._cmake.definitions["CASS_USE_BOOST_ATOMIC"] = True
-            self._cmake.definitions["CASS_USE_STD_ATOMIC"] = False
+            tc.variables["CASS_USE_BOOST_ATOMIC"] = True
+            tc.variables["CASS_USE_STD_ATOMIC"] = False
 
         elif self.options.use_atomic == "std":
-            self._cmake.definitions["CASS_USE_BOOST_ATOMIC"] = False
-            self._cmake.definitions["CASS_USE_STD_ATOMIC"] = True
+            tc.variables["CASS_USE_BOOST_ATOMIC"] = False
+            tc.variables["CASS_USE_STD_ATOMIC"] = True
         else:
-            self._cmake.definitions["CASS_USE_BOOST_ATOMIC"] = False
-            self._cmake.definitions["CASS_USE_STD_ATOMIC"] = False
+            tc.variables["CASS_USE_BOOST_ATOMIC"] = False
+            tc.variables["CASS_USE_STD_ATOMIC"] = False
 
-        self._cmake.definitions["CASS_USE_OPENSSL"] = self.options.with_openssl
-        self._cmake.definitions["CASS_USE_STATIC_LIBS"] = False
-        self._cmake.definitions["CASS_USE_ZLIB"] = self.options.with_zlib
-        self._cmake.definitions["CASS_USE_LIBSSH2"] = False
+        tc.variables["CASS_USE_OPENSSL"] = self.options.with_openssl
+        tc.variables["CASS_USE_STATIC_LIBS"] = False
+        tc.variables["CASS_USE_ZLIB"] = self.options.with_zlib
+        tc.variables["CASS_USE_LIBSSH2"] = False
 
         # FIXME: To use kerberos, its conan package is needed. Uncomment this when kerberos conan package is ready.
-        # self._cmake.definitions["CASS_USE_KERBEROS"] = self.options.with_kerberos
+        # tc.variables["CASS_USE_KERBEROS"] = self.options.with_kerberos
 
         if self.settings.os == "Linux":
-            self._cmake.definitions["CASS_USE_TIMERFD"] = self.options.use_timerfd
+            tc.variables["CASS_USE_TIMERFD"] = self.options.use_timerfd
+        tc.generate()
 
-        self._cmake.configure()
-        return self._cmake
+        deps = CMakeDeps(self)
+        deps.generate()
+
+    def _patch_sources(self):
+        apply_conandata_patches(self)
+        replace_in_file(self, os.path.join(self.source_folder, "CMakeLists.txt"),
+                              "\"${CMAKE_CXX_COMPILER_ID}\" STREQUAL \"Clang\"",
+                              "\"${CMAKE_CXX_COMPILER_ID}\" STREQUAL \"Clang\" OR \"${CMAKE_CXX_COMPILER_ID}\" STREQUAL \"AppleClang\"")
+        rm(self, "Findlibssh2.cmake", os.path.join(self.source_folder, "cmake"))
+        rm(self, "Findlibuv.cmake", os.path.join(self.source_folder, "cmake"))
+        rm(self, "FindOpenSSL.cmake", os.path.join(self.source_folder, "cmake"))
 
     def build(self):
         self._patch_sources()
-        cmake = self._configure_cmake()
+        cmake = CMake(self)
+        cmake.configure()
         cmake.build()
 
     def package(self):
-        self.copy(pattern="LICENSE.txt", dst="licenses", src=self._source_subfolder)
-        cmake = self._configure_cmake()
+        copy(self, pattern="LICENSE.txt", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
+        cmake = CMake(self)
         cmake.install()
 
     def package_info(self):
-        self.cpp_info.libs = tools.collect_libs(self)
+        self.cpp_info.libs = ["cassandra" if self.options.shared else "cassandra_static"]
 
         if self.settings.os == "Windows":
             self.cpp_info.system_libs.extend(["iphlpapi", "psapi", "wsock32",

recipes/cassandra-cpp-driver/all/patches/2.15.3/fix-atomic.patch

@@ -0,0 +1,28 @@
+diff --git a/src/atomic/atomic_std.hpp b/src/atomic/atomic_std.hpp
+index 2ad0103..08418a9 100644
+--- a/src/atomic/atomic_std.hpp
++++ b/src/atomic/atomic_std.hpp
+@@ -18,16 +18,17 @@
+ #define DATASTAX_INTERNAL_ATOMIC_STD_HPP
+
+ #include <atomic>
++#include <type_traits>
+
+ namespace datastax { namespace internal {
+
+ enum MemoryOrder {
+-  MEMORY_ORDER_RELAXED = std::memory_order_relaxed,
+-  MEMORY_ORDER_CONSUME = std::memory_order_consume,
+-  MEMORY_ORDER_ACQUIRE = std::memory_order_acquire,
+-  MEMORY_ORDER_RELEASE = std::memory_order_release,
+-  MEMORY_ORDER_ACQ_REL = std::memory_order_acq_rel,
+-  MEMORY_ORDER_SEQ_CST = std::memory_order_seq_cst
++  MEMORY_ORDER_RELAXED = static_cast<std::underlying_type<std::memory_order>::type>(std::memory_order_relaxed),
++  MEMORY_ORDER_CONSUME = static_cast<std::underlying_type<std::memory_order>::type>(std::memory_order_consume),
++  MEMORY_ORDER_ACQUIRE = static_cast<std::underlying_type<std::memory_order>::type>(std::memory_order_acquire),
++  MEMORY_ORDER_RELEASE = static_cast<std::underlying_type<std::memory_order>::type>(std::memory_order_release),
++  MEMORY_ORDER_ACQ_REL = static_cast<std::underlying_type<std::memory_order>::type>(std::memory_order_acq_rel),
++  MEMORY_ORDER_SEQ_CST = static_cast<std::underlying_type<std::memory_order>::type>(std::memory_order_seq_cst)
+ };
+
+ template <class T>