MRUITestEngine.h

Go to the documentation of this file.

#pragma once
 
#include "MRMesh/MRExpected.h"
#include "MRViewer/exports.h"
 
#include <cstdint>
#include <limits>
#include <map>
#include <optional>
#include <string_view>
#include <string>
#include <variant>
#include <vector>
 
 
namespace MR::UI::TestEngine
{
 
namespace detail
{
    template <typename T>
    struct BoundedValue
    {
        T value{};
        T min{};
        T max{};
    };
    template <>
    struct BoundedValue<std::string>
    {
        std::string value;
 
        std::optional<std::vector<std::string>> allowedValues;
    };
 
    template <typename T>
    [[nodiscard]] MRVIEWER_API std::optional<T> createValueLow( std::string_view name, std::optional<BoundedValue<T>> value, bool consumeValueOverride = true );
 
    extern template MRVIEWER_API std::optional<std::int64_t> createValueLow( std::string_view name, std::optional<BoundedValue<std::int64_t>> value, bool consumeValueOverride );
    extern template MRVIEWER_API std::optional<std::uint64_t> createValueLow( std::string_view name, std::optional<BoundedValue<std::uint64_t>> value, bool consumeValueOverride );
    extern template MRVIEWER_API std::optional<double> createValueLow( std::string_view name, std::optional<BoundedValue<double>> value, bool consumeValueOverride );
    extern template MRVIEWER_API std::optional<std::string> createValueLow( std::string_view name, std::optional<BoundedValue<std::string>> value, bool consumeValueOverride );
 
    template <typename T, typename = void> struct UnderlyingValueTypeHelper {};
    template <typename T> struct UnderlyingValueTypeHelper<T, std::enable_if_t<std::is_floating_point_v<T>>> {using type = double;};
    template <typename T> struct UnderlyingValueTypeHelper<T, std::enable_if_t<std::is_integral_v<T> && std::is_signed_v<T>>> {using type = std::int64_t;};
    template <typename T> struct UnderlyingValueTypeHelper<T, std::enable_if_t<std::is_integral_v<T> && std::is_unsigned_v<T>>> {using type = std::uint64_t;};
    template <> struct UnderlyingValueTypeHelper<std::string> {using type = std::string;};
 
    template <typename T>
    using UnderlyingValueType = typename UnderlyingValueTypeHelper<T>::type;
}
 
[[nodiscard]] MRVIEWER_API bool createButton( std::string_view name );
 
template <typename T>
concept AllowedValueType = std::is_arithmetic_v<T> || std::is_same_v<T, std::string>;
 
template <AllowedValueType T>
requires std::is_arithmetic_v<T>
[[nodiscard]] std::optional<T> createValue( std::string_view name, T value, T min, T max, bool consumeValueOverride = true )
{
    if ( !( min < max ) )
    {
        min = std::numeric_limits<T>::lowest();
        max = std::numeric_limits<T>::max();
    }
 
    using U = detail::UnderlyingValueType<T>;
    static_assert(sizeof(T) <= sizeof(U), "The used type is too large.");
 
    auto ret = detail::createValueLow<U>( name, detail::BoundedValue<U>{ .value = U( value ), .min = U( min ), .max = U( max ) }, consumeValueOverride );
    return ret ? std::optional<T>( T( *ret ) ) : std::nullopt;
}
[[nodiscard]] MRVIEWER_API std::optional<std::string> createValue( std::string_view name, std::string value, bool consumeValueOverride = true, std::optional<std::vector<std::string>> allowedValues = std::nullopt );
 
template <AllowedValueType T>
[[nodiscard]] std::optional<T> createValueTentative( std::string_view name, bool consumeValueOverride = true )
{
    auto ret = detail::createValueLow<detail::UnderlyingValueType<T>>( name, std::nullopt, consumeValueOverride );
    return ret ? std::optional<T>( T( *ret ) ) : std::nullopt;
}
 
MRVIEWER_API void pushTree( std::string_view name );
MRVIEWER_API void popTree();
 
struct Entry;
 
struct ButtonEntry
{
    mutable bool simulateClick = false;
 
    static constexpr std::string_view kindName = "button";
};
 
struct ValueEntry
{
    template <typename T>
    struct Value
    {
        T value = 0;
 
        T min = 0;
        T max = 0;
 
        mutable std::optional<T> simulatedValue;
 
        Value() {} 
    };
    template <std::same_as<std::string> T> 
    struct Value<T>
    {
        std::string value;
 
        std::optional<std::vector<std::string>> allowedValues;
 
        mutable std::optional<std::string> simulatedValue;
 
        Value() {} 
    };
    using ValueVar = std::variant<Value<std::int64_t>, Value<std::uint64_t>, Value<double>, Value<std::string>>;
    ValueVar value;
 
    static constexpr std::string_view kindName = "value";
};
 
struct GroupEntry
{
    std::map<std::string, Entry, std::less<>> elems;
 
    static constexpr std::string_view kindName = "group";
};
 
struct Entry
{
    std::variant<ButtonEntry, ValueEntry, GroupEntry> value;
 
    bool visitedOnThisFrame = false;
 
    [[nodiscard]] MRVIEWER_API std::string_view getKindName() const;
 
    template <typename T>
    [[nodiscard]] Expected<T *> getAs( std::string_view selfName = {} )
    {
        Expected<T *> ret = std::get_if<T>( &value );
        if ( !*ret )
            ret = unexpected_( selfName, T::kindName );
        return ret;
    }
    template <typename T>
    [[nodiscard]] Expected<const T *> getAs( std::string_view selfName = {} ) const
    {
        return const_cast<Entry *>( this )->template getAs<T>( selfName );
    }
 
private:
    [[nodiscard]] MRVIEWER_API Unexpected<std::string> unexpected_( std::string_view selfName, std::string_view tKindName );
};
 
[[nodiscard]] MRVIEWER_API const GroupEntry& getRootEntry();
 
}