Changeset bd6ad4b in mainline for uspace/lib/cpp/include/__bits/thread/future.hpp

Timestamp:

2019-07-01T09:49:54Z (5 years ago)

Author:

Jaroslav Jindrak <dzejrou@…>

Branches:

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

Children:

60cb9e1

Parents:

3a29607

Message:

cpp: remove unneeded std:: prefixes and add implementations for future<R&> and future<void>

File:

• uspace/lib/cpp/include/__bits/thread/future.hpp (modified) (5 diffs)

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

@@ -54 +54 @@
 
                 future_base(future_base&& rhs) noexcept
-                    : state_{std::move(rhs.state_)}
+                    : state_{move(rhs.state_)}
                 {
                     rhs.state_ = nullptr;
@@ -80 +80 @@
                 {
                     release_state_();
-                    state_ = std::move(rhs.state_);
+                    state_ = move(rhs.state_);
                     rhs.state_ = nullptr;
                 }
@@ -162 +162 @@
 
             future(future&& rhs) noexcept
-                : aux::future_base<R>{std::move(rhs.state_)}
+                : aux::future_base<R>{move(rhs.state_)}
             { /* DUMMY BODY */ }
 
@@ -173 +173 @@
             future& operator=(future&& rhs) noexcept
             {
-                return aux::future_base<R>::operator=(std::move(rhs));
+                return aux::future_base<R>::operator=(move(rhs));
             }
 
             shared_future<R> share()
             {
-                return shared_future<R>(std::move(*this));
+                return shared_future<R>(move(*this));
             }
 
@@ -190 +190 @@
                     this->state_->throw_stored_exception();
 
+                return move(this->state_->get());
+            }
+    };
+
+    template<class R>
+    class future<R&>: public aux::future_base<R&>
+    {
+        public:
+            future() noexcept
+                : aux::future_base<R&>{}
+            { /* DUMMY BODY */ }
+
+            future(const future&) = delete;
+
+            future(future&& rhs) noexcept
+                : aux::future_base<R&>{move(rhs.state_)}
+            { /* DUMMY BODY */ }
+
+            future(aux::shared_state<R&>* state)
+                : aux::future_base<R&>{state}
+            { /* DUMMY BODY */ }
+
+            future& operator=(const future&) = delete;
+
+            future& operator=(future&& rhs) noexcept
+            {
+                return aux::future_base<R>::operator=(move(rhs));
+            }
+
+            shared_future<R&> share()
+            {
+                return shared_future<R&>(move(*this));
+            }
+
+            R& get()
+            {
+                assert(this->state_);
+
+                this->wait();
+
+                if (this->state_->has_exception())
+                    this->state_->throw_stored_exception();
+
                 return this->state_->get();
             }
     };
 
-    template<class R>
-    class future<R&>
-    {
-        // TODO: Copy & modify once future is done.
-    };
-
     template<>
-    class future<void>
-    {
-        // TODO: Copy & modify once future is done.
+    class future<void>: public aux::future_base<void>
+    {
+        public:
+            future() noexcept
+                : aux::future_base<void>{}
+            { /* DUMMY BODY */ }
+
+            future(const future&) = delete;
+
+            future(future&& rhs) noexcept
+                : aux::future_base<void>{move(rhs.state_)}
+            { /* DUMMY BODY */ }
+
+            future(aux::shared_state<void>* state)
+                : aux::future_base<void>{state}
+            { /* DUMMY BODY */ }
+
+            future& operator=(const future&) = delete;
+
+            future& operator=(future&& rhs) noexcept = default;
+
+            /* shared_future<void> share() */
+            /* { */
+            /*     return shared_future<void>(move(*this)); */
+            /* } */
+
+            void get()
+            {
+                assert(this->state_);
+
+                this->wait();
+
+                if (this->state_->has_exception())
+                    this->state_->throw_stored_exception();
+            }
     };
 }