replaced AsyncRequest with Future class

examples/client.cpp

@@ -33,8 +33,7 @@ int main(int argc, char** argv) {
         alpha::ResourceHandle resource =
             client.makeResourceHandle(g_address, g_provider_id);
 
-        int32_t result;
-        resource.computeSum(32, 54, &result);
+        int32_t result = resource.computeSum(32, 54).wait();
 
     } catch(const alpha::Exception& ex) {
         std::cerr << ex.what() << std::endl;

include/alpha/Future.hpp

@@ -0,0 +1,84 @@
+/*
+ * (C) 2024 The University of Chicago
+ *
+ * See COPYRIGHT in top-level directory.
+ */
+#ifndef __ALPHA_FUTURE_HPP
+#define __ALPHA_FUTURE_HPP
+
+#include <alpha/Exception.hpp>
+#include <alpha/Result.hpp>
+#include <thallium.hpp>
+#include <memory>
+#include <functional>
+
+namespace alpha {
+
+/**
+ * @brief Future objects are used to keep track of
+ * on-going asynchronous operations.
+ */
+template<typename T, typename Wrapper = T>
+class Future {
+
+    public:
+
+    /**
+     * @brief Copy constructor.
+     */
+    Future() = default;
+
+    /**
+     * @brief Copy constructor.
+     */
+    Future(const Future& other) = default;
+
+    /**
+     * @brief Move constructor.
+     */
+    Future(Future&& other) = default;
+
+    /**
+     * @brief Copy-assignment operator.
+     */
+    Future& operator=(const Future& other) = default;
+
+    /**
+     * @brief Move-assignment operator.
+     */
+    Future& operator=(Future&& other) = default;
+
+    /**
+     * @brief Destructor.
+     */
+    ~Future() = default;
+
+    /**
+     * @brief Wait for the request to complete.
+     */
+    T wait() {
+        Result<Wrapper> result = m_resp.wait();
+        return std::move(result).valueOrThrow();
+    }
+
+    /**
+     * @brief Test if the request has completed, without blocking.
+     */
+    bool completed() const {
+        return m_resp.received();
+    }
+
+    /**
+     * @brief Constructor.
+     */
+    Future(thallium::async_response resp)
+    : m_resp(std::move(resp)) {}
+
+    private:
+
+    thallium::async_response m_resp;
+};
+
+}
+
+#endif

include/alpha/ResourceHandle.hpp

@@ -12,12 +12,10 @@
 #include <nlohmann/json.hpp>
 #include <alpha/Client.hpp>
 #include <alpha/Exception.hpp>
-#include <alpha/AsyncRequest.hpp>
+#include <alpha/Future.hpp>
 
 namespace alpha {
 
-namespace tl = thallium;
-
 class Client;
 class ResourceHandleImpl;
 
@@ -80,12 +78,10 @@ class ResourceHandle {
      *
      * @param[in] x first integer
      * @param[in] y second integer
-     * @param[out] result result
-     * @param[out] req request for a non-blocking operation
+     *
+     * @return a Future<int32_t> that can be awaited to get the result.
      */
-    void computeSum(int32_t x, int32_t y,
-                    int32_t* result = nullptr,
-                    AsyncRequest* req = nullptr) const;
+    Future<int32_t> computeSum(int32_t x, int32_t y) const;
 
     private:
 

include/alpha/Result.hpp

@@ -1,11 +1,12 @@
 /*
- * (C) 2020 The University of Chicago
+ * (C) 2024 The University of Chicago
  *
  * See COPYRIGHT in top-level directory.
  */
 #ifndef __ALPHA_RESULT_HPP
 #define __ALPHA_RESULT_HPP
 
+#include <thallium/serialization/stl/string.hpp>
 #include <alpha/Exception.hpp>
 #include <string>
 
@@ -30,13 +31,42 @@ namespace alpha {
 template<typename T>
 class Result {
 
+    template<typename U>
+    friend class Result;
+
     public:
 
     Result() = default;
-    Result(Result&&) = default;
-    Result(const Result&) = default;
-    Result& operator=(Result&&) = default;
-    Result& operator=(const Result&) = default;
+
+    template<typename U>
+    Result(Result<U>&& other)
+    : m_success{other.m_success}
+    , m_error{std::move(other.m_error)}
+    , m_value{std::move(other.m_value)} {}
+
+    template<typename U>
+    Result(const Result<U>& other)
+    : m_success{other.m_success}
+    , m_error{other.m_error}
+    , m_value{other.m_value} {}
+
+    template<typename U>
+    Result& operator=(Result<U>&& other) {
+        if(this == reinterpret_cast<decltype(this)>(&other)) return *this;
+        m_success = other.m_success;
+        m_error   = std::move(other.m_error);
+        m_value   = std::move(other.m_value);
+        return *this;
+    }
+
+    template<typename U>
+    Result& operator=(const Result<U>& other) {
+        if(this == reinterpret_cast<decltype(this)>(&other)) return *this;
+        m_success = other.m_success;
+        m_error   = other.m_error;
+        m_value   = other.m_value;
+        return *this;
+    }
 
     /**
      * @brief Whether the request succeeded.

src/CMakeLists.txt

@@ -5,8 +5,7 @@ set (server-src-files
 
 set (client-src-files
      Client.cpp
-     ResourceHandle.cpp
-     AsyncRequest.cpp)
+     ResourceHandle.cpp)
 
 set (dummy-src-files
      dummy/DummyBackend.cpp)