text.h

Go to the documentation of this file.

#pragma once
#include <functional>
#include <ostream>
#include <optional>
#include <chrono>
#include <memory>
#include "field.h"
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
#include "webcface/common/val_adaptor.h"
 
WEBCFACE_NS_BEGIN
 
class WEBCFACE_DLL Variant : protected Field {
  public:
    Variant() = default;
    Variant(const Field &base);
    Variant(const Field &base, const SharedString &field)
        : Variant(Field{base, field}) {}
 
    friend class InputRef;
    friend struct InputRefState;
    friend class TemporalViewComponent;
 
    const Variant &
    onChange(std::function<void WEBCFACE_CALL_FP(Variant)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Variant &onChange(F callback) const {
        return onChange(
            [callback = std::move(callback)](const auto &) { callback(); });
    }
    template <typename T>
    [[deprecated]] void appendListener(T &&callback) const {
        onChange(std::forward<T>(callback));
    }
 
  protected:
    const Variant &set(const ValAdaptor &v) const;
 
  public:
    const Variant &request() const;
    std::optional<ValAdaptor> tryGet() const;
    const ValAdaptor &get() const;
 
    template <typename T,
              typename std::enable_if_t<std::is_convertible_v<ValAdaptor, T>,
                                        std::nullptr_t> = nullptr>
    operator T() const {
        return static_cast<T>(get());
    }
    bool empty() const { return get().empty(); }
    const std::string &asStringRef() const { return get().asStringRef(); }
    const std::wstring &asWStringRef() const { return get().asWStringRef(); }
    std::string asString() const { return get().asString(); }
    std::wstring asWString() const { return get().asWString(); }
    double asDouble() const { return get().asDouble(); }
    int asInt() const { return get().asInt(); }
    long long asLLong() const { return get().asLLong(); }
    bool asBool() const { return get().asBool(); }
 
    template <typename T,
              typename std::enable_if_t<std::is_constructible_v<ValAdaptor, T>,
                                        std::nullptr_t> = nullptr>
    bool operator==(const T &other) const {
        return get() == other;
    }
    template <typename T,
              typename std::enable_if_t<std::is_constructible_v<ValAdaptor, T>,
                                        std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return get() != other;
    }
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Variant>,
                                                    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, Variant>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
    bool operator<(const Variant &) const = delete;
    bool operator<=(const Variant &) const = delete;
    bool operator>(const Variant &) const = delete;
    bool operator>=(const Variant &) const = delete;
};
 
 
class WEBCFACE_DLL Text : protected Variant {
  public:
    Text() = default;
    Text(const Field &base) : Variant(base) {}
    Text(const Field &base, const SharedString &field)
        : Text(Field{base, field}) {}
 
    using Field::lastName;
    using Field::member;
    using Field::name;
    using Field::nameW;
    Text child(std::string_view field) const {
        return this->Field::child(field);
    }
    Text child(std::wstring_view field) const {
        return this->Field::child(field);
    }
    [[deprecated]]
    Text child(int index) const {
        return this->Field::child(std::to_string(index));
    }
    Text operator[](std::string_view field) const { return child(field); }
    Text operator[](std::wstring_view field) const { return child(field); }
    Text operator[](const char *field) const { return child(field); }
    Text operator[](const wchar_t *field) const { return child(field); }
    [[deprecated]]
    Text operator[](int index) const {
        return child(std::to_string(index));
    }
    Text parent() const { return this->Field::parent(); }
 
    template <typename F,
              typename std::enable_if_t<std::is_invocable_v<F, Text>,
                                        std::nullptr_t> = nullptr>
    const Text &onChange(F callback) const {
        this->Variant::onChange(
            [callback = std::move(callback)](const Variant &base) {
                callback(Text(base));
            });
        return *this;
    }
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Text &onChange(F callback) const {
        this->Variant::onChange(
            [callback = std::move(callback)](const auto &) { callback(); });
        return *this;
    }
    template <typename T>
    [[deprecated]] void appendListener(T &&callback) const {
        onChange(std::forward<T>(callback));
    }
 
    const Text &set(std::string_view v) const {
        this->Variant::set(ValAdaptor{v});
        return *this;
    }
    const Text &set(std::wstring_view v) const {
        this->Variant::set(ValAdaptor{v});
        return *this;
    }
 
    const Text &operator=(std::string_view v) const {
        this->set(v);
        return *this;
    }
    const Text &operator=(std::wstring_view v) const {
        this->set(v);
        return *this;
    }
 
    const Text &request() const {
        this->Variant::request();
        return *this;
    }
    std::optional<std::string> tryGet() const;
    std::optional<std::wstring> tryGetW() const;
    const std::string &get() const;
    const std::wstring &getW() const;
 
    operator const std::string &() const { return get(); }
    operator const std::wstring &() const { return getW(); }
 
    bool exists() const;
 
    [[deprecated]] std::chrono::system_clock::time_point time() const;
 
    const Text &free() const;
 
    bool operator==(std::string_view rhs) const { return this->get() == rhs; }
    bool operator!=(std::string_view rhs) const { return this->get() != rhs; }
    bool operator==(std::wstring_view rhs) const { return this->getW() == rhs; }
    bool operator!=(std::wstring_view rhs) const { return this->getW() != rhs; }
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Text>,
                                                    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, Text>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
    bool operator<(const Text &) const = delete;
    bool operator<=(const Text &) const = delete;
    bool operator>(const Text &) const = delete;
    bool operator>=(const Text &) const = delete;
};
 
WEBCFACE_DLL std::ostream &WEBCFACE_CALL operator<<(std::ostream &os,
                                                    const Text &data);
 
namespace internal {
struct InputRefState;
}
 
class WEBCFACE_DLL InputRef {
    std::shared_ptr<internal::InputRefState> state;
 
    void lockTo(const Variant &target);
    Variant &lockedField() const;
 
  public:
    friend class TemporalViewComponent;
 
    InputRef();
    InputRef(const InputRef &) = default;
    InputRef &operator=(const InputRef &) = default;
    InputRef(InputRef &&) = delete;
    InputRef &operator=(InputRef &&) = delete;
    ~InputRef() = default;
 
    const ValAdaptor &get() const;
 
    template <typename T,
              typename std::enable_if_t<std::is_convertible_v<ValAdaptor, T>,
                                        std::nullptr_t> = nullptr>
    operator T() const {
        return static_cast<T>(get());
    }
 
    bool empty() const { return get().empty(); }
 
    const std::string &asStringRef() const { return get().asStringRef(); }
    const std::wstring &asWStringRef() const { return get().asWStringRef(); }
    std::string asString() const { return get().asString(); }
    std::wstring asWString() const { return get().asWString(); }
    double asDouble() const { return get().asDouble(); }
    int asInt() const { return get().asInt(); }
    long long asLLong() const { return get().asLLong(); }
    template <typename T>
    [[deprecated("use asDouble(), asInt() or asLLong() instead")]]
    double as() const {
        return get().as<T>();
    }
 
    bool asBool() const { return get().asBool(); }
 
    template <typename T,
              typename std::enable_if_t<std::is_constructible_v<ValAdaptor, T>,
                                        std::nullptr_t> = nullptr>
    bool operator==(const T &other) const {
        return get() == other;
    }
    template <typename T,
              typename std::enable_if_t<std::is_constructible_v<ValAdaptor, T>,
                                        std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return get() != other;
    }
};
 
template <typename T,
          typename std::enable_if_t<std::is_constructible_v<ValAdaptor, T>,
                                    std::nullptr_t> = nullptr>
bool operator==(const T &other, const InputRef &ref) {
    return ref.get() == other;
}
template <typename T,
          typename std::enable_if_t<std::is_constructible_v<ValAdaptor, T>,
                                    std::nullptr_t> = nullptr>
bool operator!=(const T &other, const InputRef &ref) {
    return ref.get() != other;
}
inline std::ostream &operator<<(std::ostream &os, const InputRef &ref) {
    return os << ref.get();
}
WEBCFACE_NS_END