TypedElementSorter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include <type_traits>
#include "DataStorage/Handles.h"
#include "Containers/StringFwd.h"
#include "Internationalization/Text.h"
#include "Math/NumericLimits.h"
#include "Misc/EnumClassFlags.h"
 
namespace UE::Editor::DataStorage
{
    class ICoreProvider;
 
    struct FPrefixInfo
    {
        uint64 Prefix = TNumericLimits<uint64>::Max();
        bool bHasRemainingBytes = false;
    };
 
    class FColumnSorterInterface
    {
    public:
        virtual ~FColumnSorterInterface() = default;
 
        enum class ESortType : uint8
        {
            FixedSize64,
            FixedSizeOnly,
            ComparativeSort,
            HybridSort,
 
            Max
        };
 
        virtual ESortType GetSortType() const = 0;
 
        virtual FText GetShortName() const = 0;
 
        virtual int32 Compare(const ICoreProvider& Storage, RowHandle Left, RowHandle Right) const = 0;
 
        virtual FPrefixInfo CalculatePrefix(const ICoreProvider& Storage, RowHandle Row, uint32 ByteIndex) const = 0;
    };
 
    template<FColumnSorterInterface::ESortType SortType, typename ColumnType>
    class TColumnSorterInterface : public FColumnSorterInterface
    {
        static_assert(static_cast<uint32>(SortType) < static_cast<uint32>(ESortType::Max), "Unexpected sort type for TColumnSorterInterface.");
    };
 
    template<typename ColumnType>
    class TColumnSorterInterface<FColumnSorterInterface::ESortType::FixedSize64, ColumnType> : public FColumnSorterInterface
    {
    public:
        virtual ~TColumnSorterInterface() override = default;
 
        int32 Compare(const ICoreProvider& Storage, RowHandle Left, RowHandle Right) const override final;
        FPrefixInfo CalculatePrefix(const ICoreProvider& Storage, RowHandle Row, uint32 ByteIndex) const override final;
        ESortType GetSortType() const override final;
 
    protected:
        virtual FPrefixInfo CalculatePrefix(const ColumnType& Column, uint32 ByteIndex) const = 0;
    };
 
    template<typename ColumnType>
    class TColumnSorterInterface<FColumnSorterInterface::ESortType::FixedSizeOnly, ColumnType> : public FColumnSorterInterface
    {
    public:
        virtual ~TColumnSorterInterface() override = default;
 
        int32 Compare(const ICoreProvider& Storage, RowHandle Left, RowHandle Right) const override final;
        FPrefixInfo CalculatePrefix(const ICoreProvider& Storage, RowHandle Row, uint32 ByteIndex) const override final;
        ESortType GetSortType() const override final;
 
    protected:
        virtual FPrefixInfo CalculatePrefix(const ColumnType& Column, uint32 ByteIndex) const = 0;
    };
 
    template<typename ColumnType>
    class TColumnSorterInterface<FColumnSorterInterface::ESortType::ComparativeSort, ColumnType> : public FColumnSorterInterface
    {
    public:
        virtual ~TColumnSorterInterface() override = default;
 
        int32 Compare(const ICoreProvider& Storage, RowHandle Left, RowHandle Right) const override final;
        FPrefixInfo CalculatePrefix(const ICoreProvider& Storage, RowHandle Row, uint32 ByteIndex) const override final;
        ESortType GetSortType() const override final;
 
    protected:
        virtual int32 Compare(const ColumnType& Left, const ColumnType& Right) const = 0;
    };
 
    template<typename ColumnType>
    class TColumnSorterInterface<FColumnSorterInterface::ESortType::HybridSort, ColumnType> : public FColumnSorterInterface
    {
    public:
        virtual ~TColumnSorterInterface() override = default;
 
        int32 Compare(const ICoreProvider& Storage, RowHandle Left, RowHandle Right) const override final;
        FPrefixInfo CalculatePrefix(const ICoreProvider& Storage, RowHandle Row, uint32 ByteIndex) const override final;
        ESortType GetSortType() const override final;
 
    protected:
        virtual int32 Compare(const ColumnType& Left, const ColumnType& Right) const = 0;
        virtual FPrefixInfo CalculatePrefix(const ColumnType& Column, uint32 ByteIndex) const = 0;
    };
 
    namespace Private
    {
        template<typename T>
        concept SortNumericValue = std::is_integral_v<T> || std::is_floating_point_v<T>;
 
        template <typename T>
        struct TSortStringViewType : std::false_type {};
 
        template <typename T>
        struct TSortStringViewType<TStringView<T>> : std::true_type {};
 
        template<typename T>
        concept SortStringViewValue = TSortStringViewType<T>::value;
 
        template<typename T>
        concept SortStringViewCopyableType =
            SortStringViewValue<T> ||
            std::is_same_v<T, FString> ||
            std::is_same_v<T, FAnsiString> ||
            std::is_same_v<T, FWideString> ||
            std::is_same_v<T, FUtf8String>;
 
        template<typename T>
        concept SortStringVariantType = SortStringViewCopyableType<T> || std::is_same_v<T, FText>;
 
        template<typename T>
        concept NameValue = std::is_same_v<T, FName>;
    }
 
    struct FSortCaseSensitive {};
    struct FSortCaseInsensitive {};
    template<typename T>
    concept SortCase = std::is_same_v<T, FSortCaseSensitive> || std::is_same_v<T, FSortCaseInsensitive>;
    
    template<SortCase Casing, Private::SortStringViewValue StringView>
    struct TSortStringView
    {
        using StringViewType = StringView;
        static constexpr bool bIsCaseSensitive = std::is_same_v<Casing, FSortCaseSensitive>;
        static constexpr ESearchCase::Type SearchCase = bIsCaseSensitive ? ESearchCase::CaseSensitive : ESearchCase::IgnoreCase;
        
        TSortStringView() = default;
        
        template<Private::SortStringViewCopyableType ViewType>
        TSortStringView(const ViewType& InView) : View(InView) {}
        template<Private::SortStringViewCopyableType ViewType>
        TSortStringView& operator=(const ViewType& InView) { this->View = InView; return *this; }
 
        TSortStringView(const FText& Text) : View(Text.ToString()) {}
        TSortStringView& operator=(const FText& Text) { this->View = Text.ToString(); return *this; }
        
        template<SortCase TargetCasing, Private::SortStringViewCopyableType ViewType>
        TSortStringView(TargetCasing, const ViewType& String) : View(String) { static_assert(std::is_same_v<Casing, TargetCasing>); }
        template<SortCase TargetCasing>
        TSortStringView(TargetCasing, const FText& Text) : View(Text.ToString()) { static_assert(std::is_same_v<Casing, TargetCasing>); }
 
        bool operator==(const TSortStringView& Rhs) const { return View.Equals(Rhs.View, SearchCase) == true; }
        bool operator!=(const TSortStringView& Rhs) const { return View.Equals(Rhs.View, SearchCase) == false; }
        bool operator< (const TSortStringView& Rhs) const { return View.Compare(Rhs.View, SearchCase) < 0; }
        bool operator<=(const TSortStringView& Rhs) const { return View.Compare(Rhs.View, SearchCase) <= 0; }
        bool operator> (const TSortStringView& Rhs) const { return View.Compare(Rhs.View, SearchCase) > 0; }
        bool operator>=(const TSortStringView& Rhs) const { return View.Compare(Rhs.View, SearchCase) >= 0; }
 
        StringView View;
    };
 
    template<SortCase Casing, Private::SortStringViewCopyableType View>
    TSortStringView(Casing, const View&) -> TSortStringView<Casing, TStringView<typename View::ElementType>>;
    template<SortCase Casing>
    TSortStringView(Casing, const FText&) -> TSortStringView<Casing, FStringView>;
 
    enum class ENameSortBy : bool { Id, String };
 
    enum class ESortByNameFlags
    {
        Default = 0,
        WithNone = 1 << 0, 
        RemoveLeadingSlash = 1 << 1, 
    };
    ENUM_CLASS_FLAGS(ESortByNameFlags)
 
    
    template<ESortByNameFlags InFlags = ESortByNameFlags::Default>
    struct TSortByName { static const ESortByNameFlags Flags = InFlags; };
    struct FSortById {};
    
    template<typename>
    struct IsSortByName : std::false_type {};
    template<ESortByNameFlags Flags>
    struct IsSortByName<TSortByName<Flags>> : std::true_type {};
 
    template<typename T>
    concept SortBy = std::is_same_v<T, FSortById> || IsSortByName<T>::value;
 
    template<SortBy By>
    struct TSortNameView
    {
        constexpr static bool bIsById = std::is_same_v<By, FSortById>;
        using CompareType = std::conditional_t<bIsById, int32, FString>;
        constexpr static bool bIsFixedSize = bIsById;
 
        TSortNameView() = default;
        explicit TSortNameView(const FName& Name) : View(&Name) {}
        TSortNameView& operator=(const FName& Name);
 
        template<SortBy TargetBy>
        TSortNameView(TargetBy, const FName& Name) : View(&Name) { static_assert(std::is_same_v<By, TargetBy>); }
 
        uint32 GetByteSize() const;
        constexpr static uint32 GetElementSize();
        FPrefixInfo CalculatePrefix(int32 CurrentIndex, int32 ByteIndex) const;
 
        int32 Compare(const FName& Rhs) const;
        int32 Compare(const TSortNameView& Rhs) const;
        bool operator==(const TSortNameView& Rhs) const;
        bool operator!=(const TSortNameView& Rhs) const;
        bool operator< (const TSortNameView& Rhs) const;
        bool operator<=(const TSortNameView& Rhs) const;
        bool operator> (const TSortNameView& Rhs) const;
        bool operator>=(const TSortNameView& Rhs) const;
 
        const FName* View = nullptr;
        mutable CompareType Cache = {};
        mutable bool bIsCached = false;
 
    private:
        int32 Compare(const FName& Lhs, const FName& Rhs) const;
        void CacheCompareType() const;
    };
 
    template<SortBy By>
    TSortNameView(By, const FName&) -> TSortNameView<By>;
 
    template<typename... ValueTypes>
    FPrefixInfo CreateSortPrefix(uint32 ByteIndex, ValueTypes&&... Values);
 
    namespace Private
    {
        template<typename T>
        constexpr uint64 MoveToLocation(int32 ByteIndex, T Value);
 
        template<typename Numeric>
        constexpr auto Rebase(Numeric Value);
    }
 
    template<typename ValueType>
    struct TSortTypeInfo
    {
        // Used to short-circuit several calls to minimize noise in the error output of the compiler.
        static constexpr bool bIsSupportedType = false;
 
        // Check is just a random way to say "false" so the compiler doesn't evaluate the assert until an attempt is made to instance 
        // this version.
        static_assert(sizeof(ValueType) == 0, "Unsupported sort type.");
    };
 
    template<Private::SortNumericValue NumericType>
    struct TSortTypeInfo<NumericType>
    {
        static constexpr bool bIsSupportedType = true;
        static constexpr bool bIsFixedSize = true;
        constexpr static uint32 GetByteSize(NumericType Value) { return sizeof(NumericType); }
        constexpr static uint32 GetElementSize() { return sizeof(NumericType); }
        constexpr static FPrefixInfo CalculatePrefix(int32 CurrentIndex, int32 ByteIndex, NumericType Value)
        {
            // Due to an issue with MSVC resolving forward declared partially specialized templates that use concepts, this 
            // can't be moved to the .inl file.
            return FPrefixInfo
            {
                .Prefix = Private::MoveToLocation(CurrentIndex - ByteIndex, Private::Rebase(Value)),
                .bHasRemainingBytes = false
            };
        }
    };
 
    template<SortCase Casing, typename T>
    struct TSortTypeInfo<TSortStringView<Casing, T>>
    {
        static constexpr bool bIsSupportedType = true;
        static constexpr bool bIsFixedSize = false;
        constexpr static uint32 GetByteSize(TSortStringView<Casing, T> Value);
        constexpr static uint32 GetElementSize();
        constexpr static FPrefixInfo CalculatePrefix(
            int32 CurrentIndex, int32 ByteIndex, TSortStringView<Casing, T> Value);
    };
 
    template<typename StringType> requires Private::SortStringVariantType<StringType>
    struct TSortTypeInfo<StringType>
    {
        static constexpr bool bIsSupportedType = false;
        static_assert(sizeof(StringType) == 0, 
            "Strings and string views are not directly supported. Use `TSortStringView` to indicate if sorting is case sensitive or not.");
    };
 
    template<SortBy By>
    struct TSortTypeInfo<TSortNameView<By>>
    {
        static constexpr bool bIsSupportedType = true;
        static constexpr bool bIsFixedSize = TSortNameView<By>::bIsFixedSize;
        static uint32 GetByteSize(const TSortNameView<By>& Value) { return Value.GetByteSize(); };
        constexpr static uint32 GetElementSize() { return TSortNameView<By>::GetElementSize(); };
        static FPrefixInfo CalculatePrefix(
            int32 CurrentIndex, int32 ByteIndex, TSortNameView<By> Value) { return Value.CalculatePrefix(CurrentIndex, ByteIndex); };
    };
 
    // Not a direct specialization, but done through requirements to prevent the compiler from evaluating the static_assert when it's not instanced.
    template<Private::NameValue NameType>
    struct TSortTypeInfo<NameType>
    {
        static constexpr bool bIsSupportedType = false;
        static_assert(sizeof(NameType) == 0,
            "FNames are not directly supported. Use `TSortNameView` to indicate if sorting is based on a string or the unique FName number.");
    };
} // namespace UE::Editor::DataStorage
 
#include "Elements/Framework/TypedElementSorter.inl"