BS::multi_future< T > Class Template Reference

A helper class to facilitate waiting for and/or getting the results of multiple futures at once. More...

#include <BS_thread_pool.hpp>

Inheritance diagram for BS::multi_future< T >:

Collaboration diagram for BS::multi_future< T >:

Public Member Functions
	multi_future (const multi_future &)=delete
multi_future &	operator= (const multi_future &)=delete
	multi_future (multi_future &&)=default
multi_future &	operator= (multi_future &&)=default
std::conditional_t< std::is_void_v< T >, void, std::vector< T > >	get ()
	Get the results from all the futures stored in this multi_future, rethrowing any stored exceptions.
size_t	ready_count () const
	Check how many of the futures stored in this multi_future are ready.
bool	valid () const
	Check if all the futures stored in this multi_future are valid.
void	wait () const
	Wait for all the futures stored in this multi_future.
template<typename R , typename P >
bool	wait_for (const std::chrono::duration< R, P > &duration) const
	Wait for all the futures stored in this multi_future, but stop waiting after the specified duration has passed. This function first waits for the first future for the desired duration. If that future is ready before the duration expires, this function waits for the second future for whatever remains of the duration. It continues similarly until the duration expires.
template<typename C , typename D >
bool	wait_until (const std::chrono::time_point< C, D > &timeout_time) const
	Wait for all the futures stored in this multi_future, but stop waiting after the specified time point has been reached. This function first waits for the first future until the desired time point. If that future is ready before the time point is reached, this function waits for the second future until the desired time point. It continues similarly until the time point is reached.

Detailed Description

template<typename T>
class BS::multi_future< T >

A helper class to facilitate waiting for and/or getting the results of multiple futures at once.

Template Parameters

T	The return type of the futures.

Member Function Documentation

get()

template<typename T >

std::conditional_t< std::is_void_v< T >, void, std::vector< T > > BS::multi_future< T >::get ( )

inline

Get the results from all the futures stored in this multi_future, rethrowing any stored exceptions.

Returns

If the futures return void, this function returns void as well. Otherwise, it returns a vector containing the results.

    {
        if constexpr (std::is_void_v<T>)
        {
            for (std::future<T>& future : *this)
                future.get();
            return;
        }
        else
        {
            std::vector<T> results;
            results.reserve(this->size());
            for (std::future<T>& future : *this)
                results.push_back(future.get());
            return results;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

ready_count()

template<typename T >

size_t BS::multi_future< T >::ready_count ( ) const

inline

Check how many of the futures stored in this multi_future are ready.

Returns

The number of ready futures.

    {
        size_t count = 0;
        for (const std::future<T>& future : *this)
        {
            if (future.wait_for(std::chrono::duration<double>::zero()) == std::future_status::ready)
                ++count;
        }
        return count;
    }

valid()

template<typename T >

bool BS::multi_future< T >::valid ( ) const

inline

Check if all the futures stored in this multi_future are valid.

Returns

true if all futures are valid, false if at least one of the futures is not valid.

    {
        bool is_valid = true;
        for (const std::future<T>& future : *this)
            is_valid = is_valid && future.valid();
        return is_valid;
    }

wait()

template<typename T >

void BS::multi_future< T >::wait ( ) const

inline

Wait for all the futures stored in this multi_future.

    {
        for (const std::future<T>& future : *this)
            future.wait();
    }

wait_for()

template<typename T >

template<typename R , typename P >

bool BS::multi_future< T >::wait_for ( const std::chrono::duration< R, P > &  duration ) const

inline

Wait for all the futures stored in this multi_future, but stop waiting after the specified duration has passed. This function first waits for the first future for the desired duration. If that future is ready before the duration expires, this function waits for the second future for whatever remains of the duration. It continues similarly until the duration expires.

Template Parameters

R	An arithmetic type representing the number of ticks to wait.
P	An std::ratio representing the length of each tick in seconds.

Parameters

duration

The amount of time to wait.

Returns

true if all futures have been waited for before the duration expired, false otherwise.

    {
        const std::chrono::time_point<std::chrono::steady_clock> start_time = std::chrono::steady_clock::now();
        for (const std::future<T>& future : *this)
        {
            future.wait_for(duration - (std::chrono::steady_clock::now() - start_time));
            if (duration < std::chrono::steady_clock::now() - start_time)
                return false;
        }
        return true;
    }

wait_until()

template<typename T >

template<typename C , typename D >

bool BS::multi_future< T >::wait_until ( const std::chrono::time_point< C, D > &  timeout_time ) const

inline

Wait for all the futures stored in this multi_future, but stop waiting after the specified time point has been reached. This function first waits for the first future until the desired time point. If that future is ready before the time point is reached, this function waits for the second future until the desired time point. It continues similarly until the time point is reached.

Template Parameters

C	The type of the clock used to measure time.
D	An std::chrono::duration type used to indicate the time point.

Parameters

timeout_time

The time point at which to stop waiting.

Returns

true if all futures have been waited for before the time point was reached, false otherwise.

    {
        for (const std::future<T>& future : *this)
        {
            future.wait_until(timeout_time);
            if (timeout_time < std::chrono::steady_clock::now())
                return false;
        }
        return true;
    }

---

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

• external/threadpool/include/BS_thread_pool.hpp