future.hpp File Reference

#include <assert.h>
#include <atomic>
#include <list>
#include <memory>
#include <ostream>
#include <set>
#include <type_traits>
#include <utility>
#include <vector>
#include <glog/logging.h>
#include <process/clock.hpp>
#include <process/latch.hpp>
#include <process/owned.hpp>
#include <process/pid.hpp>
#include <process/timer.hpp>
#include <stout/abort.hpp>
#include <stout/check.hpp>
#include <stout/duration.hpp>
#include <stout/error.hpp>
#include <stout/lambda.hpp>
#include <stout/none.hpp>
#include <stout/option.hpp>
#include <stout/preprocessor.hpp>
#include <stout/result.hpp>
#include <stout/result_of.hpp>
#include <stout/stringify.hpp>
#include <stout/synchronized.hpp>
#include <stout/try.hpp>
#include <stout/os/strerror.hpp>

Go to the source code of this file.

Classes
struct	process::_Deferred< F >
class	process::Future< T >
struct	process::internal::wrap< T >
struct	process::internal::unwrap< T >
class	process::Promise< T >
class	process::WeakFuture< T >
class	process::Future< T >
class	process::WeakFuture< T >
struct	process::Failure
struct	process::ErrnoFailure
class	process::Promise< T >
struct	process::internal::wrap< T >
struct	process::internal::wrap< Future< X > >
struct	process::internal::unwrap< T >
struct	process::internal::unwrap< Future< X > >
struct	process::UndiscardableDecorator< F >

Namespaces
	process
	process::internal

Functions
template<typename C , typename... Arguments>
void	process::internal::run (std::vector< C > &&callbacks, Arguments &&...arguments)
template<typename U >
void	process::internal::discarded (Future< U > future)
template<typename T >
void	process::internal::discard (WeakFuture< T > reference)
template<typename T >
void	process::internal::discarded (Future< T > future)
template<typename T >
void	process::internal::select (const Future< T > &future, std::shared_ptr< Promise< Future< T >>> promise)
template<typename T >
Future< Future< T > >	process::select (const std::set< Future< T >> &futures)
template<typename Futures >
void	process::discard (const Futures &futures)
void	process::internal::awaited (Owned< Latch > latch)
template<typename T , typename X >
void	process::internal::thenf (lambda::CallableOnce< Future< X >(const T &)> &&f, std::unique_ptr< Promise< X >> promise, const Future< T > &future)
template<typename T , typename X >
void	process::internal::then (lambda::CallableOnce< X(const T &)> &&f, std::unique_ptr< Promise< X >> promise, const Future< T > &future)
template<typename T >
void	process::internal::repair (lambda::CallableOnce< Future< T >(const Future< T > &)> &&f, std::unique_ptr< Promise< T >> promise, const Future< T > &future)
template<typename T >
void	process::internal::expired (const std::shared_ptr< lambda::CallableOnce< Future< T >(const Future< T > &)>> &f, const std::shared_ptr< Latch > &latch, const std::shared_ptr< Promise< T >> &promise, const std::shared_ptr< Option< Timer >> &timer, const Future< T > &future)
template<typename T >
void	process::internal::after (const std::shared_ptr< Latch > &latch, const std::shared_ptr< Promise< T >> &promise, const std::shared_ptr< Option< Timer >> &timer, const Future< T > &future)
template<typename T >
std::ostream &	process::operator<< (std::ostream &stream, const Future< T > &future)
template<typename T >
void	process::setPromises (std::set< Promise< T > * > *promises, const T &t)
template<typename T >
void	process::failPromises (std::set< Promise< T > * > *promises, const std::string &failure)
template<typename T >
void	process::discardPromises (std::set< Promise< T > * > *promises)
template<typename T >
void	process::discardPromises (std::set< Promise< T > * > *promises, const Future< T > &future)
template<typename T >
Future< T >	process::undiscardable (const Future< T > &future)
template<typename F , typename std::enable_if< !is_specialization_of< typename std::decay< F >::type, Future >::value, int >::type = 0>
UndiscardableDecorator< typename std::decay< F >::type >	process::undiscardable (F &&f)