SdlNativeData.h

Go to the documentation of this file.

#pragma once
 
#include "SDL/ESdlDataFormat.h"
#include "SDL/ESdlDataType.h"
#include "Utility/TFunction.h"
#include "Math/Color/spectrum_fwd.h"
#include "SDL/TSdlAnyInstance.h"
#include "Utility/TAnyPtr.h"
 
#include <Common/primitive_type.h>
 
#include <cstddef>
#include <variant>
#include <string>
#include <typeindex>
#include <optional>
#include <type_traits>
 
namespace ph
{
 
template<typename Variant>
class TSdlAccessorVariant final
{
public:
    using VariantType = Variant;
 
    TSdlAccessorVariant();
 
    template<typename T>
    TSdlAccessorVariant(T value);
 
    TSdlAccessorVariant(VariantType variant);
 
    template<typename T>
    bool has() const;
 
    template<typename T>
    T& get();
 
    template<typename T>
    const T& get() const;
 
    template<typename T>
    void set(T value);
 
    std::size_t index() const;
    bool isEmpty() const;
 
    auto getVariant() -> VariantType&;
    auto getVariant() const -> const VariantType&;
 
private:
    VariantType m_variant;
};
 
using SdlGetterVariant = TSdlAccessorVariant<std::variant<
    std::monostate,
    int64,
    float64,
    SdlConstInstance,
    AnyConstPtr>>;
 
using SdlSetterVariant = TSdlAccessorVariant<std::variant<
    std::monostate,
    int64,
    float64,
    SdlNonConstInstance,
    AnyNonConstPtr>>;
 
class SdlNativeData final
{
public:
    template<typename Func>
    using TElementAccessor = TFunction<Func, 32>;
 
    using ElementGetter = TElementAccessor<SdlGetterVariant(std::size_t elementIdx)>;
    using ElementSetter = TElementAccessor<bool(std::size_t elementIdx, SdlSetterVariant input)>;
 
    std::size_t numElements = 0;
 
    std::size_t tupleSize = 0;
 
    ESdlDataFormat elementContainer = ESdlDataFormat::None;
 
    ESdlDataType elementType = ESdlDataType::None;
 
    uint8 isNullClearable : 1 = false;
 
    template<typename ElementType>
    static SdlNativeData fromSingleElement(
        ElementType* elementPtr,
        ESdlDataFormat elementContainer,
        ESdlDataType elementType,
        bool canSet = false, 
        bool canDirectAccess = false);
 
    SdlNativeData();
 
    explicit SdlNativeData(ElementGetter getter);
 
    SdlNativeData(ElementGetter getter, ElementSetter setter);
 
    SdlNativeData(ElementGetter getter, ElementSetter setter, AnyNonConstPtr directPtr);
 
    template<typename T>
        requires std::is_arithmetic_v<T> || std::is_enum_v<T>
    std::optional<T> get(std::size_t elementIdx) const;
 
    template<typename T>
        requires std::is_pointer_v<T>
    T get(std::size_t elementIdx) const;
 
    template<typename T>
        requires std::is_arithmetic_v<T> || std::is_enum_v<T>
    bool set(std::size_t elementIdx, T value) const;
 
    template<typename T>
        requires std::is_pointer_v<T>
    bool set(std::size_t elementIdx, T ptr) const;
 
    template<typename T>
        requires std::is_null_pointer_v<T>
    bool set(std::size_t elementIdx, T nullPtr) const;
 
    template<typename T>
    T* directAccess() const;
 
    void setDirectAccessor(AnyNonConstPtr accessor);
 
    bool isIntegerElement() const;
    bool isFloatingPointElement() const;
 
    operator bool () const;
 
public:
    template<typename ElementType>
    static auto permissiveElementGetter(ElementType* elementPtr) -> SdlGetterVariant;
 
    template<typename ElementType>
    static auto permissiveElementSetter(SdlSetterVariant input, ElementType* out_elementPtr) -> bool;
 
private:
    ElementGetter m_elementGetter;
    ElementSetter m_elementSetter;
    AnyNonConstPtr m_directPtr;
};
 
}// end namespace ph
 
#include "SDL/Introspect/SdlNativeData.ipp"