Concurrency::completion_future Class Reference

Class represents a future corresponding to a C++ AMP asynchronous operation More...

#include <amprt.h>

Public Member Functions
	completion_future ()
	Default constructor More...
	completion_future (const completion_future &_Other)
	Copy constructor More...
	completion_future (completion_future &&_Other)
	Move constructor More...
	~completion_future ()
	Destructor More...
completion_future &	operator= (const completion_future &_Other)
	Copy assignment operator More...
completion_future &	operator= (completion_future &&_Other)
	Move assignment operator More...
void	get () const
	Waits until the associated asynchronous operation completes Throws the stored exception if one was encountered during the asynchronous operation More...
bool	valid () const
	Returns true if the object is associated with an asynchronous operation More...
void	wait () const
	Blocks until the associated asynchronous operation completes More...
template<class _Rep , class _Period >
std::future_status	wait_for (const std::chrono::duration< _Rep, _Period > &_Rel_time) const
	Blocks until the associated asynchronous operation completes or _Rel_time has elapsed More...
template<class _Clock , class _Duration >
std::future_status	wait_until (const std::chrono::time_point< _Clock, _Duration > &_Abs_time) const
	Blocks until the associated asynchronous operation completes or until the current time exceeds _Abs_time More...
	operator std::shared_future< void > () const
	Returns a std::shared_future<void> object corresponding to the associated asynchronous operation More...
template<typename _Functor >
void	then (const _Functor &_Func) const
	Chains a callback Functor to the completion_future to be executed when the associated asynchronous operation finishes execution More...
concurrency::task< void >	to_task () const
	Returns a concurrency::task<void> object corresponding to the associated asynchronous operation More...

Private Member Functions
	completion_future (const std::shared_future< void > &_Shared_future, const concurrency::task< void > &_Task)

Private Attributes
std::shared_future< void >	_M_shared_future
concurrency::task< void >	_M_task

Friends
class	details::_Amp_runtime_trace

Detailed Description

Class represents a future corresponding to a C++ AMP asynchronous operation

Constructor & Destructor Documentation

Concurrency::completion_future::completion_future ( )

inline

Default constructor

    {
    }

Concurrency::completion_future::completion_future ( const completion_future &  _Other )

inline

Copy constructor

        : _M_shared_future(_Other._M_shared_future),
        _M_task(_Other._M_task)
    {
    }

Concurrency::completion_future::completion_future ( completion_future &&  _Other )

inline

Move constructor

        : _M_shared_future(std::move(_Other._M_shared_future)),
        _M_task(std::move(_Other._M_task))
    {
    }

Concurrency::completion_future::~completion_future ( )

inline

Destructor

    {
    }

Concurrency::completion_future::completion_future ( const std::shared_future< void > &  _Shared_future, const concurrency::task< void > &  _Task  )

inlineprivate

                      : _M_shared_future(_Shared_future), _M_task(_Task)
    {
    }

Member Function Documentation

void Concurrency::completion_future::get ( ) const

inline

Waits until the associated asynchronous operation completes Throws the stored exception if one was encountered during the asynchronous operation

    {
        _M_shared_future.get();
    }

Concurrency::completion_future::operator std::shared_future< void > ( ) const

inline

Returns a std::shared_future<void> object corresponding to the associated asynchronous operation

Returns

A std::shared_future<void> object corresponding to the associated asynchronous operation

    {
        return _M_shared_future;
    }

completion_future& Concurrency::completion_future::operator= ( const completion_future &  _Other )

inline

Copy assignment operator

    {
        if (this != &_Other) {
            _M_shared_future = _Other._M_shared_future;
            _M_task = _Other._M_task;
        }

        return (*this);
    }

completion_future& Concurrency::completion_future::operator= ( completion_future &&  _Other )

inline

Move assignment operator

    {
        if (this != &_Other) {
            _M_shared_future = std::move(_Other._M_shared_future);
            _M_task = std::move(_Other._M_task);
        }

        return (*this);
    }

template<typename _Functor >

void Concurrency::completion_future::then ( const _Functor &  _Func ) const

inline

Chains a callback Functor to the completion_future to be executed when the associated asynchronous operation finishes execution

    {
        this->to_task().then(_Func);
    }

concurrency::task<void> Concurrency::completion_future::to_task ( ) const

inline

Returns a concurrency::task<void> object corresponding to the associated asynchronous operation

Returns

A concurrency::task<void> object corresponding to the associated asynchronous operation

    {
        return _M_task;
    }

bool Concurrency::completion_future::valid ( ) const

inline

Returns true if the object is associated with an asynchronous operation

Returns

true if the object is associated with an asynchronous operation and false otherwise

    {
        return _M_shared_future.valid();
    }

void Concurrency::completion_future::wait ( ) const

inline

Blocks until the associated asynchronous operation completes

    {
        _M_shared_future.wait();
    }

template<class _Rep , class _Period >

std::future_status Concurrency::completion_future::wait_for ( const std::chrono::duration< _Rep, _Period > &  _Rel_time ) const

inline

Blocks until the associated asynchronous operation completes or _Rel_time has elapsed

Returns

• future_status::deferred if the associated asynchronous operation is not running
• future_status::ready if the associated asynchronous operation is finished
• future_status::timeout if the time period specified has elapsed

    {
        return _M_shared_future.wait_for(_Rel_time);
    }

template<class _Clock , class _Duration >

std::future_status Concurrency::completion_future::wait_until ( const std::chrono::time_point< _Clock, _Duration > &  _Abs_time ) const

inline

Blocks until the associated asynchronous operation completes or until the current time exceeds _Abs_time

Returns

• future_status::deferred if the associated asynchronous operation is not running
• future_status::ready if the associated asynchronous operation is finished
• future_status::timeout if the time point specified has been reached

    {
        return _M_shared_future.wait_until(_Abs_time);
    }

Friends And Related Function Documentation

friend class details::_Amp_runtime_trace

friend

Member Data Documentation

std::shared_future<void> Concurrency::completion_future::_M_shared_future

private

concurrency::task<void> Concurrency::completion_future::_M_task

private

---

The documentation for this class was generated from the following file:

• VS2013/inc/amprt.h