ReverseIterate.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "HAL/Platform.h"
#include <iterator>
 
template <typename T>
struct TReversePointerIterator
{
    // This iterator type only supports the minimal functionality needed to support
    // C++ ranged-for syntax.  For example, it does not provide post-increment ++ nor ==.
 
    constexpr explicit TReversePointerIterator(T* InPtr UE_LIFETIMEBOUND)
        : Ptr(InPtr)
    {
    }
 
    constexpr inline T& operator*() const
    {
        return *(Ptr - 1);
    }
 
    constexpr inline TReversePointerIterator& operator++()
    {
        --Ptr;
        return *this;
    }
 
    constexpr inline bool operator!=(const TReversePointerIterator& Rhs) const
    {
        return Ptr != Rhs.Ptr;
    }
 
private:
    T* Ptr;
};
 
namespace UE::Core::Private
{
    template <typename RangeType>
    struct TReverseIterationAdapter
    {
        constexpr explicit TReverseIterationAdapter(RangeType& InRange UE_LIFETIMEBOUND)
            : Range(InRange)
        {
        }
 
        TReverseIterationAdapter(TReverseIterationAdapter&&) = delete;
        TReverseIterationAdapter& operator=(TReverseIterationAdapter&&) = delete;
        TReverseIterationAdapter& operator=(const TReverseIterationAdapter&) = delete;
        TReverseIterationAdapter(const TReverseIterationAdapter&) = delete;
        ~TReverseIterationAdapter() = default;
 
        UE_FORCEINLINE_HINT constexpr auto begin() const UE_LIFETIMEBOUND
        {
            using std::rbegin;
            return rbegin(Range);
        }
 
        UE_FORCEINLINE_HINT constexpr auto end() const UE_LIFETIMEBOUND
        {
            using std::rend;
            return rend(Range);
        }
 
    private:
        RangeType& Range;
    };
 
    template <typename ElementType, std::size_t N>
    struct TReverseIterationAdapter<ElementType(&)[N]>
    {
        constexpr explicit TReverseIterationAdapter(ElementType* InArray UE_LIFETIMEBOUND)
            : Array(InArray)
        {
        }
 
        TReverseIterationAdapter(TReverseIterationAdapter&&) = delete;
        TReverseIterationAdapter& operator=(TReverseIterationAdapter&&) = delete;
        TReverseIterationAdapter& operator=(const TReverseIterationAdapter&) = delete;
        TReverseIterationAdapter(const TReverseIterationAdapter&) = delete;
        ~TReverseIterationAdapter() = default;
 
        inline constexpr TReversePointerIterator<ElementType> begin() const UE_LIFETIMEBOUND
        {
            return TReversePointerIterator<ElementType>(Array + N);
        }
 
        inline constexpr TReversePointerIterator<ElementType> end() const UE_LIFETIMEBOUND
        {
            return TReversePointerIterator<ElementType>(Array);
        }
 
    private:
        ElementType* Array;
    };
}
 
template <typename RangeType>
inline constexpr UE::Core::Private::TReverseIterationAdapter<RangeType> ReverseIterate(RangeType&& Range UE_LIFETIMEBOUND)
{
    return UE::Core::Private::TReverseIterationAdapter<RangeType>(Range);
}