func_result.h

Go to the documentation of this file.

#pragma once
#include "webcface/exception.h"
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
#include <optional>
#include <future>
#include <memory>
#include <stdexcept>
#include "field.h"
#include "webcface/common/val_adaptor.h"
#include "webcface/c_wcf/def_types.h"
 
WEBCFACE_NS_BEGIN
namespace internal {
struct PromiseData;
struct FuncInfo;
struct ClientData;
} // namespace internal
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4996)
#else
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
 
class WEBCFACE_DLL Promise : Field {
    std::shared_ptr<internal::PromiseData> data;
 
    static SanityError WEBCFACE_CALL invalidPromise();
 
  public:
    Promise(const Field &base,
            const std::shared_ptr<internal::PromiseData> &data,
            const std::shared_future<bool> &started,
            const std::shared_future<ValAdaptor> &result);
 
    using Field::member;
    using Field::name;
    using Field::nameW;
 
    [[deprecated(
        "use reached(), found() or waitReach()")]] std::shared_future<bool>
        started;
    [[deprecated(
        "use finished(), response(), rejection(), or waitFinish()")]] std::
        shared_future<ValAdaptor>
            result;
 
  private:
    void waitReachImpl(std::optional<std::chrono::microseconds> timeout) const;
    void waitFinishImpl(std::optional<std::chrono::microseconds> timeout) const;
 
  public:
    bool reached() const;
    bool found() const;
    Promise &waitReach() {
        waitReachImpl(std::nullopt);
        return *this;
    }
    Promise &waitReachFor(std::chrono::microseconds timeout) {
        waitReachImpl(timeout);
        return *this;
    }
    template <typename Clock, typename Duration>
    Promise &waitReachUntil(std::chrono::time_point<Clock, Duration> timeout) {
        waitReachImpl(std::chrono::duration_cast<std::chrono::microseconds>(
            timeout - Clock::now()));
        return *this;
    }
 
    bool finished() const;
    bool isError() const;
    ValAdaptor response() const;
    StringView rejection() const;
    WStringView rejectionW() const;
 
    Promise &waitFinish() {
        waitFinishImpl(std::nullopt);
        return *this;
    }
    Promise &waitFinishFor(std::chrono::microseconds timeout) {
        waitFinishImpl(timeout);
        return *this;
    }
    template <typename Clock, typename Duration>
    Promise &waitFinishUntil(std::chrono::time_point<Clock, Duration> timeout) {
        waitFinishImpl(std::chrono::duration_cast<std::chrono::microseconds>(
            timeout - Clock::now()));
        return *this;
    }
 
    Promise &onReach(std::function<void WEBCFACE_CALL_FP(Promise)> callback);
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    Promise &onReach(F callback) {
        return onReach(
            [callback = std::move(callback)](const Promise &) { callback(); });
    }
    Promise &onFinish(std::function<void WEBCFACE_CALL_FP(Promise)> callback);
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    Promise &onFinish(F callback) {
        return onFinish(
            [callback = std::move(callback)](const Promise &) { callback(); });
    }
};
 
#ifdef _MSC_VER
#pragma warning(pop)
#else
#pragma GCC diagnostic pop
#endif
 
using AsyncFuncResult = Promise;
 
class WEBCFACE_DLL CallHandle : Field {
    std::shared_ptr<internal::PromiseData> data;
 
    static SanityError WEBCFACE_CALL invalidHandle();
 
  public:
    CallHandle() = default;
    CallHandle(const Field &base,
               const std::shared_ptr<internal::PromiseData> &data);
 
    friend class Func;
    friend class FuncListener;
    friend struct internal::FuncInfo;
    friend struct internal::ClientData;
 
    using Field::name;
    using Field::nameW;
 
    const std::vector<ValAdaptor> &args() const;
    const wcfMultiVal *cArgs() const;
    const wcfMultiValW *cWArgs() const;
 
    void respond(const ValAdaptor &value) const;
    void reject(const ValAdaptor &message) const;
    void reach(bool found) const;
 
    bool assertArgsNum(std::size_t expected) const;
 
    template <typename T>
    void respond(const T &value) const {
        respond(ValAdaptor(value));
    }
    template <std::size_t N>
    void respond(const char (&value)[N]) const {
        respond(ValAdaptor(value));
    }
    template <std::size_t N>
    void respond(const wchar_t (&value)[N]) const {
        respond(ValAdaptor(value));
    }
    void respond() const { respond(ValAdaptor()); }
 
    void reject(StringInitializer message) const {
        reject(ValAdaptor(std::move(message)));
    }
 
    bool respondable() const;
};
using FuncCallHandle = CallHandle;
 
WEBCFACE_NS_END