[STLab] upgrade version to 1.7.1

recipes/stlab/all/conandata.yml

@@ -1,16 +1,4 @@
 sources:
-  "1.6.2":
-    url: "https://github.com/stlab/libraries/archive/v1.6.2.tar.gz"
-    sha256: "d0369d889c7bf78068d0c4f4b5125d7e9fe9abb0ad7a3be35bf13b6e2c271676"
-  "1.5.6":
-    url: "https://github.com/stlab/libraries/archive/refs/tags/v1.5.6.tar.gz"
-    sha256: "a6b788848be637b6d6c471de76c38486789e708997648e9b9731fdb5a631030c"
-  "1.5.5":
-    url: "https://github.com/stlab/libraries/archive/v1.5.5.tar.gz"
-    sha256: "30ec5a36b4c074feac72a1b9a744f0b279010e18c7bb04bbdc5d44fe9eaf5ad8"
-  "1.5.4":
-    url: "https://github.com/stlab/libraries/archive/v1.5.4.tar.gz"
-    sha256: "87306f58f6614f4a1ca54dda52fedff7e610d3b3dae035829657bac77bc33640"
-  "1.5.2":
-    url: https://github.com/stlab/libraries/archive/v1.5.2.tar.gz
-    sha256: a82eb013e51d0bb3ee2050f0eda31e11997cb4ca74d2abfdc2c8249c5c67c9fb
+  "1.7.1":
+    url: "https://github.com/stlab/libraries/archive/refs/tags/v1.7.1.tar.gz"
+    sha256: "0160b5f7be7d423100a9a8b205a99285b106dd438f806978028a82b9f01c6b64"

recipes/stlab/all/conanfile.py

@@ -1,180 +1,179 @@
-from conans import ConanFile, tools
-from conans.tools import Version
-from conans.errors import ConanInvalidConfiguration
 import os
 
+from conan import ConanFile
+from conan.errors import ConanInvalidConfiguration
+from conan.tools.build import check_min_cppstd, cross_building
+from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
+from conan.tools.files import copy, get, rm, rmdir
+from conan.tools.microsoft import check_min_vs, is_msvc
+from conan.tools.scm import Version
+
+required_conan_version = ">=1.52.0"
+
+
 class Stlab(ConanFile):
     name = 'stlab'
     description = 'The Software Technology Lab libraries.'
     url = 'https://github.com/conan-io/conan-center-index'
     homepage = 'https://github.com/stlab/libraries'
     license = 'BSL-1.0'
-    topics = 'conan', 'c++', 'concurrency', 'futures', 'channels'
-
-    settings = "arch", "os", "compiler", "build_type", 
-
+    topics = 'concurrency', 'futures', 'channels'
+    settings = "arch", "os", "compiler", "build_type",
     options = {
-        "boost_optional": [True, False],
-        "boost_variant": [True, False],
-        "coroutines": [True, False],
-        "task_system": ["portable", "libdispatch", "emscripten", "pnacl", "windows", "auto"],
+        "with_boost": [True, False],
+        "no_std_coroutines": [True, False],
+        "future_coroutines": [True, False],
+        "task_system": ["portable", "libdispatch", "emscripten", "pnacl", "windows"],
+        "thread_system": ["win32", "pthread", "pthread-emscripten", "pthread-apple", "none"],
     }
-
     default_options = {
-        "boost_optional": False,
-        "boost_variant": False,
-        "coroutines": False,
-        "task_system": "auto",
+        "with_boost": False,
+        "no_std_coroutines": True,
+        "future_coroutines": False
+        # Handle default value for `thread_system` in `config_options` method
+        # Handle default value for `task_system` in `config_options` method
     }
+    package_type = "header-library"
+    short_paths = True
 
-    no_copy_source = True
-    _source_subfolder = 'source_subfolder'
+    def config_options(self):
+        self.options.thread_system = {"Macos": "pthread-apple",
+                                      "Linux": "pthread",
+                                      "Windows": "win32",
+                                      "Emscripten": "pthread-emscripten"}.get(str(self.settings.os), "none")
+        self.options.task_system = {"Macos": "libdispatch",
+                                    "Windows": "windows"}.get(str(self.settings.os), "portable")
 
-    def _use_boost(self):
-        return self.options.boost_optional or self.options.boost_variant
+    @property
+    def _minimum_cpp_standard(self):
+        return 17
 
-    def _requires_libdispatch(self):
-        # On macOS it is not necessary to use the libdispatch conan package, because the library is 
-        # included in the OS.
-        return self.options.task_system == "libdispatch" and self.settings.os != "Macos"
+    @property
+    def _compilers_minimum_version(self):
+        return {"gcc": "9",
+                "clang": "8",
+                "apple-clang": "13"}
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def build_requirements(self):
+        self.tool_requires("cmake/[>=3.23.3]")
 
     def requirements(self):
-        if self._use_boost():
-            self.requires("boost/1.75.0")
+        if self.options.with_boost:
+            self.requires("boost/1.82.0")
 
-        if self._requires_libdispatch():
+        # On macOS, it is not necessary to use the libdispatch conan package, because the library is
+        # included in the OS.
+        if self.options.task_system == "libdispatch" and self.settings.os != "Macos":
             self.requires("libdispatch/5.3.2")
 
     def source(self):
-        tools.get(**self.conan_data["sources"][self.version])
-        extracted_dir = "libraries-" + self.version
-        os.rename(extracted_dir, self._source_subfolder)
-
-    def _fix_boost_components(self):
-        if self.settings.os != "Macos": return
-        if self.settings.compiler != "apple-clang": return
-        if Version(self.settings.compiler.version) >= "12": return
-
-        #
-        # On Apple we have to force the usage of boost.variant, because Apple's implementation of C++17 is not complete.
-        #
-        self.output.info("Apple-Clang versions less than 12 do not correctly support std::optional or std::variant, so we will use boost::optional and boost::variant instead.")
-        self.options.boost_optional = True
-        self.options.boost_variant = True
-
-    def _default_task_system(self):
-        if self.settings.os == "Macos": 
-            return "libdispatch"
-
-        if self.settings.os == "Windows":
-            return "windows"
-
-        if self.settings.os == "Emscripten":
-            return "emscripten"
-
-        return "portable"
-
-    def _validate_task_system_libdispatch(self):
-        if self.settings.os == "Linux":
-            if self.settings.compiler != "clang":
-                raise ConanInvalidConfiguration("{}/{} task_system=libdispatch needs Clang compiler when using OS: {}. Use Clang compiler or switch to task_system=portable or task_system=auto".format(self.name, self.version, self.settings.os))
-        elif self.settings.os != "Macos":
-            raise ConanInvalidConfiguration("{}/{} task_system=libdispatch is not supported on {}. Try using task_system=auto".format(self.name, self.version, self.settings.os))
-
-    def _validate_task_system_windows(self):
-        if self.settings.os != "Windows":
-            self.output.info("Libdispatch is not supported on {}. The task system is changed to {}.".format(self.settings.os, self.options.task_system))
-            raise ConanInvalidConfiguration("{}/{} task_system=windows is not supported on {}. Try using task_system=auto".format(self.name, self.version, self.settings.os))
-
-    def _validate_task_system_emscripten(self):
-        if self.settings.os != "Emscripten":
-            raise ConanInvalidConfiguration("{}/{} task_system=emscripten is not supported on {}. Try using task_system=auto".format(self.name, self.version, self.settings.os))
+        get(self, **self.conan_data["sources"][self.version], destination=self.source_folder, strip_root=True)
 
     def _validate_task_system(self):
         if self.options.task_system == "libdispatch":
-            self._validate_task_system_libdispatch()
-        elif self.options.task_system == "windows":
-            self._validate_task_system_windows()
-        elif self.options.task_system == "emscripten":
-            self._validate_task_system_emscripten()
+            if self.settings.os == "Linux" and self.settings.compiler != "clang":
+                raise ConanInvalidConfiguration(f"{self.ref} task_system=libdispatch needs Clang compiler when using OS: {self.settings.os}."
+                                                f" Use Clang compiler or switch to task_system=portable")
+            elif self.settings.os != "Macos":
+                raise ConanInvalidConfiguration(f"{self.ref} task_system=libdispatch is not supported on {self.settings.os}")
+        elif self.options.task_system == "windows" and self.settings.os != "Windows":
+            raise ConanInvalidConfiguration(f"{self.ref} task_system=windows is not supported on {self.settings.os}")
+
+    def _validate_thread_system(self):
+        if any([self.options.thread_system == "pthread-apple" and self.settings.os != "Macos",
+                self.options.thread_system == "pthread" and self.settings.os != "Linux",
+                self.options.thread_system == "win32" and self.settings.os != "Windows",
+                self.options.thread_system == "pthread-emscripten" and self.settings.os != "Emscripten"]):
+            raise ConanInvalidConfiguration(f"{self.ref} thread_system={self.options.thread_system} is not supported on {self.settings.os}")
 
     def _validate_boost_components(self):
-        if self.settings.os != "Macos": return
-        if self.settings.compiler != "apple-clang": return
-        if Version(self.settings.compiler.version) >= "12": return
-        if self.options.boost_optional and self.options.boost_variant: return
-        #
-        # On Apple we have to force the usage of boost.variant, because Apple's implementation of C++17 
-        # is not complete.
-        #
-        msg = "Apple-Clang versions less than 12 do not correctly support std::optional or std::variant, so we will use boost::optional and boost::variant instead. "
-        if not self.options.boost_optional and not self.options.boost_variant:
-            msg += "Try -o boost_optional=True -o boost_variant=True"
-        elif not self.options.boost_optional:
-            msg += "Try -o boost_optional=True."
+        if not any([self.settings.os != "Macos", self.settings.compiler != "apple-clang",
+                    Version(str(self.settings.compiler.version)) >= "12", self.options.with_boost]):
+            # On Apple we have to force the usage of boost.variant and boost.optional, because Apple's implementation of C++17
+            # is not complete.
+            raise ConanInvalidConfiguration(
+                f"Compiler Apple-Clang < 12 versions do not correctly support std::optional or std::variant, "
+                f"so we will use boost::optional and boost::variant instead. Try -o {self.ref}:with_boost=True.")
+
+    def _validate_min_compiler_version(self):
+        if is_msvc(self):
+            check_min_vs(self, "192")
         else:
-            msg += "Try -o boost_variant=True."
-
-        raise ConanInvalidConfiguration(msg)
+            minimum_version = self._compilers_minimum_version.get(str(self.settings.compiler), False)
+            if not minimum_version:
+                self.output.warn(f"{self.ref} requires C++{self._minimum_cpp_standard}. "
+                                 f"Your compiler is unknown. Assuming it supports C++{self._minimum_cpp_standard}.")
+            elif Version(str(self.settings.compiler.version)) < minimum_version:
+                raise ConanInvalidConfiguration(f"{self.ref} requires C++{self._minimum_cpp_standard}, "
+                                                f"which your compiler does not support.")
+            if self.settings.compiler == "clang" and str(self.settings.compiler.version) in ("13", "14"):
+                raise ConanInvalidConfiguration(
+                    f"{self.ref} currently does not work with Clang {self.settings.compiler.version} on CCI, it enters "
+                    f"in an infinite build loop (smells like a compiler bug). Contributions are welcomed!")
 
     def validate(self):
         if self.settings.compiler.get_safe("cppstd"):
-            tools.check_min_cppstd(self, '17')
-
-        if self.settings.compiler == "gcc" and Version(self.settings.compiler.version) < "9":
-            raise ConanInvalidConfiguration("Need GCC >= 9")
-
-        if self.settings.compiler == "clang" and Version(self.settings.compiler.version) < "8":
-            raise ConanInvalidConfiguration("Need Clang >= 8")
-
-        if self.settings.compiler == "Visual Studio" and Version(self.settings.compiler.version) < "15.8":
-            raise ConanInvalidConfiguration("Need Visual Studio >= 2017 15.8 (MSVC 19.15)")
-
-        # Actually, we want *at least* 15.8 (MSVC 19.15), but we cannot check this for now with Conan.
-        if self.settings.compiler == "msvc" and Version(self.settings.compiler.version) < "19.15":
-            raise ConanInvalidConfiguration("Need msvc >= 19.15")
+            check_min_cppstd(self, self._minimum_cpp_standard)
 
+        self._validate_min_compiler_version()
         self._validate_task_system()
+        self._validate_thread_system()
         self._validate_boost_components()
 
     def configure(self):
-        if self.options.task_system == "auto":
-            self.options.task_system = self._default_task_system()
-        self.output.info("Stlab Task System: {}.".format(self.options.task_system))
+        self.output.info("STLab With Boost: {}.".format(self.options.with_boost))
+        self.output.info("STLab Future Coroutines: {}.".format(self.options.future_coroutines))
+        self.output.info("STLab No Standard Coroutines: {}.".format(self.options.no_std_coroutines))
+        self.output.info("STLab Task System: {}.".format(self.options.task_system))
+        self.output.info("STLab Thread System: {}.".format(self.options.thread_system))
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables['BUILD_TESTING'] = not self.conf.get("tools.build:skip_test", default=True, check_type=bool)
+        tc.variables["STLAB_USE_BOOST_CPP17_SHIMS"] = self.options.with_boost
+        tc.variables["STLAB_NO_STD_COROUTINES"] = self.options.no_std_coroutines
+        tc.variables["STLAB_THREAD_SYSTEM"] = self.options.thread_system
+        tc.variables["STLAB_TASK_SYSTEM"] = self.options.task_system
+        if cross_building(self):
+            tc.variables["STLAB_HAVE_FUNCTIONAL_VARIANT_OPTIONAL"] = True
+        tc.generate()
+
+        tc = CMakeDeps(self)
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
 
     def package(self):
-        self.copy("*LICENSE", dst="licenses", keep_path=False)
-        self.copy("stlab/*", src=self._source_subfolder, dst='include/')
+        copy(self, pattern="LICENSE", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
+        cmake = CMake(self)
+        cmake.install()
+
+        rmdir(self, os.path.join(self.package_folder, "share"))
+        rm(self, "msvcp*.dll", os.path.join(self.package_folder, "bin"))
+        rm(self, "concrt*.dll", os.path.join(self.package_folder, "bin"))
+        rm(self, "vcruntime*.dll", os.path.join(self.package_folder, "bin"))
 
     def package_id(self):
-        self.info.header_only()
-        self.info.options.boost_optional = "ANY"
-        self.info.options.boost_variant = "ANY"
+        # TODO: is header only but needs a header modified by cmake
+        # self.info.settings.clear()
+        # self.info.header_only()
+        pass
 
     def package_info(self):
-        coroutines_value = 1 if self.options.coroutines else 0
+        future_coroutines_value = 1 if self.options.future_coroutines else 0
 
         self.cpp_info.defines = [
-            'STLAB_FUTURE_COROUTINES={}'.format(coroutines_value)
+            'STLAB_FUTURE_COROUTINES={}'.format(future_coroutines_value)
         ]
 
-        if self.options.boost_optional:
-            self.cpp_info.defines.append("STLAB_FORCE_BOOST_OPTIONAL")
-
-        if self.options.boost_variant:
-            self.cpp_info.defines.append("STLAB_FORCE_BOOST_VARIANT")
-
-        if self.options.task_system == "portable":
-            self.cpp_info.defines.append("STLAB_FORCE_TASK_SYSTEM_PORTABLE")
-        elif self.options.task_system == "libdispatch":
-            self.cpp_info.defines.append("STLAB_FORCE_TASK_SYSTEM_LIBDISPATCH")
-        elif self.options.task_system == "emscripten":
-            self.cpp_info.defines.append("STLAB_FORCE_TASK_SYSTEM_EMSRIPTEN")  #Note: there is a typo in Stlab Cmake.
-            self.cpp_info.defines.append("STLAB_FORCE_TASK_SYSTEM_EMSCRIPTEN") #Note: for typo fix in later versions
-        elif self.options.task_system == "pnacl":
-            self.cpp_info.defines.append("STLAB_FORCE_TASK_SYSTEM_PNACL")
-        elif self.options.task_system == "windows":
-            self.cpp_info.defines.append("STLAB_FORCE_TASK_SYSTEM_WINDOWS")
+        if self.settings.os == "Windows":
+            self.cpp_info.defines = ['NOMINMAX']
 
         if self.settings.os == "Linux":
             self.cpp_info.system_libs = ["pthread"]

recipes/stlab/all/test_package/CMakeLists.txt

@@ -1,10 +1,10 @@
-cmake_minimum_required(VERSION 3.1)
-project(test_package)
+cmake_minimum_required(VERSION 3.15)
 
-set(CMAKE_CXX_STANDARD 17)
-
-include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup()
+project(test_package CXX) # if the project uses c++
+find_package(stlab REQUIRED CONFIG)
 
 add_executable(${PROJECT_NAME} test_package.cpp)
-target_link_libraries(${PROJECT_NAME} ${CONAN_LIBS})
+target_compile_definitions( ${PROJECT_NAME} INTERFACE $<$<CXX_COMPILER_ID:MSVC>:NOMINMAX> )
+target_link_libraries(${PROJECT_NAME} PRIVATE stlab::stlab)
+target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_17)
+

recipes/stlab/all/test_package/conanfile.py

@@ -1,17 +1,26 @@
-from conans import ConanFile, CMake, tools
 import os
 
+from conan import ConanFile
+from conan.tools.build import can_run
+from conan.tools.cmake import cmake_layout, CMake
+
 
 class TestPackageConan(ConanFile):
     settings = "os", "compiler", "build_type", "arch"
-    generators = "cmake"
+    generators = "CMakeDeps", "CMakeToolchain", "VirtualRunEnv"
+
+    def requirements(self):
+        self.requires(self.tested_reference_str)
+
+    def layout(self):
+        cmake_layout(self)
 
     def build(self):
         cmake = CMake(self)
         cmake.configure()
         cmake.build()
 
     def test(self):
-        if not tools.cross_building(self.settings):
-            bin_path = os.path.join("bin", "test_package")
-            self.run(bin_path, run_environment=True)
+        if can_run(self):
+            bin_path = os.path.join(self.cpp.build.bindirs[0], "test_package")
+            self.run(bin_path, env="conanrun")

recipes/stlab/all/test_package/test_package.cpp

@@ -16,6 +16,8 @@ int main() {
     while (!f.get_try()) { this_thread::sleep_for(chrono::milliseconds(1)); }
 
     cout << "The answer is " << *f.get_try() << "\n";
+
+    stlab::pre_exit();
 }
 
 /*