member.h

Go to the documentation of this file.

#pragma once
#include <functional>
#include <string>
#include <vector>
#include <optional>
#include <chrono>
#include "field.h"
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
 
WEBCFACE_NS_BEGIN
 
class WEBCFACE_DLL Member : protected Field {
  public:
    Member() = default;
    Member(const std::weak_ptr<internal::ClientData> &data_w,
           const SharedString &member)
        : Field(data_w, member) {}
    Member(const Field &base) : Field(base.data_w, base.member_) {}
 
    friend struct internal::ClientData;
 
    StringView name() const { return member_.decodeShare(); }
    WStringView nameW() const { return member_.decodeShareW(); }
 
    using Field::child;
    using Field::operator[];
 
    using Field::canvas2D;
    using Field::canvas3D;
    using Field::func;
    using Field::funcListener;
    using Field::image;
    using Field::robotModel;
    using Field::text;
    using Field::value;
    using Field::view;
 
    template <WEBCFACE_COMPLETE(Log)>
    Log_ log(StringInitializer name) const {
        return this->child(static_cast<SharedString &>(name));
    }
    template <WEBCFACE_COMPLETE(Log)>
    Log_ log() const;
 
    using Field::canvas2DEntries;
    using Field::canvas3DEntries;
    using Field::children;
    using Field::childrenRecurse;
    using Field::funcEntries;
    using Field::hasChildren;
    using Field::imageEntries;
    using Field::logEntries;
    using Field::robotModelEntries;
    using Field::textEntries;
    using Field::valueEntries;
    using Field::viewEntries;
    [[deprecated]]
    std::vector<Value> values() const;
    [[deprecated]]
    std::vector<Text> texts() const;
    [[deprecated]]
    std::vector<RobotModel> robotModels() const;
    [[deprecated]]
    std::vector<Func> funcs() const;
    [[deprecated]]
    std::vector<View> views() const;
    [[deprecated]]
    std::vector<Image> images() const;
 
    bool exists() const;
    bool connected() const;
    const Member &
    onDisconnect(std::function<void WEBCFACE_CALL_FP(Member)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Member &onDisconnect(F callback) const {
        return onDisconnect(
            [callback = std::move(callback)](const auto &) { callback(); });
    }
    const Member &
    onConnect(std::function<void WEBCFACE_CALL_FP(Member)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Member &onConnect(F callback) const {
        return onConnect(
            [callback = std::move(callback)](const auto &) { callback(); });
    }
 
    const Member &
    onValueEntry(std::function<void WEBCFACE_CALL_FP(Value)> callback) const;
    const Member &
    onTextEntry(std::function<void WEBCFACE_CALL_FP(Text)> callback) const;
    const Member &onRobotModelEntry(
        std::function<void WEBCFACE_CALL_FP(RobotModel)> callback) const;
    const Member &
    onFuncEntry(std::function<void WEBCFACE_CALL_FP(Func)> callback) const;
    const Member &
    onImageEntry(std::function<void WEBCFACE_CALL_FP(Image)> callback) const;
    const Member &
    onViewEntry(std::function<void WEBCFACE_CALL_FP(View)> callback) const;
    const Member &onCanvas3DEntry(
        std::function<void WEBCFACE_CALL_FP(Canvas3D)> callback) const;
    const Member &onCanvas2DEntry(
        std::function<void WEBCFACE_CALL_FP(Canvas2D)> callback) const;
    const Member &
    onLogEntry(std::function<void WEBCFACE_CALL_FP(Log)> callback) const;
 
    const Member &
    onSync(std::function<void WEBCFACE_CALL_FP(Member)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Member &onSync(F callback) const {
        return onSync(
            [callback = std::move(callback)](const auto &) { callback(); });
    }
 
    std::chrono::system_clock::time_point syncTime() const;
    const std::string &libName() const;
    const std::string &libVersion() const;
    const std::string &remoteAddr() const;
 
    std::optional<int> pingStatus() const;
    const Member &
    onPing(std::function<void WEBCFACE_CALL_FP(Member)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Member &onPing(F callback) const {
        return onPing(
            [callback = std::move(callback)](const auto &) { callback(); });
    }
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Member>,
                                                    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, Member>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
};
extern template Log Member::log<Log, true>() const;
 
WEBCFACE_NS_END