#include "AsyncTask.h"

Public Types
using	AsyncFunction = std::function< T()>

using	CallbackFunction = std::function< void(T)>

Public Member Functions
	AsyncTask (AsyncFunction asyncFunc, CallbackFunction callbackFunc)

	~AsyncTask ()

bool	InvokeIfReady ()

void	ExecuteAsync ()

Private Attributes
AsyncFunction	asyncFunc

CallbackFunction	callbackFunc

std::shared_future< T >	asyncTask

bool	isReady

Detailed Description

template<typename T>
class AsyncTask< T >

Member Typedef Documentation

◆ AsyncFunction

template<typename T >

using AsyncTask< T >::AsyncFunction = std::function<T()>

◆ CallbackFunction

template<typename T >

using AsyncTask< T >::CallbackFunction = std::function<void(T)>

Constructor & Destructor Documentation

◆ AsyncTask()

template<typename T >

AsyncTask< T >::AsyncTask	(	AsyncFunction	asyncFunc,
		CallbackFunction	callbackFunc
	)

inline

        : asyncFunc(std::move(asyncFunc)), callbackFunc(std::move(callbackFunc)), isReady(false)
    {
    }

◆ ~AsyncTask()

template<typename T >

AsyncTask< T >::~AsyncTask ( )

inline

    {
        // Ensure that the asynchronous task has completed before destruction
        if (asyncTask.valid() && asyncTask.wait_for(std::chrono::seconds(0)) != std::future_status::ready)
        {
            asyncTask.wait(); // Wait for the task to complete
        }
    }

References AsyncTask< T >::asyncTask.

Member Function Documentation

◆ ExecuteAsync()

template<typename T >

void AsyncTask< T >::ExecuteAsync ( )

inline

    {
        // Capture the function by value so a moved AsyncTask does not leave
        // the in-flight async holding a dangling this pointer.
        AsyncFunction fn = asyncFunc;
        asyncTask = std::async(std::launch::async, [fn = std::move(fn)]() mutable
        {
            return fn();
        });
    }

References AsyncTask< T >::asyncFunc, and AsyncTask< T >::asyncTask.

Referenced by ToCloud9Sidecar::OnMapsReassigned().

◆ InvokeIfReady()

template<typename T >

bool AsyncTask< T >::InvokeIfReady ( )

inline

    {
        if (!isReady)
        {
            // Check if the asynchronous task is ready
            if (asyncTask.valid() && asyncTask.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
            {
                // get() rethrows anything the async function threw. Swallowing it
                // would wedge the cluster handoff (the completion callback signals
                // map readiness to the registry), so fail fast with context and let
                // the registry's crash recovery rebalance this node.
                try
                {
                    callbackFunc(asyncTask.get());
                }
                catch (std::exception const& e)
                {
                    LOG_ERROR("server.tc9", "AsyncTask failed: {}", e.what());
                    ABORT("AsyncTask failed: {}", e.what());
                }
                isReady = true;
                return true;
            }
        }
        return false;
    }