namespace version bump (#541)

Bumping the inline namespace version to v2 to avoid ODR violations.
The pre_exit code remains at v1 (it must be bumped more carefully).
The portable default executor is moving to v2 - which may lead to more than one thread pool for the portable instance. Pinning the version here is more difficult.
Removed dead reset() operations in future shared_base
Documented (and assert) precondition that future::exception() is only invoked on a ready exception.
Made more of the tuple meta-facilities public to avoid detail:: namespace usage in unit tests.
Restructured unit tests to avoid sleep-wait-loops.

README.md

@@ -74,6 +74,7 @@ cmake -S . -B ../BUILD -GNinja -DCMAKE_CXX_STANDARD=17 -DCMAKE_BUILD_TYPE=Releas
 If you organize the build directory into subdirectories you can support multiple configurations.
 
 ```
+rm -rf ../builds/portable
 cmake -S . -B ../builds/portable -GXcode -DCMAKE_CXX_STANDARD=17 -DBUILD_TESTING=ON -DSTLAB_TASK_SYSTEM=portable -DCMAKE_OSX_DEPLOYMENT_TARGET=14.4  -DCMAKE_OSX_DEPLOYMENT_TARGET=macosx14.4
 ```
 

stlab/concurrency/await.hpp

@@ -31,10 +31,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -203,18 +200,16 @@ template <class T>
 }
 
 template <class T>
-[[deprecated("Use await_for instead.")]] auto blocking_get(future<T> x,
-                                                           const std::chrono::nanoseconds& timeout)
-    -> decltype(x.get_try()) {
+[[deprecated("Use await_for instead.")]] auto blocking_get(
+    future<T> x, const std::chrono::nanoseconds& timeout) -> decltype(x.get_try()) {
     return blocking_get_for(std::move(x), timeout).get_try();
 }
 
 /**************************************************************************************************/
 
-} // namespace v1
+} // namespace STLAB_VERSION_NAMESPACE()
+} // namespace stlab
 
 /**************************************************************************************************/
 
-} // namespace stlab
-
 #endif // STLAB_CONCURRENCY_AWAIT_HPP

stlab/concurrency/channel.hpp

@@ -9,6 +9,8 @@
 #ifndef STLAB_CONCURRENCY_CHANNEL_HPP
 #define STLAB_CONCURRENCY_CHANNEL_HPP
 
+#include <stlab/config.hpp>
+
 #include <algorithm>
 #include <array>
 #include <atomic>
@@ -33,10 +35,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -192,7 +191,9 @@ using avoid = std::conditional_t<std::is_same<void, T>::value, avoid_, T>;
 /**************************************************************************************************/
 
 template <typename F, std::size_t... I, typename... T>
-auto invoke_(F&& f, std::tuple<std::variant<T, std::exception_ptr>...>& t, std::index_sequence<I...>) {
+auto invoke_(F&& f,
+             std::tuple<std::variant<T, std::exception_ptr>...>& t,
+             std::index_sequence<I...>) {
     return std::forward<F>(f)(std::move(std::get<I>(t))...);
 }
 
@@ -484,14 +485,12 @@ struct round_robin_queue_strategy {
     queue_t _queue;
 
     bool empty() const {
-        return get_i(
-            _queue, _index, [](const auto& c) { return c.empty(); }, true);
+        return get_i(_queue, _index, [](const auto& c) { return c.empty(); }, true);
     }
 
     auto front() {
         assert(!empty() && "front on an empty container is a very bad idea!");
-        return std::make_tuple(get_i(
-            _queue, _index, [](auto& c) { return c.front(); }, item_t{}));
+        return std::make_tuple(get_i(_queue, _index, [](auto& c) { return c.front(); }, item_t{}));
     }
 
     void pop_front() {
@@ -546,8 +545,8 @@ struct unordered_queue_strategy {
     auto front() {
         assert(!empty() && "front on an empty container is a very bad idea!");
         _index = tuple_find(_queue, [](const auto& c) { return !c.empty(); });
-        return std::make_tuple(get_i(
-            _queue, _index, [](auto& c) { return std::move(c.front()); }, item_t{}));
+        return std::make_tuple(
+            get_i(_queue, _index, [](auto& c) { return std::move(c.front()); }, item_t{}));
     }
 
     void pop_front() {
@@ -1705,10 +1704,7 @@ struct function_process<R(Args...)> {
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/

stlab/concurrency/default_executor.hpp

@@ -40,10 +40,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -500,10 +497,7 @@ constexpr auto high_executor = detail::executor_type<detail::executor_priority::
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/

stlab/concurrency/executor_base.hpp

@@ -9,6 +9,8 @@
 #ifndef STLAB_CONCURRENCY_EXECUTOR_BASE_HPP
 #define STLAB_CONCURRENCY_EXECUTOR_BASE_HPP
 
+#include <stlab/config.hpp>
+
 #include <chrono>
 #include <functional>
 
@@ -18,12 +20,10 @@
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
-/**************************************************************************************************/
-
 using executor_t = std::function<void(stlab::task<void() noexcept>)>;
 
 /*
@@ -82,10 +82,7 @@ executor_task_pair<F> operator&(F&& f, executor e) {
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/

stlab/concurrency/future.hpp

@@ -38,10 +38,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -274,8 +271,6 @@ struct shared_base<T, enable_if_copyable<T>> : std::enable_shared_from_this<shar
 
     explicit shared_base(executor_t s) : _executor(std::move(s)) {}
 
-    void reset() { _then.clear(); } // NEEDS MUTEX
-
     template <typename F>
     auto recover(future<T>&& p, F&& f) {
         return recover(std::move(p), _executor, std::forward<F>(f));
@@ -389,8 +384,6 @@ struct shared_base<T, enable_if_not_copyable<T>> : std::enable_shared_from_this<
 
     explicit shared_base(executor_t s) : _executor(std::move(s)) {}
 
-    void reset() { _then.second = task<void() noexcept>{}; }
-
     template <typename F>
     auto recover(future<T>&& p, F&& f) {
         return recover(std::move(p), _executor, std::forward<F>(f));
@@ -474,8 +467,6 @@ struct shared_base<void> : std::enable_shared_from_this<shared_base<void>> {
 
     explicit shared_base(executor_t s) : _executor(std::move(s)) {}
 
-    void reset() { _then.clear(); }
-
     template <typename F>
     auto recover(future<result_type>&& p, F&& f) {
         return recover(std::move(p), _executor, std::forward<F>(f));
@@ -750,7 +741,11 @@ class STLAB_NODISCARD() future<T, enable_if_copyable<T>> {
         return _p->_exception ? std::optional<std::exception_ptr>{_p->_exception} : std::nullopt;
     }
 
-    std::exception_ptr exception() const& { return _p->_exception; }
+    // Precondition: is_ready()
+    std::exception_ptr exception() const& {
+        assert(is_ready());
+        return _p->_exception;
+    }
 };
 
 /**************************************************************************************************/
@@ -897,7 +892,11 @@ class STLAB_NODISCARD() future<void, void> {
         return _p->_exception ? std::optional<std::exception_ptr>{_p->_exception} : std::nullopt;
     }
 
-    std::exception_ptr exception() const& { return _p->_exception; }
+    // Precondition: is_ready()
+    std::exception_ptr exception() const& {
+        assert(is_ready());
+        return _p->_exception;
+    }
 };
 
 /**************************************************************************************************/
@@ -1001,7 +1000,11 @@ class STLAB_NODISCARD() future<T, enable_if_not_copyable<T>> {
         return _p->_exception ? std::optional<std::exception_ptr>{_p->_exception} : std::nullopt;
     }
 
-    std::exception_ptr exception() const& { return _p->_exception; }
+    // Precondition: is_ready()
+    std::exception_ptr exception() const& {
+        assert(is_ready());
+        return _p->_exception;
+    }
 };
 
 template <typename Sig, typename E, typename F>
@@ -1233,7 +1236,7 @@ template <typename E, typename F, typename... Ts>
 auto when_all(E executor, F f, future<Ts>... args) {
     using vt_t = voidless_tuple<Ts...>;
     using opt_t = optional_placeholder_tuple<Ts...>;
-    using result_t = decltype(detail::apply_tuple(std::declval<F>(), std::declval<vt_t>()));
+    using result_t = decltype(apply_ignore_placeholders(std::declval<F>(), std::declval<vt_t>()));
 
     auto shared = std::make_shared<detail::when_all_shared<F, opt_t>>();
     auto p = package<result_t()>(
@@ -1816,10 +1819,7 @@ auto shared_base<void>::recover(future<result_type>&& p, E executor, F&& f) {
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/

stlab/concurrency/immediate_executor.hpp

@@ -9,17 +9,17 @@
 #ifndef STLAB_CONCURRENCY_IMMEDIATE_EXECUTOR_HPP
 #define STLAB_CONCURRENCY_IMMEDIATE_EXECUTOR_HPP
 
+#include <stlab/config.hpp>
+
 #include <type_traits>
 
 /**************************************************************************************************/
 
 namespace stlab {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
-inline namespace v1 {
-/**************************************************************************************************/
-
 namespace detail {
 
 /**************************************************************************************************/
@@ -41,10 +41,7 @@ constexpr auto immediate_executor = detail::immediate_executor_type{};
 
 /**************************************************************************************************/
 
-} // namespace v1
-
-/**************************************************************************************************/
-
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/

stlab/concurrency/main_executor.hpp

@@ -35,10 +35,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -170,8 +167,11 @@ struct main_executor_type {
 
 constexpr auto main_executor = detail::main_executor_type{};
 
-} // namespace v1
+/**************************************************************************************************/
 
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
+/**************************************************************************************************/
+
 #endif // STLAB_CONCURRENCY_MAIN_EXECUTOR_HPP

stlab/concurrency/ready_future.hpp

@@ -9,6 +9,8 @@
 #ifndef STLAB_CONCURRENCY_READY_FUTURE_HPP
 #define STLAB_CONCURRENCY_READY_FUTURE_HPP
 
+#include <stlab/config.hpp>
+
 #include <exception>
 #include <type_traits>
 #include <utility>
@@ -18,10 +20,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-
-/**************************************************************************************************/
-
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -72,10 +71,9 @@ future<T> make_exceptional_future(std::exception_ptr error, E executor) {
 
 /**************************************************************************************************/
 
-} // namespace v1
+} // namespace STLAB_VERSION_NAMESPACE()
+} // namespace stlab
 
 /**************************************************************************************************/
 
-} // namespace stlab
-
 #endif // STLAB_CONCURRENCY_READY_FUTURE_HPP

stlab/concurrency/serial_queue.hpp

@@ -11,6 +11,8 @@
 
 /**************************************************************************************************/
 
+#include <stlab/config.hpp>
+
 #include <deque>
 #include <mutex>
 #include <tuple>
@@ -29,7 +31,7 @@
 /**************************************************************************************************/
 
 namespace stlab {
-inline namespace v1 {
+inline namespace STLAB_VERSION_NAMESPACE() {
 
 /**************************************************************************************************/
 
@@ -164,7 +166,7 @@ class serial_queue_t {
 
 /**************************************************************************************************/
 
-} // namespace v1
+} // namespace STLAB_VERSION_NAMESPACE()
 } // namespace stlab
 
 /**************************************************************************************************/