robot_model.h

Go to the documentation of this file.

#pragma once
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
#include "robot_link.h"
#include "field.h"
#include "components.h"
 
WEBCFACE_NS_BEGIN
namespace internal {
template <typename Component>
class DataSetBuffer;
} // namespace internal
 
class WEBCFACE_DLL RobotModel : protected Field {
    std::shared_ptr<internal::DataSetBuffer<RobotLink>> sb;
 
  public:
    RobotModel();
    RobotModel(const Field &base);
    RobotModel(const Field &base, const SharedString &field)
        : RobotModel(Field{base, field}) {}
 
    friend class Canvas3D;
    friend class TemporalCanvas3DComponent;
    friend internal::DataSetBuffer<RobotLink>;
 
    using Field::lastName;
    using Field::member;
    using Field::name;
    using Field::nameW;
    RobotModel child(StringInitializer field) const {
        return this->Field::child(static_cast<SharedString&>(field));
    }
    [[deprecated]]
    RobotModel child(int index) const {
        return this->Field::child(std::to_string(index));
    }
    RobotModel operator[](StringInitializer field) const { return child(std::move(field)); }
    [[deprecated]]
    RobotModel operator[](int index) const {
        return child(std::to_string(index));
    }
    RobotModel parent() const { return this->Field::parent(); }
 
    const RobotModel &
    onChange(std::function<void WEBCFACE_CALL_FP(RobotModel)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const RobotModel &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 RobotModel &init() const;
    const RobotModel &operator<<(RobotLink rl) const;
    template <typename T>
    const RobotModel &add(T &&rl) const {
        *this << std::forward<T>(rl);
        return *this;
    }
    const RobotModel &sync() const;
 
    const RobotModel &set(const std::vector<RobotLink> &v) const;
    const RobotModel &operator=(const std::vector<RobotLink> &v) const {
        this->set(v);
        return *this;
    }
    const RobotModel &request() const;
    std::optional<std::vector<RobotLink>> tryGet() const;
    std::vector<RobotLink> get() const {
        return tryGet().value_or(std::vector<RobotLink>{});
    }
    operator std::vector<RobotLink>() const { return get(); }
    bool exists() const;
    [[deprecated]] std::chrono::system_clock::time_point time() const;
 
    const RobotModel &free() const;
 
    TemporalCanvas3DComponent toComponent3D() const;
    TemporalCanvas3DComponent origin(const Transform &origin) const {
        return toComponent3D().origin(origin);
    }
    TemporalCanvas3DComponent color(ViewColor color) const {
        return toComponent3D().color(color);
    }
    template <typename... Args>
    TemporalCanvas3DComponent angles(Args &&...args) const {
        return toComponent3D().angles(std::forward<Args>(args)...);
    }
 
    template <typename T,
              typename std::enable_if_t<std::is_same_v<T, RobotModel>,
                                        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, RobotModel>,
                                        std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
};
 
WEBCFACE_NS_END