func.h

Go to the documentation of this file.

#pragma once
#include "webcface/common/val_adaptor_vec.h"
#include "func_result.h"
#include "arg.h"
#include "webcface/common/trait.h"
#include "func_trait.h"
#include "exception.h"
#include <thread>
 
WEBCFACE_NS_BEGIN
namespace internal {
struct FuncInfo;
}
 
namespace traits {
template <typename BadArg>
struct This_arg_type_is_not_supported_by_WebCFace_Func {};
template <typename BadArg>
struct FuncArgTypesIterationFailureTrait {
    using ArgTypesCheckResult =
        This_arg_type_is_not_supported_by_WebCFace_Func<BadArg>;
};
// MSVCでexplicitな変換operatorがあるとき
// std::is_constructible_t<Arg, ValAdaptor> が正しくtrueを返さないため、
// decltypeで実装している
template <typename Arg, typename = void>
struct IsConstructibleArg : std::false_type {};
template <>
struct IsConstructibleArg<ValAdaptor, void> : std::true_type {};
template <>
struct IsConstructibleArg<ValAdaptorVector, void> : std::true_type {};
template <typename Arg>
struct IsConstructibleArg<
    Arg, std::void_t<decltype(std::declval<ValAdaptorVector>().operator Arg())>>
    : std::true_type {};
 
template <typename... Args>
struct FuncArgTypesIterationTrait;
template <>
struct FuncArgTypesIterationTrait<> {
    struct ArgTypesCheckResult {
        using ArgTypesCheckOk = TraitOkType;
    };
};
template <typename FirstArg, typename... OtherArgs>
struct FuncArgTypesIterationTrait<FirstArg, OtherArgs...> {
    using ArgTypesCheckResult = typename std::conditional_t<
        IsConstructibleArg<std::decay_t<FirstArg>>::value,
        FuncArgTypesIterationTrait<OtherArgs...>,
        FuncArgTypesIterationFailureTrait<FirstArg>>::ArgTypesCheckResult;
};
template <typename... Args>
using FuncArgTypesTrait =
    typename FuncArgTypesIterationTrait<Args...>::ArgTypesCheckResult;
 
template <typename BadArg>
struct This_return_type_is_not_supported_by_WebCFace_Func {};
struct FuncReturnTypeCheckOkTrait {
    using FuncReturnTypeCheckOk = TraitOkType;
};
template <typename Ret>
using FuncReturnTypeTrait = std::conditional_t<
    std::disjunction_v<std::is_void<Ret>,
                       std::is_constructible<ValAdaptorVector, Ret>>,
    FuncReturnTypeCheckOkTrait,
    This_return_type_is_not_supported_by_WebCFace_Func<Ret>>;
 
template <typename T>
struct FuncSignatureTrait {};
template <typename Ret, typename... Args>
struct FuncSignatureTrait<Ret(Args...)> : InvokeSignatureTrait<Ret(Args...)> {
    using ReturnTypeTrait = FuncReturnTypeTrait<Ret>;
    using ArgTypesTrait = FuncArgTypesTrait<Args...>;
    static constexpr bool return_void = std::is_void_v<Ret>;
    static inline bool assertArgsNum(const CallHandle &handle) {
        return handle.assertArgsNum(sizeof...(Args));
    }
    static inline std::vector<Arg> argsInfo() {
        return std::vector<Arg>{Arg{valTypeOf<Args>()}...};
    }
};
template <typename Ret, typename T, typename... Args>
struct FuncSignatureTrait<Ret (T::*)(Args...)>
    : FuncSignatureTrait<Ret(Args...)> {};
template <typename Ret, typename T, typename... Args>
struct FuncSignatureTrait<Ret (T::*)(Args...) const>
    : FuncSignatureTrait<Ret(Args...)> {};
template <typename Ret, typename... Args>
struct FuncSignatureTrait<Ret (*)(Args...)> : FuncSignatureTrait<Ret(Args...)> {
};
 
template <typename T>
using FuncObjTrait = FuncSignatureTrait<decltype(getInvokeSignature(
    std::declval<std::decay_t<T>>()))>;
 
} // namespace traits
 
class WEBCFACE_DLL Func : protected Field {
  public:
    friend class TemporalViewComponent;
    friend class TemporalCanvas2DComponent;
 
    Func() = default;
    Func(const Field &base);
    Func(const Field &base, const SharedString &field)
        : Func(Field{base, field}) {}
 
    using Field::lastName;
    using Field::lastNameW;
    using Field::member;
    using Field::name;
    using Field::nameW;
    Func child(StringInitializer field) const {
        return this->Field::child(static_cast<SharedString &>(field));
    }
    [[deprecated]]
    Func child(int index) const {
        return this->Field::child(std::to_string(index));
    }
    Func operator[](StringInitializer field) const {
        return child(std::move(field));
    }
    [[deprecated]]
    Func operator[](int index) const {
        return child(std::to_string(index));
    }
    Func parent() const { return this->Field::parent(); }
 
    using FuncType = void WEBCFACE_CALL_FP(CallHandle);
 
  protected:
    const Func &setImpl(ValType return_type, std::vector<Arg> &&args,
                        std::function<FuncType> &&func_impl) const;
    const Func &setImpl(ValType return_type, std::nullopt_t,
                        std::function<FuncType> &&func_impl) const;
    const Func &
    setImpl(const std::shared_ptr<internal::FuncInfo> &func_info) const;
 
    template <typename F1>
    static void catchAll(F1 &&f_run, const CallHandle &handle) {
        ValAdaptor error;
        try {
            f_run();
            return;
        } catch (const std::exception &e) {
            error = e.what();
        } catch (const std::string &e) {
            error = e;
        } catch (const char *e) {
            error = e;
        } catch (const std::wstring &e) {
            error = e;
        } catch (const wchar_t *e) {
            error = e;
        } catch (...) {
            error = "unknown exception";
        }
        handle.reject(error);
    }
    template <typename F1>
    static void tryRun(F1 &&f_run, const CallHandle &handle) {
        catchAll([&] { handle.respond(f_run()); }, handle);
    }
 
  public:
    template <typename T,
              typename traits::FuncObjTrait<
                  T>::ReturnTypeTrait::FuncReturnTypeCheckOk = traits::TraitOk,
              typename traits::FuncObjTrait<T>::ArgTypesTrait::ArgTypesCheckOk =
                  traits::TraitOk>
    const Func &set(T func) const {
        return setImpl(
            valTypeOf<typename traits::FuncObjTrait<T>::ReturnType>(),
            traits::FuncObjTrait<T>::argsInfo(),
            [func = std::move(func)](const CallHandle &handle) {
                if (traits::FuncObjTrait<T>::assertArgsNum(handle)) {
                    tryRun(
                        [&] {
                            typename traits::FuncObjTrait<T>::ArgsTuple
                                args_tuple;
                            argToTuple(handle.args(), args_tuple);
                            if constexpr (traits::FuncObjTrait<
                                              T>::return_void) {
                                std::apply(func, args_tuple);
                                return ValAdaptorVector();
                            } else {
                                auto ret = std::apply(func, args_tuple);
                                return ValAdaptorVector(ret);
                            }
                        },
                        handle);
                }
            });
    }
    template <typename T,
              typename traits::FuncObjTrait<
                  T>::ReturnTypeTrait::FuncReturnTypeCheckOk = traits::TraitOk,
              typename traits::FuncObjTrait<T>::ArgTypesTrait::ArgTypesCheckOk =
                  traits::TraitOk>
    const Func &setAsync(T func) const {
        return setImpl(
            valTypeOf<typename traits::FuncObjTrait<T>::ReturnType>(),
            traits::FuncObjTrait<T>::argsInfo(),
            [func_p = std::make_shared<T>(std::move(func))](
                const CallHandle &handle) {
                if (traits::FuncObjTrait<T>::assertArgsNum(handle)) {
                    std::thread([func_p, handle]() {
                        tryRun(
                            [&] {
                                typename traits::FuncObjTrait<T>::ArgsTuple
                                    args_tuple;
                                argToTuple(handle.args(), args_tuple);
                                if constexpr (traits::FuncObjTrait<
                                                  T>::return_void) {
                                    std::apply(*func_p, args_tuple);
                                    return ValAdaptorVector();
                                } else {
                                    auto ret = std::apply(*func_p, args_tuple);
                                    return ValAdaptorVector(ret);
                                }
                            },
                            handle);
                    }).detach();
                }
            });
    }
    template <typename T>
    [[deprecated("use set() or setAsync()")]]
    const Func &operator=(T func) const {
        this->set(std::move(func));
        return *this;
    }
 
    template <typename T,
              typename std::enable_if_t<
                  std::is_same_v<std::invoke_result_t<T, CallHandle>, void>,
                  std::nullptr_t> = nullptr>
    const Func &set(std::vector<Arg> args, ValType return_type,
                    T callback) const {
        auto args_size = args.size();
        return setImpl(return_type, std::move(args),
                       [args_size, callback = std::move(callback)](
                           const CallHandle &handle) {
                           if (handle.assertArgsNum(args_size)) {
                               catchAll([&] { callback(handle); }, handle);
                           }
                       });
    }
    template <typename T,
              typename std::enable_if_t<
                  std::is_same_v<std::invoke_result_t<T, CallHandle>, void>,
                  std::nullptr_t> = nullptr>
    const Func &setAsync(std::vector<Arg> args, ValType return_type,
                         T callback) const {
        auto args_size = args.size();
        return setImpl(
            return_type, std::move(args),
            [args_size,
             callback = std::make_shared<std::function<void(FuncCallHandle)>>(
                 std::move(callback))](const CallHandle &handle) {
                if (handle.assertArgsNum(args_size)) {
                    std::thread([callback, handle] {
                        catchAll([&] { callback->operator()(handle); }, handle);
                    }).detach();
                }
            });
    }
    template <typename T,
              typename std::enable_if_t<
                  std::is_same_v<std::invoke_result_t<T, CallHandle>, void>,
                  std::nullptr_t> = nullptr>
    const Func &set(T callback) const {
        return setImpl(ValType::none_, std::nullopt,
                       [base = *this, callback = std::move(callback)](
                           const CallHandle &handle) {
                           if (handle.assertArgsNum(base.args().size())) {
                               catchAll([&] { callback(handle); }, handle);
                           }
                       });
    }
    template <typename T,
              typename std::enable_if_t<
                  std::is_same_v<std::invoke_result_t<T, CallHandle>, void>,
                  std::nullptr_t> = nullptr>
    const Func &setAsync(T callback) const {
        return setImpl(
            ValType::none_, std::nullopt,
            [base = *this,
             callback = std::make_shared<std::function<void(FuncCallHandle)>>(
                 std::move(callback))](const CallHandle &handle) {
                if (handle.assertArgsNum(base.args().size())) {
                    std::thread([callback, handle] {
                        catchAll([&] { callback->operator()(handle); }, handle);
                    }).detach();
                }
            });
    }
 
    const Func &free() const;
 
    template <typename... Args>
    Promise runAsync(Args... args) const {
        return runAsync(
            std::vector<ValAdaptorVector>{ValAdaptorVector(args)...});
    }
    Promise runAsync(std::vector<ValAdaptorVector> args_vec) const;
    Promise runAsync(std::vector<ValAdaptor> args_vec) const {
        return runAsync(
            std::vector<ValAdaptorVector>(args_vec.begin(), args_vec.end()));
    }
 
    bool exists() const;
    int index() const;
    const Func &setIndex(int index) const;
 
    ValType returnType() const;
    std::vector<Arg> args() const;
 
    const Arg args(std::size_t i) const { return args().at(i); }
 
    const Func &setArgs(const std::vector<Arg> &args) const;
    const Func &setReturnType(ValType return_type) const;
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Func>,
                                                    std::nullptr_t> = nullptr>
    bool operator==(const T &other) const {
        return static_cast<Field>(*this) == static_cast<Field>(other);
    }
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Func>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
};
 
class WEBCFACE_DLL FuncListener : protected Func {
    ValType return_type_ = ValType::none_;
    std::vector<Arg> args_{};
 
  public:
    FuncListener() = default;
    FuncListener(const Field &base);
    FuncListener(const Field &base, const SharedString &field)
        : FuncListener(Field{base, field}) {}
 
    friend class TemporalViewComponent;
    friend class TemporalCanvas2DComponent;
    using Field::member;
    using Field::name;
 
    FuncListener &listen();
    FuncListener &listen(std::size_t args_num,
                         ValType return_type = ValType::none_) {
        this->args_.resize(args_num);
        this->return_type_ = return_type;
        listen();
        return *this;
    }
 
    FuncListener &setArgs(const std::vector<Arg> &args) {
        this->args_ = args;
        return *this;
    }
    FuncListener &setReturnType(ValType type) {
        this->return_type_ = type;
        return *this;
    }
 
    std::optional<FuncCallHandle> fetchCall() const;
};
 
WEBCFACE_NS_END