view.h

Go to the documentation of this file.

#pragma once
#include <vector>
#include <ostream>
#include <memory>
#include <utility>
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
#include "components.h"
#include "trait.h"
 
WEBCFACE_NS_BEGIN
namespace internal {
template <typename Component>
class DataSetBuffer;
class ViewBuf;
} // namespace internal
 
namespace traits {
template <typename T>
using EnableIfFormattable =
    decltype(std::declval<std::ostream>() << std::declval<T>(), TraitOk);
template <typename T>
using EnableIfViewInvocable =
    decltype(std::declval<T>()(std::declval<View>()), TraitOk);
} // namespace traits
 
class WEBCFACE_DLL View : protected Field {
    std::shared_ptr<internal::ViewBuf> sb;
    mutable std::ostream os;
 
  public:
    View();
    View(const Field &base);
    View(const Field &base, const SharedString &field)
        : View(Field{base, field}) {}
    View(const View &rhs) : View() { *this = rhs; }
    View(View &&rhs) noexcept : View() { *this = std::move(rhs); }
    View &operator=(const View &rhs);
    View &operator=(View &&rhs) noexcept;
    ~View();
 
    friend internal::DataSetBuffer<ViewComponent>;
 
    using Field::lastName;
    using Field::member;
    using Field::name;
    using Field::nameW;
    View child(std::string_view field) const {
        return this->Field::child(field);
    }
    View child(std::wstring_view field) const {
        return this->Field::child(field);
    }
    [[deprecated]]
    View child(int index) const {
        return this->Field::child(std::to_string(index));
    }
    View operator[](std::string_view field) const { return child(field); }
    View operator[](std::wstring_view field) const { return child(field); }
    View operator[](const char *field) const { return child(field); }
    View operator[](const wchar_t *field) const { return child(field); }
    [[deprecated]]
    View operator[](int index) const {
        return child(std::to_string(index));
    }
    View parent() const { return this->Field::parent(); }
 
    const View &
    onChange(std::function<void WEBCFACE_CALL_FP(View)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const View &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));
    }
 
    const View &request() const;
    std::optional<std::vector<ViewComponent>> tryGet() const;
    std::vector<ViewComponent> get() const {
        return tryGet().value_or(std::vector<ViewComponent>{});
    }
    bool exists() const;
    [[deprecated]] std::chrono::system_clock::time_point time() const;
 
    const View &free() const;
 
    const View &init() const;
    template <typename T, traits::EnableIfFormattable<T> = traits::TraitOk>
    const View &operator<<(T &&rhs) const {
        os << std::forward<T>(rhs);
        return *this;
    }
    const View &operator<<(std::ostream &(*os_manip)(std::ostream &)) const {
        os_manip(os);
        return *this;
    }
    template <bool C2, bool C3>
    const View &operator<<(TemporalComponent<true, C2, C3> vc) const {
        *this << std::move(vc.component_v);
        return *this;
    }
    const View &operator<<(TemporalViewComponent vc) const;
    template <typename F, traits::EnableIfViewInvocable<F> = traits::TraitOk>
    const View &operator<<(const F &manip) const {
        manip(*this);
        return *this;
    }
 
    template <typename T>
    const View &add(T &&rhs) const {
        *this << std::forward<T>(rhs);
        return *this;
    }
 
    std::ostreambuf_iterator<char> inserter() const {
        return std::ostreambuf_iterator<char>(os);
    }
    std::ostream &ostream() const { return os; }
 
    const View &sync() const;
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, View>,
                                                    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, View>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
};
WEBCFACE_NS_END