ldvc_async.hpp File Reference

Provides utilities for asynchronous execution in C++. More...

#include <future>

Include dependency graph for ldvc_async.hpp:

Go to the source code of this file.

Functions
template<typename F , typename... A>
std::future< typename std::result_of< F(A...)>::type >	ldvc_async_execute (F &&f, A &&... args)
	Executes a function asynchronously.
template<typename R , typename P , typename F , typename... A>
std::future< typename std::result_of< F(A...)>::type >	ldvc_async_execute_with_delay (const std::chrono::duration< R, P > &delay, F &&f, A &&... args)
	Executes a function asynchronously with a delay.
template<typename R , typename P , typename F , typename... A>
std::future< typename std::result_of< F(A...)>::type >	ldvc_async_execute_with_timeout (const std::chrono::duration< R, P > &timeout, F &&f, A &&... args)
	Executes a function asynchronously with a timeout.

Detailed Description

Provides utilities for asynchronous execution in C++.

This header file defines functions for executing tasks asynchronously in C++, providing capabilities for delayed execution and timeout handling.

Author

Nathanne Isip

Definition in file ldvc_async.hpp.

Function Documentation

ldvc_async_execute()

template<typename F , typename... A>

std::future< typename std::result_of< F(A...)>::type > ldvc_async_execute	(	F &&	f,
		A &&...	args )

Executes a function asynchronously.

This function executes the given function f asynchronously, along with its arguments args. It returns a std::future object representing the result of the function call.

Template Parameters

F	The type of the function to be executed.
A	The types of the arguments to the function.

Parameters

f	The function to be executed.
args	The arguments to the function.

Returns

std::future<typename std::result_of<F(A...)>::type> A future object representing the result of the function call.

Definition at line 60 of file ldvc_async.hpp.

{
    using return_type = typename std::result_of<F(A...)>::type;
 
    std::packaged_task<return_type()> task(std::bind(std::forward<F>(f), std::forward<A>(args)...));
    std::future<return_type> result = task.get_future();
    std::thread(std::move(task)).detach();
 
    return result;
}

ldvc_async_execute_with_delay()

template<typename R , typename P , typename F , typename... A>

std::future< typename std::result_of< F(A...)>::type > ldvc_async_execute_with_delay	(	const std::chrono::duration< R, P > &	delay,
		F &&	f,
		A &&...	args )

Executes a function asynchronously with a delay.

This function executes the given function f asynchronously, along with its arguments args, after the specified delay. It returns a std::future object representing the result of the function call.

Template Parameters

R	The type of the delay duration.
P	The type of the delay duration.
F	The type of the function to be executed.
A	The types of the arguments to the function.

Parameters

delay	The delay duration before executing the function.
f	The function to be executed.
args	The arguments to the function.

Returns

std::future<typename std::result_of<F(A...)>::type> A future object representing the result of the function call.

Definition at line 93 of file ldvc_async.hpp.

{
    return std::async(std::launch::async, [=]() {
        std::this_thread::sleep_for(delay);
        return f(std::forward<A>(args)...);
    });
}

ldvc_async_execute_with_timeout()

template<typename R , typename P , typename F , typename... A>

std::future< typename std::result_of< F(A...)>::type > ldvc_async_execute_with_timeout	(	const std::chrono::duration< R, P > &	timeout,
		F &&	f,
		A &&...	args )

Executes a function asynchronously with a timeout.

This function executes the given function f asynchronously, along with its arguments args, and provides a timeout mechanism. If the function does not complete within the specified timeout duration, an exception is thrown.

Template Parameters

R	The type of the timeout duration.
P	The type of the timeout duration.
F	The type of the function to be executed.
A	The types of the arguments to the function.

Parameters

timeout	The timeout duration for the function execution.
f	The function to be executed.
args	The arguments to the function.

Returns

std::future<typename std::result_of<F(A...)>::type> A future object representing the result of the function call.

Exceptions

std::runtime_error

Thrown if the function execution exceeds the specified timeout duration.

Definition at line 130 of file ldvc_async.hpp.

{
    std::promise<typename std::result_of<F(A...)>::type> promise;
    std::future<typename std::result_of<F(A...)>::type> result = promise.get_future();
 
    std::thread([=, &promise]() {
        try {
            f(std::forward<A>(args)...);
        } catch (...) {
            promise.set_exception(std::current_exception());
            return;
        }
        promise.set_value();
    }).detach();
 
    std::thread([=, &promise]() {
        std::this_thread::sleep_for(timeout);
        promise.set_exception(std::make_exception_ptr(std::runtime_error("Timeout")));
    }).detach();
 
    return result;
}