refactor: use variant type for result

Author: sangelovic

include/sdbus-c++/Awaitable.h

@@ -33,7 +33,6 @@
 #include <cstdint>
 #include <exception>
 #include <memory>
-#include <optional>
 #include <type_traits>
 #include <variant>
 
@@ -61,8 +60,7 @@ template <typename T>
 struct AwaitableData
 {
     using result_type = std::conditional_t<std::is_void_v<T>, std::monostate, T>;
-    std::optional<result_type> result;
-    std::optional<std::exception_ptr> exception;
+    std::variant<result_type, std::exception_ptr> result;
     std::coroutine_handle<> handle;
     std::atomic<AwaitableState> status{AwaitableState::NotReady};
 };
@@ -89,7 +87,10 @@ template <typename T>
 class Awaitable
 {
 public:
-    explicit Awaitable(std::shared_ptr<AwaitableData<T>> data) : data_(std::move(data)) {};
+    explicit Awaitable(std::shared_ptr<AwaitableData<T>> data)
+        : data_(std::move(data))
+    {
+    }
 
     // Called when the coroutine is co_await'ed. Returns true if the coroutine should be suspended.
     [[nodiscard]] bool await_ready() const noexcept
@@ -111,19 +112,13 @@ class Awaitable
     // Called when the coroutine is resumed. Returns the result or throws the exception.
     T await_resume() const
     {
-        if (data_->exception)
-        {
-            std::rethrow_exception(*data_->exception);
-        }
+        if (auto* exception = std::get_if<std::exception_ptr>(&data_->result); exception != nullptr)
+            std::rethrow_exception(*exception);
 
         if constexpr (std::is_void_v<T>)
-        {
             return;
-        }
         else
-        {
-            return std::move(*data_->result);
-        }
+            return std::get<T>(std::move(data_->result));
     }
 
 private:

include/sdbus-c++/ConvenienceApiClasses.inl

@@ -357,34 +357,27 @@ namespace sdbus {
     template <typename... Args>
     Awaitable<awaitable_return_t<Args...>> AsyncMethodInvoker::getResultAsAwaitable()
     {
+        // awaitable_return_t<Args...> will be void for no D-Bus method return value
+        //                                  or T for single D-Bus method return value
+        //                                  or std::tuple<...> for multiple method return values
         auto data = std::make_shared<AwaitableData<awaitable_return_t<Args...>>>();
-        uponReplyInvoke(
-            [data](std::optional<Error> error, Args... args)
-            {
-                if (error)
-                {
-                    data->exception = std::make_exception_ptr(*std::move(error));
-                }
+
+        uponReplyInvoke([data](std::optional<Error> error, Args... args)
+        {
+            if (!error)
+                if constexpr (!std::is_void_v<awaitable_return_t<Args...>>)
+                    data->result = {std::move(args)...};
                 else
-                {
-                    if constexpr (!std::is_void_v<awaitable_return_t<Args...>>)
-                    {
-                        data->result.emplace(std::move(args)...);
-                    }
-                    else
-                    {
-                        data->result = std::monostate{};
-                    }
-                }
+                    data->result = std::monostate{};
+            else
+                data->result = std::make_exception_ptr(*std::move(error));
 
-                auto previous = data->status.exchange(AwaitableState::Completed, std::memory_order_acq_rel);
-                if (previous == AwaitableState::Waiting)
-                {
-                    data->handle.resume();
-                }
-            });
+            auto previous = data->status.exchange(AwaitableState::Completed, std::memory_order_acq_rel);
+            if (previous == AwaitableState::Waiting)
+                data->handle.resume();
+        });
 
-        return Awaitable<awaitable_return_t<Args...>>(data);
+        return Awaitable(data);
     }
 
     /*** ---------------- ***/

src/Proxy.cpp

@@ -192,19 +192,13 @@ Awaitable<MethodReply> Proxy::callMethodAsync(const MethodCall& message, uint64_
     async_reply_handler asyncReplyCallback = [data](MethodReply reply, std::optional<Error> error) noexcept
     {
         if (!error)
-        {
             data->result = std::move(reply);
-        }
         else
-        {
-            data->exception = std::make_exception_ptr(*std::move(error));
-        }
+            data->result = std::make_exception_ptr(*std::move(error));
 
         auto previous = data->status.exchange(AwaitableState::Completed, std::memory_order_acq_rel);
         if (previous == AwaitableState::Waiting)
-        {
             data->handle.resume();
-        }
     };
 
     (void)Proxy::callMethodAsync(message, std::move(asyncReplyCallback), timeout);