AuroraRuntime/Include/Aurora/Async/JobFrom.hpp

/***
    Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: JobFrom.hpp
    Date: 2021-11-1
    Author: Reece
***/
 #pragma once

namespace Aurora::Async
{
    template<class Info_t = AVoid, class Result_t = AVoid, class Callable_t>
    static inline FJob<Info_t, Result_t> JobFromPairConsumer(const /*AuConsumer<const Info_t &, const Result_t &> */ Callable_t&onSuccess)
    {
        FJob<Info_t, Result_t> ret;
        ret.onSuccess = [=](const Info_t &in, const Result_t &a)
        {
            onSuccess(in, a);
        };
        return ret;
    }
    
    template<class Info_t = AVoid, class Result_t = AVoid, class Callable_t>
    static inline FJob<Info_t, Result_t> JobFromResultConsumer(/*AuConsumer<const Result_t &> */ Callable_t&&onSuccess)
    {
        FJob<Info_t, Result_t> ret;
        ret.onSuccess = [=](const Info_t &in, const Result_t &a)
        {
            onSuccess(a);
        };
        return ret;
    }
    
    template<typename Out_t = AVoid, typename ... Args, typename Callable_t>
    FJob<std::tuple<Args...>, Out_t> JobFromTupleConsumer(/*AuConsumer<Args..., const Result_t &> */ Callable_t &&onSuccess)
    {
        FJob<std::tuple<Args...>, Out_t> ret;
        static_assert(std::is_same_v<std::tuple<Args...>, std::tuple<AuUInt64, AuUInt64>>);
        ret.onSuccess = [=](const std::tuple<Args...> &in, const Out_t &a)
        {
            std::apply(onSuccess, std::tuple_cat(in, std::make_tuple<const Out_t &>(a)));
        };
        return ret;
    }
    
    template<typename Out_t = AVoid, typename ... Args, typename Callable_t, typename FailureCallable_t>
    FJob<std::tuple<Args...>, Out_t> JobFromTupleConsumerEx(/*AuConsumer<Args..., const Result_t &> */ Callable_t &&onSuccess, FailureCallable_t &&onFailure)
    {
        FJob<std::tuple<Args...>, Out_t> ret;
        static_assert(std::is_same_v<std::tuple<Args...>, std::tuple<AuUInt64, AuUInt64>>);
        ret.onSuccess = [=](const std::tuple<Args...> &in, const Out_t &a)
        {
            std::apply(onSuccess, std::tuple_cat(in, std::make_tuple<const Out_t &>(a)));
        };

        ret.onFailure = [=](const std::tuple<Args...> &in)
        {
            std::apply(onFailure, in);
        };
        return ret;
    }

    template<class Info_t = AVoid, class Result_t = AVoid>
    static inline FJob<Info_t, Result_t> JobFromPairConsumerEx(const AuConsumer<const Info_t &, const Result_t &> &onSuccess, const AuConsumer<const Info_t &> &onFailure)
    {
        FJob<Info_t, Result_t> ret;
        ret.onSuccess = [=](const Info_t &in, const Result_t &a)
        {
            onSuccess(in, a);
        };
        ret.onFailure = [=](const Info_t &a)
        {
            onFailure(a);
        };
        return ret;
    }
    
    template<class Info_t = AVoid, class Result_t = AVoid>
    static inline FJob<Info_t, Result_t> JobFromConsumer(const AuConsumer<const Result_t &> &onSuccess, const AuVoidFunc &onFailure)
    {
        FJob<Info_t, Result_t> ret;
        ret.onSuccess = [=](const Info_t &in, const Result_t &a)
        {
            onSuccess(a);
        };
        ret.onFailure = [=](const Info_t &a)
        {
            onFailure();
        };
        return ret;
    }
    
    template<class Info_t = AVoid, class Result_t = AVoid, class BaseInfo_t = AVoid, class BaseResult_t = AVoid>
    static inline FJob<Info_t, Result_t> JobFromDerivedJob(const FJob<BaseInfo_t, BaseResult_t> &reference)
    {
        FJob<Info_t, Result_t> ret;
        ret.onSuccess = [=](const Info_t &in, const Result_t &a)
        {
            if (reference.onSuccess)
            {
                reference.onSuccess(in, a);
            }
        };
        ret.onFailure = [=](const Info_t &a)
        {
            if (reference.onFailure)
            {
                reference.onFailure(a);
            }
        };
        return ret;
    }

    template<typename ReturnValue_t = void, typename Arg0_t, typename ... Args>
    static inline FJob<std::tuple<Arg0_t, Args...>, ReturnValue_t> JobFromTupleClazz(const AuConsumer<const Arg0_t &, const ReturnValue_t &> &onSuccess)
    {
        FJob<std::tuple<Arg0_t, Args...>, ReturnValue_t> ret;
        ret.onSuccess = [=](const std::tuple<Arg0_t, Args...> &in, const ReturnValue_t &out)
        {
            onSuccess(std::get<0>(in), out);
        };
        return ret;
    }

    template<typename ReturnValue_t = void, typename Arg0_t, typename ... Args>
    static inline FJob<std::tuple<Arg0_t, Args...>, ReturnValue_t> JobFromTupleClazzEx(const AuConsumer<const Arg0_t &, const ReturnValue_t &> &onSuccess, const AuConsumer<const Arg0_t &> &onFailure)
    {
        FJob<std::tuple<Arg0_t, Args...>, ReturnValue_t> ret;
        ret.onSuccess = [=](const std::tuple<Arg0_t, Args...> &in, const ReturnValue_t &out)
        {
            onSuccess(std::get<0>(in), out);
        };

        ret.onFailure = [=](const std::tuple<Arg0_t, Args...> &in)
        {
            onFailure(std::get<0>(in));
        };
        return ret;
    }

#if 0
    template<typename ReturnValue_t = void, typename Clazz_t, typename ... Args>
    static inline FJob<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> JobFromTupleClazz(const AuConsumer<const ReturnValue_t &> &onSuccess)
    {
        FJob<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> ret;
        ret.onSuccess = [=](const std::tuple<AuSPtr<Clazz_t>, Args...> &in, const ReturnValue_t &out)
        {
            onSuccess(out);
        };
        return ret;
    }
    
    template<typename ReturnValue_t = void, typename Clazz_t, typename ... Args>
    static inline FJob<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> JobFromTupleClazz(const AuConsumer<Args..., const ReturnValue_t &> &onSuccess)
    {
        FJob<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> ret;
        ret.onSuccess = [=](const std::tuple<AuSPtr<Clazz_t>, Args...> &in, const ReturnValue_t &out)
        {
            std::apply(onSuccess, std::tuple_cat(AuTuplePopFront(in), std::make_tuple<const ReturnValue_t &>(out)));
        };
        return ret;
    }
#endif
    
    template<typename ReturnValue_t = void, typename ... Args>
    static inline FJob<std::tuple<Args...>, ReturnValue_t> JobFromTupleResultConsumer(const AuConsumer<const ReturnValue_t &> &onSuccess)
    {
        FJob<std::tuple<Args...>, ReturnValue_t> ret;
        ret.onSuccess = [=](const std::tuple<Args...> &in, const ReturnValue_t &out)
        {
            onSuccess(out);
        };
        return ret;
    }
    
    template<typename ReturnValue_t = void, typename ... Args>
    static inline FJob<std::tuple<Args...>, ReturnValue_t> JobFromTuple(const AuConsumer<Args..., const ReturnValue_t &> &onSuccess)
    {
        FJob<std::tuple<Args...>, ReturnValue_t> ret;
        ret.onSuccess = [=](const std::tuple<Args...> &in, const ReturnValue_t &out)
        {
            std::apply(onSuccess, std::tuple_cat(in, std::make_tuple<const ReturnValue_t &>(out)));
        };
        return ret;
    }
}