feat: Public Result class encapsulating a result value and a status code

doc/async_model.md

@@ -9,7 +9,7 @@ Open62541++ adapts the well-proven [asynchronous model of (Boost) Asio](https://
 Open62541++ accepts completion tokens as the final argument of asynchronous operations.
 
 ```cpp
-// Function signature of the completion handler: void(opcua::StatusCode, opcua::Variant&)
+// Function signature of the completion handler: void(opcua::Result<opcua::Variant>&)
 template <typename CompletionToken = opcua::DefaultCompletionToken>
 auto opcua::services::readValueAsync(
     opcua::Client& client,
@@ -21,7 +21,7 @@ auto opcua::services::readValueAsync(
 Following completion tokens can be used (and described in more detail below):
 
 - A callback function (object) with the expected completion signature
-- `opcua::useFuture` to return a future object `std::future<T>`
+- `opcua::useFuture` to return a future object `std::future<opcua::Result<T>>`
 - `opcua::useDeferred` to return a callable for deferred execution
 - `opcua::useDetached` to detach the asynchronous operation
 - Custom tokens by providing template specializations for `opcua::AsyncResult`
@@ -31,31 +31,29 @@ Following completion tokens can be used (and described in more detail below):
 If the user passes a function object as the completion token, the asynchronous operation behaves as previously described: the operation begins, and when the operation completes the result is passed to the callback. The callback function must match the expected signature:
 
 ```cpp
-void(opcua::StatusCode code)              // for void result types
-void(opcua::StatusCode code, T& result);  // for non-void result types
-void(opcua::StatusCode code, T result);   // for non-void result types (trivially-copyable)
+void(opcua::Result<T>);   // for void and non-void, trivially-copyable value types
+void(opcua::Result<T>&);  // for non-void value types
 ```
 
 ```cpp
 opcua::services::readValueAsync(
     client,
     id,
-    [](opcua::StatusCode code, opcua::Variant& result) {
+    [](opcua::Result<opcua::Variant>& result) {
         // ...
     }
 );
 ```
 
-The status code `opcua::StatusCode` needs to be checked to determine the validity of the result.
 The callback is executed within the client's or server's event loop. Please make sure not to block the event loop. Waiting for asynchronous results within the callback will block the further execution of the event loop.
 
 ### Future completion token
 
-The special token `opcua::useFuture` can be passed as completion token to return a future object `std::future<T>`.
+The special token `opcua::useFuture` can be passed as completion token to return a future object `std::future<opcua::Result<T>>`.
 
 ```cpp
-std::future<opcua::Variant> future = opcua::services::readValueAsync(client, id, opcua::useFuture);
-auto result = future.get();  // throws an exception if an error occurred
+std::future<opcua::Result<opcua::Variant>> future = opcua::services::readValueAsync(client, id, opcua::useFuture);
+auto value = future.get().value();  // throws an exception if an error occurred
 ```
 
 ### Deferred completion token
@@ -66,7 +64,7 @@ The token `opcua::useDeferred` is used to indicate that an asynchronous operatio
 auto func = opcua::services::readValueAsync(client, id, opcua::useDeferred);
 
 // start operation with provided completion token
-func([](auto code, auto&& result) {
+func([](auto&& result) {
     // ...
 });
 ```
@@ -90,14 +88,14 @@ struct PrintResultToken {};
 
 namespace opcua {
 
-template <typename Result>
-struct AsyncResult<PrintResultToken, Result> {
+template <typename T>
+struct AsyncResult<PrintResultToken, T> {
     template <typename Initiation, typename CompletionHandler, typename... Args>
     static void initiate(Initiation&& initiation, PrintResultToken, Args&&... args) {
         std::invoke(
             std::forward<Initiation>(initiation),
-            [](StatusCode code, auto& result) {
-                std::cout << "Async operation completed: code=" << code << ", result=" << result << std::endl;
+            [](opcua::Result<T>& result) {
+                std::cout << "Async operation completed: code=" << result.code() << ", value=" << result.value() << std::endl;
             },
             std::forward<Args>(args)...
         );
@@ -107,12 +105,9 @@ struct AsyncResult<PrintResultToken, Result> {
 }
 ```
 
-The `Result` template parameter specifies the result type of the asynchronous operation.
-If `Result` is `void`, the expected signature of the completion handler is `void(opcua::StatusCode)`, otherwise it is `void(opcua::StatusCode, Result&)`.
-
 The trait's `opcua::AsyncResult::initiate` member function is called with three arguments:
 1. A function object that launches the async operation (initiating function)
-2. A concrete completion handler with the signature `void(opcua::StatusCode, Result)`
+2. A concrete completion handler with the signature `void(opcua::Result<T>)` or `void(opcua::Result<T>&)`
 3. Any additional arguments for the function object
 
 Please have a look at implementations in @ref async.h for further details.

examples/method/client_method_async.cpp

@@ -29,8 +29,8 @@ int main() {
         future.wait();
 
         std::cout << "Future ready, get method output\n";
-        auto output = future.get();
-        std::cout << output.at(0).getScalar<opcua::String>() << std::endl;
+        auto result = future.get();
+        std::cout << result.value().at(0).getScalar<opcua::String>() << std::endl;
     }
 
     // Asynchronously call method (callback variant)
@@ -40,9 +40,10 @@ int main() {
             objNode.getNodeId(),
             greetMethodNode.getNodeId(),
             {opcua::Variant::fromScalar("Callback World")},
-            [](opcua::StatusCode code, std::vector<opcua::Variant>& output) {
-                std::cout << "Callback with status code " << code << ", get method output\n";
-                std::cout << output.at(0).getScalar<opcua::String>() << std::endl;
+            [](const opcua::Result<std::vector<opcua::Variant>>& result) {
+                std::cout
+                    << "Callback with status code " << result.code() << ", get method output\n";
+                std::cout << result.value().at(0).getScalar<opcua::String>() << std::endl;
             }
         );
     }

include/open62541pp/ErrorHandling.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <new>
 #include <stdexcept>
 
 #include "open62541pp/detail/open62541/common.h"
@@ -69,6 +70,8 @@ namespace detail {
         }
     } catch (const BadStatus& e) {
         return e.code();
+    } catch (const std::bad_alloc& /*e*/) {
+        return UA_STATUSCODE_BADOUTOFMEMORY;
     } catch (...) {
         return UA_STATUSCODE_BADINTERNALERROR;
     }