canvas3d.h

Go to the documentation of this file.

#pragma once
#include <vector>
#include <sstream>
#include <ostream>
#include <memory>
#include <utility>
#include <stdexcept>
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
#include "robot_model.h"
#include "components.h"
 
WEBCFACE_NS_BEGIN
namespace internal {
template <typename Component>
class DataSetBuffer;
}
 
class WEBCFACE_DLL Canvas3D : protected Field {
    std::shared_ptr<internal::DataSetBuffer<TemporalCanvas3DComponent>> sb;
 
  public:
    Canvas3D();
    Canvas3D(const Field &base);
    Canvas3D(const Field &base, const SharedString &field)
        : Canvas3D(Field{base, field}) {}
 
    friend internal::DataSetBuffer<Canvas3DComponent>;
    using Field::lastName;
    using Field::member;
    using Field::name;
    using Field::nameW;
    Canvas3D child(std::string_view field) const {
        return this->Field::child(field);
    }
    Canvas3D child(std::wstring_view field) const {
        return this->Field::child(field);
    }
    Canvas3D child(int index) const { return this->Field::child(index); }
    Canvas3D operator[](std::string_view field) const { return child(field); }
    Canvas3D operator[](std::wstring_view field) const { return child(field); }
    Canvas3D operator[](const char *field) const { return child(field); }
    Canvas3D operator[](const wchar_t *field) const { return child(field); }
    Canvas3D operator[](int index) const { return child(index); }
    Canvas3D parent() const { return this->Field::parent(); }
 
    const Canvas3D &
    onChange(std::function<void WEBCFACE_CALL_FP(Canvas3D)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Canvas3D &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 Canvas3D &request() const;
    std::optional<std::vector<Canvas3DComponent>> tryGet() const;
    std::vector<Canvas3DComponent> get() const {
        return tryGet().value_or(std::vector<Canvas3DComponent>{});
    }
    bool exists() const;
 
    [[deprecated]] std::chrono::system_clock::time_point time() const;
 
    const Canvas3D &free() const;
 
    const Canvas3D &init() const;
 
    const Canvas3D &operator<<(TemporalCanvas3DComponent cc) const;
 
    template <typename T>
    const Canvas3D &add(T &&cc) const {
        *this << std::forward<T>(cc);
        return *this;
    }
 
    template <bool V, bool C2>
    const Canvas3D &operator<<(TemporalComponent<V, C2, true> cc) const {
        *this << std::move(cc.component_3d);
        return *this;
    }
 
    const Canvas3D &sync() const;
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Canvas3D>,
                                                    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, Canvas3D>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
};
WEBCFACE_NS_END