projects
/
folly.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
cmake: add checks to generate folly-config.h correctly
[folly.git]
/
folly
/
futures
/
Promise-inl.h
diff --git
a/folly/futures/Promise-inl.h
b/folly/futures/Promise-inl.h
index f38ee60dfd59f9dd7381a0d0fb2621327a2a4387..45e6929a9152a7bc0bf4750cf7583e8da4a684e3 100644
(file)
--- a/
folly/futures/Promise-inl.h
+++ b/
folly/futures/Promise-inl.h
@@
-1,5
+1,5
@@
/*
/*
- * Copyright 201
5
Facebook, Inc.
+ * Copyright 201
7
Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@
-19,22
+19,30
@@
#include <atomic>
#include <thread>
#include <atomic>
#include <thread>
+#include <folly/executors/InlineExecutor.h>
#include <folly/futures/FutureException.h>
#include <folly/futures/detail/Core.h>
namespace folly {
template <class T>
#include <folly/futures/FutureException.h>
#include <folly/futures/detail/Core.h>
namespace folly {
template <class T>
-Promise<T>::Promise() : retrieved_(false), core_(new detail::Core<T>())
-{}
+Promise<T> Promise<T>::makeEmpty() noexcept {
+ return Promise<T>(futures::detail::EmptyConstruct{});
+}
+
+template <class T>
+Promise<T>::Promise()
+ : retrieved_(false), core_(new futures::detail::Core<T>()) {}
template <class T>
template <class T>
-Promise<T>::Promise(Promise<T>&& other) : core_(nullptr) {
- *this = std::move(other);
+Promise<T>::Promise(Promise<T>&& other) noexcept
+ : retrieved_(other.retrieved_), core_(other.core_) {
+ other.core_ = nullptr;
+ other.retrieved_ = false;
}
template <class T>
}
template <class T>
-Promise<T>& Promise<T>::operator=(Promise<T>&& other) {
+Promise<T>& Promise<T>::operator=(Promise<T>&& other)
noexcept
{
std::swap(core_, other.core_);
std::swap(retrieved_, other.retrieved_);
return *this;
std::swap(core_, other.core_);
std::swap(retrieved_, other.retrieved_);
return *this;
@@
-42,18
+50,25
@@
Promise<T>& Promise<T>::operator=(Promise<T>&& other) {
template <class T>
void Promise<T>::throwIfFulfilled() {
template <class T>
void Promise<T>::throwIfFulfilled() {
- if (!core_)
- throw NoState();
- if (core_->ready())
- throw PromiseAlreadySatisfied();
+ if (!core_) {
+ throwNoState();
+ }
+ if (core_->ready()) {
+ throwPromiseAlreadySatisfied();
+ }
}
template <class T>
void Promise<T>::throwIfRetrieved() {
}
template <class T>
void Promise<T>::throwIfRetrieved() {
- if (retrieved_)
- throw FutureAlreadyRetrieved();
+ if (retrieved_) {
+ throwFutureAlreadyRetrieved();
+ }
}
}
+template <class T>
+Promise<T>::Promise(futures::detail::EmptyConstruct) noexcept
+ : retrieved_(false), core_(nullptr) {}
+
template <class T>
Promise<T>::~Promise() {
detach();
template <class T>
Promise<T>::~Promise() {
detach();
@@
-62,18
+77,26
@@
Promise<T>::~Promise() {
template <class T>
void Promise<T>::detach() {
if (core_) {
template <class T>
void Promise<T>::detach() {
if (core_) {
- if (!retrieved_)
+ if (!retrieved_)
{
core_->detachFuture();
core_->detachFuture();
+ }
core_->detachPromise();
core_ = nullptr;
}
}
template <class T>
core_->detachPromise();
core_ = nullptr;
}
}
template <class T>
-
Future<T> Promise<T>::get
Future() {
+
SemiFuture<T> Promise<T>::getSemi
Future() {
throwIfRetrieved();
retrieved_ = true;
throwIfRetrieved();
retrieved_ = true;
- return Future<T>(core_);
+ return SemiFuture<T>(core_);
+}
+
+template <class T>
+Future<T> Promise<T>::getFuture() {
+ // An InlineExecutor approximates the old behaviour of continuations
+ // running inine on setting the value of the promise.
+ return getSemiFuture().via(&InlineExecutor::instance());
}
template <class T>
}
template <class T>
@@
-85,13
+108,7
@@
Promise<T>::setException(E const& e) {
template <class T>
void Promise<T>::setException(std::exception_ptr const& ep) {
template <class T>
void Promise<T>::setException(std::exception_ptr const& ep) {
- try {
- std::rethrow_exception(ep);
- } catch (const std::exception& e) {
- setException(exception_wrapper(std::current_exception(), e));
- } catch (...) {
- setException(exception_wrapper(std::current_exception()));
- }
+ setException(exception_wrapper::from_exception_ptr(ep));
}
template <class T>
}
template <class T>
@@
-107,7
+124,7
@@
void Promise<T>::setInterruptHandler(
}
template <class T>
}
template <class T>
-void Promise<T>::
fulfilTry(Try<T>
t) {
+void Promise<T>::
setTry(Try<T>&&
t) {
throwIfFulfilled();
core_->setResult(std::move(t));
}
throwIfFulfilled();
core_->setResult(std::move(t));
}
@@
-118,22
+135,22
@@
void Promise<T>::setValue(M&& v) {
static_assert(!std::is_same<T, void>::value,
"Use setValue() instead");
static_assert(!std::is_same<T, void>::value,
"Use setValue() instead");
- fulfilTry(Try<T>(std::forward<M>(v)));
-}
-
-template <class T>
-void Promise<T>::setValue() {
- static_assert(std::is_same<T, void>::value,
- "Use setValue(value) instead");
-
- fulfilTry(Try<void>());
+ setTry(Try<T>(std::forward<M>(v)));
}
template <class T>
template <class F>
}
template <class T>
template <class F>
-void Promise<T>::
fulfil
(F&& func) {
+void Promise<T>::
setWith
(F&& func) {
throwIfFulfilled();
throwIfFulfilled();
-
fulfilTry(makeTryFunction
(std::forward<F>(func)));
+
setTry(makeTryWith
(std::forward<F>(func)));
}
}
+template <class T>
+bool Promise<T>::isFulfilled() const noexcept {
+ if (core_) {
+ return core_->hasResult();
+ }
+ return true;
}
}
+
+} // namespace folly