Make consistent set of get and getTry methods on SemiFuture.

[folly.git] / folly / futures / Future-inl.h

diff --git a/folly/futures/Future-inl.h b/folly/futures/Future-inl.h
index 70b0f892de00320d9798cd1ff017ee938fc85c6d..56b98410abcfe59d24cfcdbe89caecf08a0d8ba2 100644 (file)
--- a/folly/futures/Future-inl.h
+++ b/folly/futures/Future-inl.h
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright 2017 Facebook, Inc.
+ * Copyright 2017-present 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.


@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

-

 #pragma once
 
 #include <algorithm>
 #pragma once
 
 #include <algorithm>


@@ -174,30 +173,50 @@ FutureBase<T>::~FutureBase() {
 
 template <class T>
 T& FutureBase<T>::value() & {
 
 template <class T>
 T& FutureBase<T>::value() & {

+  return result().value();
+}
+
+template <class T>
+T const& FutureBase<T>::value() const& {
+  return result().value();
+}
+
+template <class T>
+T&& FutureBase<T>::value() && {
+  return std::move(result().value());
+}
+
+template <class T>
+T const&& FutureBase<T>::value() const&& {
+  return std::move(result().value());
+}
+
+template <class T>
+Try<T>& FutureBase<T>::result() & {

   throwIfInvalid();
 
   throwIfInvalid();
 

-  return core_->getTry().value();
+  return core_->getTry();

 }
 
 template <class T>
 }
 
 template <class T>

-T const& FutureBase<T>::value() const& {
+Try<T> const& FutureBase<T>::result() const& {

   throwIfInvalid();
 
   throwIfInvalid();
 

-  return core_->getTry().value();
+  return core_->getTry();

 }
 
 template <class T>
 }
 
 template <class T>

-T&& FutureBase<T>::value() && {
+Try<T>&& FutureBase<T>::result() && {

   throwIfInvalid();
 
   throwIfInvalid();
 

-  return std::move(core_->getTry().value());
+  return std::move(core_->getTry());

 }
 
 template <class T>
 }
 
 template <class T>

-T const&& FutureBase<T>::value() const&& {
+Try<T> const&& FutureBase<T>::result() const&& {

   throwIfInvalid();
 
   throwIfInvalid();
 

-  return std::move(core_->getTry().value());
+  return std::move(core_->getTry());

 }
 
 template <class T>
 }
 
 template <class T>


@@ -208,12 +227,12 @@ bool FutureBase<T>::isReady() const {
 
 template <class T>
 bool FutureBase<T>::hasValue() {
 
 template <class T>
 bool FutureBase<T>::hasValue() {

-  return getTry().hasValue();
+  return core_->getTry().hasValue();

 }
 
 template <class T>
 bool FutureBase<T>::hasException() {
 }
 
 template <class T>
 bool FutureBase<T>::hasException() {

-  return getTry().hasException();
+  return core_->getTry().hasException();

 }
 
 template <class T>
 }
 
 template <class T>


@@ -224,13 +243,6 @@ void FutureBase<T>::detach() {
   }
 }
 
   }
 }
 

-template <class T>
-Try<T>& FutureBase<T>::getTry() {
-  throwIfInvalid();
-
-  return core_->getTry();
-}
-

 template <class T>
 void FutureBase<T>::throwIfInvalid() const {
   if (!core_) {
 template <class T>
 void FutureBase<T>::throwIfInvalid() const {
   if (!core_) {


@@ -795,11 +807,6 @@ Future<T>::onError(F&& func) {
   return f;
 }
 
   return f;
 }
 

-template <class T>
-Try<T>& Future<T>::getTryVia(DrivableExecutor* e) {
-  return waitVia(e).getTry();
-}
-

 template <class Func>
 auto via(Executor* x, Func&& func)
     -> Future<typename isFuture<decltype(std::declval<Func>()())>::Inner> {
 template <class Func>
 auto via(Executor* x, Func&& func)
     -> Future<typename isFuture<decltype(std::declval<Func>()())>::Inner> {


@@ -1399,6 +1406,21 @@ void waitViaImpl(Future<T>& f, DrivableExecutor* e) {
   assert(f.isReady());
 }
 
   assert(f.isReady());
 }
 

+template <class T>
+void waitViaImpl(SemiFuture<T>& f, DrivableExecutor* e) {
+  // Set callback so to ensure that the via executor has something on it
+  // so that once the preceding future triggers this callback, drive will
+  // always have a callback to satisfy it
+  if (f.isReady()) {
+    return;
+  }
+  f = std::move(f).via(e).then([](T&& t) { return std::move(t); });
+  while (!f.isReady()) {
+    e->drive();
+  }
+  assert(f.isReady());
+}
+

 } // namespace detail
 } // namespace futures
 
 } // namespace detail
 } // namespace futures
 


@@ -1426,9 +1448,21 @@ SemiFuture<T>&& SemiFuture<T>::wait(Duration dur) && {
   return std::move(*this);
 }
 
   return std::move(*this);
 }
 

+template <class T>
+SemiFuture<T>& SemiFuture<T>::waitVia(DrivableExecutor* e) & {
+  futures::detail::waitViaImpl(*this, e);
+  return *this;
+}
+
+template <class T>
+SemiFuture<T>&& SemiFuture<T>::waitVia(DrivableExecutor* e) && {
+  futures::detail::waitViaImpl(*this, e);
+  return std::move(*this);
+}
+

 template <class T>
 T SemiFuture<T>::get() && {
 template <class T>
 T SemiFuture<T>::get() && {

-  return std::move(wait().value());
+  return std::move(wait()).value();

 }
 
 template <class T>
 }
 
 template <class T>


@@ -1441,6 +1475,31 @@ T SemiFuture<T>::get(Duration dur) && {
   }
 }
 
   }
 }
 

+template <class T>
+Try<T> SemiFuture<T>::getTry() && {
+  return std::move(wait()).result();
+}
+
+template <class T>
+Try<T> SemiFuture<T>::getTry(Duration dur) && {
+  wait(dur);
+  if (this->isReady()) {
+    return std::move(this->result());
+  } else {
+    throwTimedOut();
+  }
+}
+
+template <class T>
+T SemiFuture<T>::getVia(DrivableExecutor* e) && {
+  return std::move(waitVia(e)).value();
+}
+
+template <class T>
+Try<T> SemiFuture<T>::getTryVia(DrivableExecutor* e) && {
+  return std::move(waitVia(e)).result();
+}
+

 template <class T>
 Future<T>& Future<T>::wait() & {
   futures::detail::waitImpl(*this);
 template <class T>
 Future<T>& Future<T>::wait() & {
   futures::detail::waitImpl(*this);


@@ -1492,11 +1551,21 @@ T Future<T>::get(Duration dur) {
   }
 }
 
   }
 }
 

+template <class T>
+Try<T>& Future<T>::getTry() {
+  return result();
+}
+

 template <class T>
 T Future<T>::getVia(DrivableExecutor* e) {
   return std::move(waitVia(e).value());
 }
 
 template <class T>
 T Future<T>::getVia(DrivableExecutor* e) {
   return std::move(waitVia(e).value());
 }
 

+template <class T>
+Try<T>& Future<T>::getTryVia(DrivableExecutor* e) {
+  return waitVia(e).getTry();
+}
+

 namespace futures {
 namespace detail {
 template <class T>
 namespace futures {
 namespace detail {
 template <class T>