value.h

Go to the documentation of this file.

#pragma once
#include <functional>
#include <ostream>
#include <optional>
#include <chrono>
#include "field.h"
#include "webcface/common/array_like.h"
#include "webcface/common/num_vector.h"
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
 
WEBCFACE_NS_BEGIN
 
class WEBCFACE_DLL ValueElementRef : protected Field {
    std::size_t index;
 
  public:
    ValueElementRef(const Field &base, std::size_t index)
        : Field(base), index(index) {}
 
    const ValueElementRef &set(double v) const;
    const ValueElementRef &operator=(double v) const { return set(v); }
 
    std::optional<double> tryGet() const;
    double get() const { return tryGet().value_or(0); }
};
 
class WEBCFACE_DLL Value : protected Field {
  public:
    Value() = default;
    Value(const Field &base);
    Value(const Field &base, const SharedString &field)
        : Value(Field{base, field}) {}
 
    friend class ValueElementRef;
 
    using Field::lastName;
    using Field::lastNameW;
    using Field::member;
    using Field::name;
    using Field::nameW;
    Value child(StringInitializer field) const {
        return this->Field::child(static_cast<SharedString &>(field));
    }
    [[deprecated]]
    Value child(int index) const {
        return this->Field::child(std::to_string(index));
    }
    Value operator[](StringInitializer field) const {
        return child(std::move(field));
    }
    Value operator[](const char *field) const { return child(field); }
    Value operator[](const wchar_t *field) const { return child(field); }
    template <typename CharT, std::size_t N,
              typename std::enable_if_t<std::is_same_v<CharT, char> ||
                                            std::is_same_v<CharT, wchar_t>,
                                        std::nullptr_t> = nullptr>
    Value operator[](const CharT (&static_str)[N]) {
        return child(StringInitializer(static_str));
    }
    template <std::size_t N>
    Value operator[](const wchar_t (&static_str)[N]) {
        return child(StringInitializer(static_str));
    }
    template <typename T,
              std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>
    ValueElementRef operator[](T index) const {
        return ValueElementRef(*this, index);
    }
    ValueElementRef at(std::size_t index) const {
        return ValueElementRef(*this, index);
    }
    Value parent() const { return this->Field::parent(); }
 
    const Value &
    onChange(std::function<void WEBCFACE_CALL_FP(Value)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Value &onChange(F callback) const {
        return onChange(
            [callback = std::move(callback)](const auto &) { callback(); });
    }
 
    const Value &set(double v) const;
    const Value &set(std::vector<double> v) const;
    template <typename R,
              typename traits::ArrayLikeTrait<R>::ArrayLike = traits::TraitOk>
    const Value &set(const R &range) const {
        return set(traits::arrayLikeToVector(range));
    }
    const Value &resize(std::size_t size) const;
    const Value &push_back(double v) const;
    std::size_t size() const;
 
    template <typename T>
    const Value &operator=(T &&v) const {
        this->set(std::forward<T>(v));
        return *this;
    }
    const Value &operator=(std::vector<double> v) const {
        this->set(std::move(v));
        return *this;
    }
 
    const Value &request() const;
    std::optional<double> tryGet() const;
    std::optional<NumVector> tryGetVec() const;
    double get() const { return tryGet().value_or(0); }
    NumVector getVec() const {
        return tryGetVec().value_or(std::vector<double>{});
    }
    operator double() const { return get(); }
    operator std::vector<double>() const { return getVec(); }
    operator NumVector() const { return getVec(); }
 
    bool exists() const;
 
    const Value &free() const;
 
    const Value &operator+=(double rhs) const {
        this->set(this->get() + rhs);
        return *this;
    }
    const Value &operator-=(double rhs) const {
        this->set(this->get() - rhs);
        return *this;
    }
    const Value &operator*=(double rhs) const {
        this->set(this->get() * rhs);
        return *this;
    }
    const Value &operator/=(double rhs) const {
        this->set(this->get() / rhs);
        return *this;
    }
    const Value &operator%=(std::int32_t rhs) const {
        this->set(static_cast<std::int32_t>(this->get()) % rhs);
        return *this;
    }
    const Value &operator<<=(std::int32_t rhs) const {
        // todo: int64_tかuint64_tにしたほうがいいかもしれない
        this->set(static_cast<std::int32_t>(this->get()) << rhs);
        return *this;
    }
    const Value &operator>>=(std::int32_t rhs) const {
        this->set(static_cast<std::int32_t>(this->get()) >> rhs);
        return *this;
    }
    const Value &operator&=(std::int32_t rhs) const {
        this->set(static_cast<std::int32_t>(this->get()) & rhs);
        return *this;
    }
    const Value &operator|=(std::int32_t rhs) const {
        this->set(static_cast<std::int32_t>(this->get()) | rhs);
        return *this;
    }
    const Value &operator^=(std::int32_t rhs) const {
        this->set(static_cast<std::int32_t>(this->get()) ^ rhs);
        return *this;
    }
    const Value &operator++() const { // ++s
        this->set(this->get() + 1);
        return *this;
    }
    double operator++(int) const { // s++
        auto v = this->get();
        this->set(v + 1);
        return v;
    }
    const Value &operator--() const { // --const s
        this->set(this->get() - 1);
        return *this;
    }
    double operator--(int) const { // s--
        auto v = this->get();
        this->set(v - 1);
        return v;
    }
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Value>,
                                                    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, Value>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) == static_cast<Field>(other);
    }
    bool operator<(const Value &) const = delete;
    bool operator<=(const Value &) const = delete;
    bool operator>(const Value &) const = delete;
    bool operator>=(const Value &) const = delete;
};
 
WEBCFACE_DLL std::ostream &WEBCFACE_CALL operator<<(std::ostream &os,
                                                    const Value &data);
 
WEBCFACE_NS_END