Changeset 0f43be5 in mainline

Timestamp:

2019-07-01T13:19:05Z (5 years ago)

Author:

Jaroslav Jindrak <dzejrou@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0d299c93

Parents:

396b234

Message:

cpp: implemented promise and future for references

Location:

uspace/lib/cpp/include/__bits/thread

Files:

• future.hpp (modified) (3 diffs)
• promise.hpp (modified) (9 diffs)

uspace/lib/cpp/include/__bits/thread/future.hpp

@@ -192 +192 @@
 
     template<class R>
-    class future<R&>: public aux::future_base<R&>
+    class future<R&>: public aux::future_base<R*>
     {
         public:
             future() noexcept
-                : aux::future_base<R&>{}
+                : aux::future_base<R*>{}
             { /* DUMMY BODY */ }
 
@@ -202 +202 @@
 
             future(future&& rhs) noexcept
-                : aux::future_base<R&>{move(rhs.state_)}
-            { /* DUMMY BODY */ }
-
-            future(aux::shared_state<R&>* state)
-                : aux::future_base<R&>{state}
+                : aux::future_base<R*>{move(rhs.state_)}
+            { /* DUMMY BODY */ }
+
+            future(aux::shared_state<R*>* state)
+                : aux::future_base<R*>{state}
             { /* DUMMY BODY */ }
 
@@ -227 +227 @@
                     this->state_->throw_stored_exception();
 
-                return this->state_->get();
+                assert(this->state_->get());
+                return *this->state_->get();
             }
     };

uspace/lib/cpp/include/__bits/thread/promise.hpp

@@ -75 +75 @@
                 {
                     abandon_state_();
-                    promise_base{std::move(rhs)}.swap(*this);
+                    promise_base{move(rhs)}.swap(*this);
 
                     return *this;
@@ -85 +85 @@
                 {
                     std::swap(state_, other.state_);
-                }
-
-                future<R> get_future()
-                {
-                    return future<R>{state_};
                 }
 
@@ -165 +160 @@
             promise& operator=(const promise&) = delete;
 
+            future<R> get_future()
+            {
+                return future<R>{this->state_};
+            }
+
             void set_value(const R& val)
             {
@@ -190 +190 @@
                 }
 
-                this->state_->set_value(std::forward<R>(val), true);
+                this->state_->set_value(forward<R>(val), true);
             }
 
@@ -219 +219 @@
                 }
 
-                this->state_->set_value(std::forward<R>(val), false);
+                this->state_->set_value(forward<R>(val), false);
                 // TODO: schedule it to be set as ready when thread exits
             }
@@ -225 +225 @@
 
     template<class R>
-    class promise<R&>: public aux::promise_base<R>
-    { // TODO: I'm afraid we will need aux::shared_state<R&> specialization for this :/
+    class promise<R&>: public aux::promise_base<R*>
+    {
         public:
             promise()
-                : aux::promise_base<R&>{}
+                : aux::promise_base<R*>{}
             { /* DUMMY BODY */ }
 
             template<class Allocator>
             promise(allocator_arg_t, const Allocator& a)
-                : aux::promise_base<R&>{}
+                : aux::promise_base<R*>{}
             {
                 // TODO: Use the allocator.
@@ -240 +240 @@
 
             promise(promise&& rhs) noexcept
-                : aux::promise_base<R&>{move(rhs)}
+                : aux::promise_base<R*>{move(rhs)}
             { /* DUMMY BODY */ }
 
@@ -250 +250 @@
 
             promise& operator=(const promise&) = delete;
+
+            future<R&> get_future()
+            {
+                return future<R&>{this->state_};
+            }
+
+            void set_value(R& val)
+            {
+                if (!this->state_)
+                    throw future_error{make_error_code(future_errc::no_state)};
+                if (this->state_->is_set())
+                {
+                    throw future_error{
+                        make_error_code(future_errc::promise_already_satisfied)
+                    };
+                }
+
+                this->state_->set_value(&val, true);
+            }
+
+            void set_value_at_thread_exit(R& val)
+            {
+                if (!this->state_)
+                    throw future_error{make_error_code(future_errc::no_state)};
+                if (this->state_->is_set())
+                {
+                    throw future_error{
+                        make_error_code(future_errc::promise_already_satisfied)
+                    };
+                }
+
+                this->state_->set_value(&val, false);
+                // TODO: schedule it to be set as ready when thread exits
+            }
     };
 
@@ -278 +312 @@
 
             promise& operator=(const promise&) = delete;
+
+            future<void> get_future()
+            {
+                return future<void>{this->state_};
+            }
 
             void set_value()