func.h

Go to the documentation of this file.

#pragma once
#include "webcface/common/val_adaptor.h"
#include "func_result.h"
#include "arg.h"
#include "trait.h"
 
WEBCFACE_NS_BEGIN
namespace internal {
struct FuncInfo;
}
 
namespace traits {
template <typename T>
constexpr auto getInvokeSignature(T &&) -> decltype(&T::operator()) {
    return &T::operator();
}
template <typename Ret, typename... Args>
constexpr auto getInvokeSignature(Ret (*p)(Args...)) {
    return p;
}
template <typename T>
using InvokeSignature =
    decltype(getInvokeSignature(std::declval<std::decay_t<T>>()));
 
template <bool>
struct FuncArgTypeCheck {};
template <>
struct FuncArgTypeCheck<true> {
    using ArgTypesSupportedByWebCFaceFunc = TraitOkType;
};
template <typename... Args>
struct FuncArgTypesTrait
    : FuncArgTypeCheck<(std::is_convertible_v<ValAdaptor, Args> && ...)> {};
 
template <bool>
struct FuncReturnTypeCheck {};
template <>
struct FuncReturnTypeCheck<true> {
    using ReturnTypeSupportedByWebCFaceFunc = TraitOkType;
};
template <typename Ret>
struct FuncReturnTypeTrait
    : FuncReturnTypeCheck<std::is_same_v<Ret, void> ||
                          std::is_constructible_v<ValAdaptor, Ret>> {};
 
template <typename T>
struct FuncSignatureTrait {};
template <typename Ret, typename... Args>
struct FuncSignatureTrait<Ret(Args...)> {
    using ReturnTypeTrait = FuncReturnTypeTrait<Ret>;
    using ArgTypesTrait = FuncArgTypesTrait<Args...>;
    static constexpr bool return_void = std::is_same_v<Ret, void>;
    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>()}...};
    }
    using ReturnType = Ret;
    using ArgsTuple = std::tuple<std::decay_t<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<InvokeSignature<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::member;
    using Field::name;
    using Field::nameW;
    Func child(std::string_view field) const {
        return this->Field::child(field);
    }
    Func child(std::wstring_view field) const {
        return this->Field::child(field);
    }
    [[deprecated]]
    Func child(int index) const {
        return this->Field::child(std::to_string(index));
    }
    Func operator[](std::string_view field) const { return child(field); }
    Func operator[](std::wstring_view field) const { return child(field); }
    Func operator[](const char *field) const { return child(field); }
    Func operator[](const wchar_t *field) const { return child(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::
                  ReturnTypeSupportedByWebCFaceFunc = traits::TraitOk,
              typename traits::FuncObjTrait<T>::ArgTypesTrait::
                  ArgTypesSupportedByWebCFaceFunc = 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)) {
                    typename traits::FuncObjTrait<T>::ArgsTuple args_tuple;
                    argToTuple(handle.args(), args_tuple);
                    tryRun(
                        [&] {
                            if constexpr (traits::FuncObjTrait<
                                              T>::return_void) {
                                std::apply(func, args_tuple);
                                return ValAdaptor::emptyVal();
                            } else {
                                auto ret = std::apply(func, args_tuple);
                                return ret;
                            }
                        },
                        handle);
                }
            });
    }
    template <typename T,
              typename traits::FuncObjTrait<T>::ReturnTypeTrait::
                  ReturnTypeSupportedByWebCFaceFunc = traits::TraitOk,
              typename traits::FuncObjTrait<T>::ArgTypesTrait::
                  ArgTypesSupportedByWebCFaceFunc = 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)) {
                    typename traits::FuncObjTrait<T>::ArgsTuple args_tuple;
                    argToTuple(handle.args(), args_tuple);
                    std::thread(
                        [func_p, handle](auto args_tuple) {
                            tryRun(
                                [&] {
                                    if constexpr (traits::FuncObjTrait<
                                                      T>::return_void) {
                                        std::apply(*func_p, args_tuple);
                                        return ValAdaptor::emptyVal();
                                    } else {
                                        auto ret =
                                            std::apply(*func_p, args_tuple);
                                        return ret;
                                    }
                                },
                                handle);
                        },
                        std::move(args_tuple))
                        .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();
                }
            });
    }
 
    [[deprecated("Func::hidden() does nothing since ver1.10")]]
    const Func &hidden(bool) const {
        return *this;
    }
 
    const Func &free() const;
 
    template <typename... Args>
    [[deprecated("use runAsync")]]
    ValAdaptor run(Args... args) const {
        return run({ValAdaptor(args)...});
    }
    [[deprecated("use runAsync")]]
    ValAdaptor run(std::vector<ValAdaptor> &&args_vec) const {
        auto p = runAsync(std::move(args_vec));
        p.waitFinish();
        if (p.found()) {
            if (p.isError()) {
                throw std::runtime_error(p.rejection());
            } else {
                return p.response();
            }
        } else {
            throw FuncNotFound(*this);
        }
    }
    template <typename... Args>
    [[deprecated("use runAsync")]]
    ValAdaptor operator()(Args... args) const {
        return run(args...);
    }
 
    template <typename... Args>
    Promise runAsync(Args... args) const {
        return runAsync({ValAdaptor(args)...});
    }
    Promise runAsync(std::vector<ValAdaptor> args_vec) const;
 
    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;
    }
 
    [[deprecated("FuncListener::hidden() does nothing since ver1.10")]]
    FuncListener &hidden(bool) {
        return *this;
    }
    std::optional<FuncCallHandle> fetchCall() const;
};
 
WEBCFACE_NS_END