Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 0f43be5 in mainline


Ignore:
Timestamp:
2019-07-01T13:19:05Z (16 months ago)
Author:
Jaroslav Jindrak <dzejrou@…>
Branches:
master
Children:
0d299c93
Parents:
396b234
Message:

cpp: implemented promise and future for references

Location:
uspace/lib/cpp/include/__bits/thread
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/cpp/include/__bits/thread/future.hpp

    r396b234 r0f43be5  
    192192
    193193    template<class R>
    194     class future<R&>: public aux::future_base<R&>
     194    class future<R&>: public aux::future_base<R*>
    195195    {
    196196        public:
    197197            future() noexcept
    198                 : aux::future_base<R&>{}
     198                : aux::future_base<R*>{}
    199199            { /* DUMMY BODY */ }
    200200
     
    202202
    203203            future(future&& rhs) noexcept
    204                 : aux::future_base<R&>{move(rhs.state_)}
    205             { /* DUMMY BODY */ }
    206 
    207             future(aux::shared_state<R&>* state)
    208                 : aux::future_base<R&>{state}
     204                : aux::future_base<R*>{move(rhs.state_)}
     205            { /* DUMMY BODY */ }
     206
     207            future(aux::shared_state<R*>* state)
     208                : aux::future_base<R*>{state}
    209209            { /* DUMMY BODY */ }
    210210
     
    227227                    this->state_->throw_stored_exception();
    228228
    229                 return this->state_->get();
     229                assert(this->state_->get());
     230                return *this->state_->get();
    230231            }
    231232    };
  • uspace/lib/cpp/include/__bits/thread/promise.hpp

    r396b234 r0f43be5  
    7575                {
    7676                    abandon_state_();
    77                     promise_base{std::move(rhs)}.swap(*this);
     77                    promise_base{move(rhs)}.swap(*this);
    7878
    7979                    return *this;
     
    8585                {
    8686                    std::swap(state_, other.state_);
    87                 }
    88 
    89                 future<R> get_future()
    90                 {
    91                     return future<R>{state_};
    9287                }
    9388
     
    165160            promise& operator=(const promise&) = delete;
    166161
     162            future<R> get_future()
     163            {
     164                return future<R>{this->state_};
     165            }
     166
    167167            void set_value(const R& val)
    168168            {
     
    190190                }
    191191
    192                 this->state_->set_value(std::forward<R>(val), true);
     192                this->state_->set_value(forward<R>(val), true);
    193193            }
    194194
     
    219219                }
    220220
    221                 this->state_->set_value(std::forward<R>(val), false);
     221                this->state_->set_value(forward<R>(val), false);
    222222                // TODO: schedule it to be set as ready when thread exits
    223223            }
     
    225225
    226226    template<class R>
    227     class promise<R&>: public aux::promise_base<R>
    228     { // TODO: I'm afraid we will need aux::shared_state<R&> specialization for this :/
     227    class promise<R&>: public aux::promise_base<R*>
     228    {
    229229        public:
    230230            promise()
    231                 : aux::promise_base<R&>{}
     231                : aux::promise_base<R*>{}
    232232            { /* DUMMY BODY */ }
    233233
    234234            template<class Allocator>
    235235            promise(allocator_arg_t, const Allocator& a)
    236                 : aux::promise_base<R&>{}
     236                : aux::promise_base<R*>{}
    237237            {
    238238                // TODO: Use the allocator.
     
    240240
    241241            promise(promise&& rhs) noexcept
    242                 : aux::promise_base<R&>{move(rhs)}
     242                : aux::promise_base<R*>{move(rhs)}
    243243            { /* DUMMY BODY */ }
    244244
     
    250250
    251251            promise& operator=(const promise&) = delete;
     252
     253            future<R&> get_future()
     254            {
     255                return future<R&>{this->state_};
     256            }
     257
     258            void set_value(R& val)
     259            {
     260                if (!this->state_)
     261                    throw future_error{make_error_code(future_errc::no_state)};
     262                if (this->state_->is_set())
     263                {
     264                    throw future_error{
     265                        make_error_code(future_errc::promise_already_satisfied)
     266                    };
     267                }
     268
     269                this->state_->set_value(&val, true);
     270            }
     271
     272            void set_value_at_thread_exit(R& val)
     273            {
     274                if (!this->state_)
     275                    throw future_error{make_error_code(future_errc::no_state)};
     276                if (this->state_->is_set())
     277                {
     278                    throw future_error{
     279                        make_error_code(future_errc::promise_already_satisfied)
     280                    };
     281                }
     282
     283                this->state_->set_value(&val, false);
     284                // TODO: schedule it to be set as ready when thread exits
     285            }
    252286    };
    253287
     
    278312
    279313            promise& operator=(const promise&) = delete;
     314
     315            future<void> get_future()
     316            {
     317                return future<void>{this->state_};
     318            }
    280319
    281320            void set_value()
Note: See TracChangeset for help on using the changeset viewer.