Apache Mesos
Classes | Namespaces | Functions
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/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 T >
void process::discard (const std::set< Future< T >> &futures)
 
template<typename T >
void process::discard (const std::list< Future< T >> &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)