146 lines
4.6 KiB
C++
146 lines
4.6 KiB
C++
#pragma once
|
|
|
|
namespace Aurora::Async
|
|
{
|
|
#pragma region EASE_OF_READING
|
|
struct BasicWorkStdFunc : IWorkItemHandler
|
|
{
|
|
AuFunction<void()> callback;
|
|
AuFunction<void()> shutdown; // error
|
|
|
|
BasicWorkStdFunc(AuFunction<void()> &&callback, AuFunction<void()> &&shutdown) : callback(std::move(callback)), shutdown(std::move(shutdown))
|
|
{}
|
|
|
|
BasicWorkStdFunc(AuFunction<void()> &&callback) : callback(std::move(callback))
|
|
{}
|
|
|
|
BasicWorkStdFunc(const AuFunction<void()> &callback) : callback(callback)
|
|
{}
|
|
|
|
BasicWorkStdFunc(const AuFunction<void()> &callback, const AuFunction<void()> &shutdown) : callback(callback), shutdown(shutdown)
|
|
{}
|
|
|
|
private:
|
|
#if !defined(_CPPSHARP)
|
|
void DispatchFrame(ProcessInfo &info) override
|
|
{
|
|
try
|
|
{
|
|
callback();
|
|
}
|
|
catch (...)
|
|
{
|
|
Debug::PrintError();
|
|
}
|
|
}
|
|
|
|
void Shutdown() override
|
|
{
|
|
try
|
|
{
|
|
if (shutdown)
|
|
{
|
|
shutdown();
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
Debug::PrintError();
|
|
}
|
|
}
|
|
#endif
|
|
};
|
|
|
|
|
|
/// @hideinitializer
|
|
template<typename Frame_t = AuFunction<void()>, typename Cleanup_t = AuFunction<void()>>
|
|
struct WorkItemCallable : IWorkItemHandler
|
|
{
|
|
Frame_t frame;
|
|
Cleanup_t cleanup;
|
|
|
|
private:
|
|
void DispatchFrame(ProcessInfo &info) override
|
|
{
|
|
if constexpr (AuIsBaseOfTemplate<AuFunction, Frame_t>::value)
|
|
{
|
|
if (!frame)
|
|
{
|
|
info.type = IWorkItemHandler::EProcessNext::eFinished;
|
|
return;
|
|
}
|
|
}
|
|
frame();
|
|
info.type = IWorkItemHandler::EProcessNext::eFinished;
|
|
}
|
|
|
|
void Shutdown() override
|
|
{
|
|
if constexpr (AuIsBaseOfTemplate<AuFunction, Cleanup_t>::value)
|
|
{
|
|
if (!cleanup)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
cleanup();
|
|
}
|
|
};
|
|
|
|
|
|
#define ASYNC_ERROR(exp) { if constexpr (AuIsSame_v<T, bool>) { SysPushErrorGen(exp); return {}; } else { throw AuString(exp); } }
|
|
#define ASYNC_FINISH { if constexpr (AuIsSame_v<T, bool>) { return true; } }
|
|
|
|
template<typename T = void, typename... Args, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<T, bool> || AuIsVoid_v<T>)>
|
|
static AuFunction<T(Args&&...)> TranslateAsyncFunctionToDispatcherWithThread(WorkerId_t id, AuFunction<void(Args...)> func)
|
|
{
|
|
if (!func) return {};
|
|
return [=](Args&&... in) -> T
|
|
{
|
|
auto work = AuMakeShared<BasicWorkStdFunc>([=]() -> void {
|
|
func(in...);
|
|
});
|
|
if (!work) ASYNC_ERROR("can't dispatch async call. out of memory");
|
|
auto workItem = NewWorkItem(id, work);
|
|
if (!workItem) ASYNC_ERROR("can't dispatch async call. out of memory");
|
|
workItem->Dispatch();
|
|
ASYNC_FINISH;
|
|
};
|
|
}
|
|
|
|
/// Async app only
|
|
template<typename T = void, typename... Args, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<T, bool> || AuIsVoid_v<T>)>
|
|
static AuFunction<T(Args&&...)> TranslateAsyncFunctionToDispatcher(AuFunction<void(Args...)> func)
|
|
{
|
|
return TranslateAsyncFunctionToDispatcherWithThread(GetAsyncApp()->GetCurrentThread(), func);
|
|
}
|
|
|
|
/// Async app only
|
|
template<typename B = void, typename T, typename... Args, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<T, bool> || AuIsVoid_v<T>)>
|
|
static AuFunction<T(AuFunction<void(const B&)>, Args...)> TranslateAsyncReturnableFunctionToDispatcherWithThread(WorkerId_t id, AuFunction<B(Args...)> func)
|
|
{
|
|
return [=](AuFunction<T(const B&)> callback, Args... in) -> T
|
|
{
|
|
auto work = AuMakeShared<WorkPairImpl<AVoid, B>>();
|
|
if (!work) ASYNC_ERROR("can't dispatch async call; out of memory");
|
|
work.task.onProcess = [=](const AVoid &) -> B
|
|
{
|
|
if (!func) return B{};
|
|
return func(in...);
|
|
};
|
|
work.callback.onSuccess = [=](const AVoid &, const B &ret)
|
|
{
|
|
callback(ret);
|
|
};
|
|
auto workItem = NewWorkItem(id, work);
|
|
if (!workItem) ASYNC_ERROR("can't dispatch async call; out of memory");
|
|
workItem->Dispatch();
|
|
ASYNC_FINISH;
|
|
};
|
|
}
|
|
|
|
#undef ASYNC_ERROR
|
|
#undef ASYNC_FINISH
|
|
|
|
#pragma endregion EASE_OF_READING
|
|
} |