Redstone1024/Redcraft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor(*): refactor the tool library's namespace to plural form

Browse Source
This commit is contained in:
Redstone1024 2024-12-20 18:09:27 +08:00
parent 343007ffd6
commit a92422e8b2
25 changed files with 299 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Redcraft.Utility/Source/Private/Testing/Algorithms.cpp
View File

@ -19,16 +19,16 @@ void TestBasic()
auto Iter = Arr.Begin();
Algorithm::Advance(Iter, 5);
Algorithms::Advance(Iter, 5);
always_check(*Iter == 5);
always_check(Algorithm::Distance(Arr.Begin(), Iter) == 5);
always_check(Algorithms::Distance(Arr.Begin(), Iter) == 5);
always_check(Algorithm::Distance(Arr) == 10);
always_check(Algorithms::Distance(Arr) == 10);
always_check(*Algorithm::Next(Iter, 2) == 7);
always_check(*Algorithm::Prev(Iter, 2) == 3);
always_check(*Algorithms::Next(Iter, 2) == 7);
always_check(*Algorithms::Prev(Iter, 2) == 3);
}
NAMESPACE_PRIVATE_END

116
Redcraft.Utility/Source/Private/Testing/Ranges.cpp
View File

@ -19,8 +19,8 @@ void TestConversion()
const TArray<int> Arr = { 1, 2, 3, 4, 5 };
const TList<int> List = { 1, 2, 3, 4, 5 };
const TArray<int> Brr = Range::View(List.Begin(), List.End()) | Range::To<TArray<int>>();
const TList<int> Mist = Range::View(Arr.Begin(), Arr.End()) | Range::To<TList<int>>();
const TArray<int> Brr = Ranges::View(List.Begin(), List.End()) | Ranges::To<TArray<int>>();
const TList<int> Mist = Ranges::View(Arr.Begin(), Arr.End()) | Ranges::To<TList<int>>();
always_check(Arr == Brr);
always_check(List == Mist);
@ -30,8 +30,8 @@ void TestConversion()
const TArray<int> Arr = { 1, 2, 3, 4, 5 };
const TList<int> List = { 1, 2, 3, 4, 5 };
const TArray<int> Brr = Range::View(List.Begin(), List.End()) | Range::To<TArray>();
const TList<int> Mist = Range::View(Arr.Begin(), Arr.End()) | Range::To<TList>();
const TArray<int> Brr = Ranges::View(List.Begin(), List.End()) | Ranges::To<TArray>();
const TList<int> Mist = Ranges::View(Arr.Begin(), Arr.End()) | Ranges::To<TList>();
always_check(Arr == Brr);
always_check(List == Mist);
@ -42,27 +42,27 @@ void TestFactory()
{
{
const TArray<int> Arr = { };
const TArray<int> Brr = Range::Empty<int> | Range::To<TArray<int>>();
const TArray<int> Brr = Ranges::Empty<int> | Ranges::To<TArray<int>>();
always_check(Arr == Brr);
}
{
const TArray<int> Arr = { 1 };
const TArray<int> Brr = Range::Single(1) | Range::To<TArray<int>>();
const TArray<int> Brr = Ranges::Single(1) | Ranges::To<TArray<int>>();
always_check(Arr == Brr);
}
{
const TArray<int> Arr = { 0, 1, 2, 3, 4 };
const TArray<int> Brr = Range::Iota(0, 5) | Range::To<TArray<int>>();
const TArray<int> Brr = Ranges::Iota(0, 5) | Ranges::To<TArray<int>>();
always_check(Arr == Brr);
}
{
auto View = Range::Iota(0, 5);
auto View = Ranges::Iota(0, 5);
always_check(View.Num() == 5);
always_check(!View.IsEmpty());
@ -91,7 +91,7 @@ void TestFactory()
}
{
auto View = Range::Iota(0);
auto View = Ranges::Iota(0);
always_check(!View.IsEmpty());
always_check(!!View);
@ -119,13 +119,13 @@ void TestFactory()
{
const TArray<int> Arr = { 0, 0, 0, 0, 0 };
const TArray<int> Brr = Range::Repeat(0, 5) | Range::To<TArray<int>>();
const TArray<int> Brr = Ranges::Repeat(0, 5) | Ranges::To<TArray<int>>();
always_check(Arr == Brr);
}
{
auto View = Range::Repeat(0, 8);
auto View = Ranges::Repeat(0, 8);
always_check(View.Num() == 8);
always_check(!View.IsEmpty());
@ -176,7 +176,7 @@ void TestFactory()
}
{
auto View = Range::Repeat(0);
auto View = Ranges::Repeat(0);
always_check(!View.IsEmpty());
always_check(!!View);
@ -226,15 +226,15 @@ void TestAllView()
{
TArray<int> Arr = { 0, 1, 2, 3, 4 };
TArray<int> Brr = Range::All(Arr) | Range::To<TArray<int>>();
TArray<int> Brr = Ranges::All(Arr) | Ranges::To<TArray<int>>();
always_check(Arr == Brr);
auto View = Range::All(MoveTemp(Arr));
auto View = Ranges::All(MoveTemp(Arr));
Arr.Reset();
TArray<int> Crr = View | Range::To<TArray<int>>();
TArray<int> Crr = View | Ranges::To<TArray<int>>();
always_check(Brr == Crr);
}
@ -254,7 +254,7 @@ void TestMoveView()
FTracker Arr[2];
auto View = Arr | Range::Move();
auto View = Arr | Ranges::Move();
auto First = View.Begin();
auto Last = View.End();
@ -269,7 +269,7 @@ void TestMoveView()
{
TArray<int> Arr = { 0, 1, 2, 3, 4, 5, 6, 7 };
auto View = Arr | Range::Move();
auto View = Arr | Ranges::Move();
always_check(View.Num() == 8);
always_check(!View.IsEmpty());
@ -320,7 +320,7 @@ void TestMoveView()
}
{
auto View = Range::Iota(0) | Range::Move();
auto View = Ranges::Iota(0) | Ranges::Move();
always_check(!View.IsEmpty());
always_check(!!View);
@ -354,8 +354,8 @@ void TestMiscView()
TArray<int> Brr = { 0, 2, 4, 6 };
TArray<int> Crr = Arr
| Range::Filter([](int Value) { return Value % 2 == 0; })
| Range::To<TArray<int>>();
| Ranges::Filter([](int Value) { return Value % 2 == 0; })
| Ranges::To<TArray<int>>();
always_check(Brr == Crr);
}
@ -365,8 +365,8 @@ void TestMiscView()
TArray<int> Brr = { 0, 2, 4, 4, 2, 0 };
TArray<int> Crr = Arr
| Range::Transform([](int Value) { return Value * 2; })
| Range::To<TArray<int>>();
| Ranges::Transform([](int Value) { return Value * 2; })
| Ranges::To<TArray<int>>();
always_check(Brr == Crr);
}
@ -376,14 +376,14 @@ void TestMiscView()
TArray<int> Brr = { 0, 2, 4, 4, 2, 0 };
TArray<int> Crr = Arr
| Range::Filter ([](int Value) { return Value < 3; })
| Range::Transform([](int Value) { return Value * 2; })
| Range::To<TArray<int>>();
| Ranges::Filter ([](int Value) { return Value < 3; })
| Ranges::Transform([](int Value) { return Value * 2; })
| Ranges::To<TArray<int>>();
TArray<int> Drr = Arr
| Range::Transform([](int Value) { return Value * 2; })
| Range::Filter ([](int Value) { return Value < 6; })
| Range::To<TArray<int>>();
| Ranges::Transform([](int Value) { return Value * 2; })
| Ranges::Filter ([](int Value) { return Value < 6; })
| Ranges::To<TArray<int>>();
always_check(Brr == Crr);
always_check(Brr == Drr);
@ -392,13 +392,13 @@ void TestMiscView()
{
TArray<int> Arr = { 0, 1, 2, 3, 4, 5, 6, 7 };
TArray<int> Brr = Range::Iota(0)
| Range::Take(8)
| Range::To<TArray<int>>();
TArray<int> Brr = Ranges::Iota(0)
| Ranges::Take(8)
| Ranges::To<TArray<int>>();
TArray<int> Crr = Range::Iota(0)
| Range::TakeWhile([](int Value) { return Value < 8; })
| Range::To<TArray<int>>();
TArray<int> Crr = Ranges::Iota(0)
| Ranges::TakeWhile([](int Value) { return Value < 8; })
| Ranges::To<TArray<int>>();
always_check(Arr == Brr);
always_check(Arr == Crr);
@ -409,40 +409,40 @@ void TestMiscView()
TArray<int> Brr = { 0, 2, 4 };
TArray<int> Crr = Arr
| Range::Filter ([](int Value) { return Value % 2 == 0; })
| Range::Take(3)
| Range::Transform([](int Value) { return Value / 2; })
| Range::To<TArray<int>>();
| Ranges::Filter ([](int Value) { return Value % 2 == 0; })
| Ranges::Take(3)
| Ranges::Transform([](int Value) { return Value / 2; })
| Ranges::To<TArray<int>>();
TArray<int> Drr = Arr
| Range::Filter ([](int Value) { return Value % 2 == 0; })
| Range::TakeWhile([](int Value) { return Value < 10; })
| Range::Transform([](int Value) { return Value / 2; })
| Range::To<TArray<int>>();
| Ranges::Filter ([](int Value) { return Value % 2 == 0; })
| Ranges::TakeWhile([](int Value) { return Value < 10; })
| Ranges::Transform([](int Value) { return Value / 2; })
| Ranges::To<TArray<int>>();
TArray<int> Err = Arr
| Range::Filter ([](int Value) { return Value % 2 == 0; })
| Range::Transform([](int Value) { return Value / 2; })
| Range::Take(3)
| Range::To<TArray<int>>();
| Ranges::Filter ([](int Value) { return Value % 2 == 0; })
| Ranges::Transform([](int Value) { return Value / 2; })
| Ranges::Take(3)
| Ranges::To<TArray<int>>();
TArray<int> Frr = Arr
| Range::Filter ([](int Value) { return Value % 2 == 0; })
| Range::Transform([](int Value) { return Value / 2; })
| Range::TakeWhile([](int Value) { return Value < 5; })
| Range::To<TArray<int>>();
| Ranges::Filter ([](int Value) { return Value % 2 == 0; })
| Ranges::Transform([](int Value) { return Value / 2; })
| Ranges::TakeWhile([](int Value) { return Value < 5; })
| Ranges::To<TArray<int>>();
TArray<int> Grr = Arr
| Range::Take(6)
| Range::Filter ([](int Value) { return Value % 2 == 0; })
| Range::Transform([](int Value) { return Value / 2; })
| Range::To<TArray<int>>();
| Ranges::Take(6)
| Ranges::Filter ([](int Value) { return Value % 2 == 0; })
| Ranges::Transform([](int Value) { return Value / 2; })
| Ranges::To<TArray<int>>();
TArray<int> Hrr = Arr
| Range::TakeWhile([](int Value) { return Value < 10; })
| Range::Filter ([](int Value) { return Value % 2 == 0; })
| Range::Transform([](int Value) { return Value / 2; })
| Range::To<TArray<int>>();
| Ranges::TakeWhile([](int Value) { return Value < 10; })
| Ranges::Filter ([](int Value) { return Value % 2 == 0; })
| Ranges::Transform([](int Value) { return Value / 2; })
| Ranges::To<TArray<int>>();
always_check(Brr == Crr);
always_check(Brr == Drr);

13
Redcraft.Utility/Source/Public/Algorithms/Basic.h
View File

@ -3,6 +3,7 @@
#include "CoreTypes.h"
#include "TypeTraits/TypeTraits.h"
#include "Iterators/Utility.h"
#include "Iterators/Sentinel.h"
#include "Iterators/BasicIterator.h"
#include "Ranges/Utility.h"
#include "Miscellaneous/AssertionMacros.h"
@ -11,7 +12,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Algorithm)
NAMESPACE_BEGIN(Algorithms)
/** Increments given iterator 'Iter' by 'N' elements. */
template <CInputIterator I>
@ -57,16 +58,16 @@ NODISCARD FORCEINLINE constexpr ptrdiff Distance(R&& Range)
{
if constexpr (CSizedRange<R>)
{
return static_cast<ptrdiff>(Range::Num(Range));
return static_cast<ptrdiff>(Ranges::Num(Range));
}
else return Algorithm::Distance(Range::Begin(Range), Range::End(Range));
else return Algorithms::Distance(Ranges::Begin(Range), Ranges::End(Range));
}
/** @return The 'N'-th successor of iterator 'Iter'. */
template <CInputIterator I>
NODISCARD FORCEINLINE constexpr I Next(I Iter, ptrdiff N = 1)
{
Algorithm::Advance(Iter, N);
Algorithms::Advance(Iter, N);
return Iter;
}
@ -74,11 +75,11 @@ NODISCARD FORCEINLINE constexpr I Next(I Iter, ptrdiff N = 1)
template <CBidirectionalIterator I>
NODISCARD FORCEINLINE constexpr I Prev(I Iter, ptrdiff N = 1)
{
Algorithm::Advance(Iter, -N);
Algorithms::Advance(Iter, -N);
return Iter;
}
NAMESPACE_END(Algorithm)
NAMESPACE_END(Algorithms)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

38
Redcraft.Utility/Source/Public/Containers/Array.h
View File

@ -4,7 +4,7 @@
#include "TypeTraits/TypeTraits.h"
#include "Templates/Utility.h"
#include "Templates/TypeHash.h"
#include "Memory/Allocator.h"
#include "Memory/Allocators.h"
#include "Memory/MemoryOperator.h"
#include "Iterators/Utility.h"
#include "Iterators/BasicIterator.h"
@ -60,7 +60,7 @@ public:
/** Constructs the container with 'Count' copies of elements with 'InValue'. */
FORCEINLINE explicit TArray(size_t Count, const FElementType& InValue) requires (CCopyConstructible<T>)
: TArray(Range::Repeat(InValue, Count))
: TArray(Ranges::Repeat(InValue, Count))
{ }
/** Constructs the container with the contents of the range ['First', 'Last'). */
@ -104,7 +104,7 @@ public:
/** Constructs the container with the contents of the range. */
template <CInputRange R> requires (!CSameAs<TRemoveCVRef<R>, TArray> && CConstructibleFrom<T, TRangeReference<R>> && CMovable<T>)
FORCEINLINE explicit TArray(R&& Range) : TArray(Range::Begin(Range), Range::End(Range)) { }
FORCEINLINE explicit TArray(R&& Range) : TArray(Ranges::Begin(Range), Ranges::End(Range)) { }
/** Copy constructor. Constructs the container with the copy of the contents of 'InValue'. */
TArray(const TArray& InValue) requires (CCopyConstructible<T>)
@ -142,7 +142,7 @@ public:
}
/** Constructs the container with the contents of the initializer list. */
FORCEINLINE TArray(initializer_list<FElementType> IL) requires (CCopyConstructible<T>) : TArray(Range::Begin(IL), Range::End(IL)) { }
FORCEINLINE TArray(initializer_list<FElementType> IL) requires (CCopyConstructible<T>) : TArray(Ranges::Begin(IL), Ranges::End(IL)) { }
/** Destructs the array. The destructors of the elements are called and the used storage is deallocated. */
~TArray()
@ -256,38 +256,38 @@ public:
/** Replaces the contents with those identified by initializer list. */
TArray& operator=(initializer_list<FElementType> IL) requires (CCopyable<T>)
{
size_t NumToAllocate = Range::Num(IL);
size_t NumToAllocate = Ranges::Num(IL);
NumToAllocate = NumToAllocate > Max() ? Impl->CalculateSlackGrow (Range::Num(IL), Max()) : NumToAllocate;
NumToAllocate = NumToAllocate < Max() ? Impl->CalculateSlackShrink(Range::Num(IL), Max()) : NumToAllocate;
NumToAllocate = NumToAllocate > Max() ? Impl->CalculateSlackGrow (Ranges::Num(IL), Max()) : NumToAllocate;
NumToAllocate = NumToAllocate < Max() ? Impl->CalculateSlackShrink(Ranges::Num(IL), Max()) : NumToAllocate;
if (NumToAllocate != Max())
{
Memory::Destruct(Impl.Pointer, Num());
Impl->Deallocate(Impl.Pointer);
Impl.ArrayNum = Range::Num(IL);
Impl.ArrayNum = Ranges::Num(IL);
Impl.ArrayMax = NumToAllocate;
Impl.Pointer = Impl->Allocate(Max());
Memory::CopyConstruct<FElementType>(Impl.Pointer, Range::GetData(IL), Num());
Memory::CopyConstruct<FElementType>(Impl.Pointer, Ranges::GetData(IL), Num());
return *this;
}
if (Range::Num(IL) <= Num())
if (Ranges::Num(IL) <= Num())
{
Memory::CopyAssign(Impl.Pointer, Range::GetData(IL), Range::Num(IL));
Memory::Destruct(Impl.Pointer + Range::Num(IL), Num() - Range::Num(IL));
Memory::CopyAssign(Impl.Pointer, Ranges::GetData(IL), Ranges::Num(IL));
Memory::Destruct(Impl.Pointer + Ranges::Num(IL), Num() - Ranges::Num(IL));
}
else if (Range::Num(IL) <= Max())
else if (Ranges::Num(IL) <= Max())
{
Memory::CopyAssign(Impl.Pointer, Range::GetData(IL), Num());
Memory::CopyConstruct<FElementType>(Impl.Pointer + Num(), Range::GetData(IL) + Num(), Range::Num(IL) - Num());
Memory::CopyAssign(Impl.Pointer, Ranges::GetData(IL), Num());
Memory::CopyConstruct<FElementType>(Impl.Pointer + Num(), Ranges::GetData(IL) + Num(), Ranges::Num(IL) - Num());
}
else check_no_entry();
Impl.ArrayNum = Range::Num(IL);
Impl.ArrayNum = Ranges::Num(IL);
return *this;
}
@ -419,7 +419,7 @@ public:
{
checkf(IsValidIterator(Iter), TEXT("Read access violation. Please check IsValidIterator()."));
return Insert(Iter, Range::Repeat(InValue, Count));
return Insert(Iter, Ranges::Repeat(InValue, Count));
}
/** Inserts elements from range ['First', 'Last') before 'Iter'. */
@ -546,13 +546,13 @@ public:
template <CInputRange R> requires (CConstructibleFrom<T, TRangeReference<R>> && CAssignableFrom<T&, TRangeReference<R>> && CMovable<T>)
FORCEINLINE FIterator Insert(FConstIterator Iter, R&& Range)
{
return Insert(Iter, Range::Begin(Range), Range::End(Range));
return Insert(Iter, Ranges::Begin(Range), Ranges::End(Range));
}
/** Inserts elements from initializer list before 'Iter' in the container. */
FORCEINLINE FIterator Insert(FConstIterator Iter, initializer_list<FElementType> IL) requires (CCopyable<T>)
{
return Insert(Iter, Range::Begin(IL), Range::End(IL));
return Insert(Iter, Ranges::Begin(IL), Ranges::End(IL));
}
/** Inserts a new element into the container directly before 'Iter'. */

14
Redcraft.Utility/Source/Public/Containers/Bitset.h
View File

@ -5,7 +5,7 @@
#include "Templates/Utility.h"
#include "Templates/TypeHash.h"
#include "Templates/Noncopyable.h"
#include "Memory/Allocator.h"
#include "Memory/Allocators.h"
#include "Iterators/Utility.h"
#include "Iterators/BasicIterator.h"
#include "Iterators/Sentinel.h"
@ -135,7 +135,7 @@ public:
/** Constructs the bitset with the bits of the range. */
template <CInputRange R> requires (!CSameAs<TRemoveCVRef<R>, TBitset> && CConstructibleFrom<bool, TRangeReference<R>>)
FORCEINLINE explicit TBitset(R&& Range) : TBitset(Range::Begin(Range), Range::End(Range)) { }
FORCEINLINE explicit TBitset(R&& Range) : TBitset(Ranges::Begin(Range), Ranges::End(Range)) { }
/** Copy constructor. Constructs the bitset with the copy of the bits of 'InValue'. */
FORCEINLINE TBitset(const TBitset& InValue)
@ -171,7 +171,7 @@ public:
}
/** Constructs the bitset with the bits of the initializer list. */
FORCEINLINE TBitset(initializer_list<bool> IL) : TBitset(Range::Begin(IL), Range::End(IL)) { }
FORCEINLINE TBitset(initializer_list<bool> IL) : TBitset(Ranges::Begin(IL), Ranges::End(IL)) { }
/** Destructs the bitset. The storage is deallocated. */
~TBitset()
@ -239,9 +239,9 @@ public:
/** Replaces the bits with those identified by initializer list. */
TBitset& operator=(initializer_list<bool> IL)
{
auto First = Range::Begin(IL);
auto First = Ranges::Begin(IL);
const size_t BlocksCount = (Range::Num(IL) + BlockWidth - 1) / BlockWidth;
const size_t BlocksCount = (Ranges::Num(IL) + BlockWidth - 1) / BlockWidth;
size_t NumToAllocate = BlocksCount;
@ -252,7 +252,7 @@ public:
{
Impl->Deallocate(Impl.Pointer);
Impl.BitsetNum = Range::Num(IL);
Impl.BitsetNum = Ranges::Num(IL);
Impl.BlocksMax = NumToAllocate;
Impl.Pointer = Impl->Allocate(MaxBlocks());
@ -261,7 +261,7 @@ public:
return *this;
}
Impl.BitsetNum = Range::Num(IL);
Impl.BitsetNum = Ranges::Num(IL);
for (FReference Ref : *this) Ref = *First++;

24
Redcraft.Utility/Source/Public/Containers/List.h
View File

@ -4,7 +4,7 @@
#include "TypeTraits/TypeTraits.h"
#include "Templates/Utility.h"
#include "Templates/TypeHash.h"
#include "Memory/Allocator.h"
#include "Memory/Allocators.h"
#include "Memory/MemoryOperator.h"
#include "Iterators/Utility.h"
#include "Iterators/BasicIterator.h"
@ -79,7 +79,7 @@ public:
/** Constructs the container with 'Count' copies of elements with 'InValue'. */
TList(size_t Count, const FElementType& InValue) requires (CCopyable<FElementType>)
: TList(Range::Repeat(InValue, Count))
: TList(Ranges::Repeat(InValue, Count))
{ }
/** Constructs the container with the contents of the range ['First', 'Last'). */
@ -106,7 +106,7 @@ public:
/** Constructs the container with the contents of the range. */
template <CInputRange R> requires (!CSameAs<TRemoveCVRef<R>, TList> && CConstructibleFrom<FElementType, TRangeReference<R>>)
FORCEINLINE explicit TList(R&& Range) : TList(Range::Begin(Range), Range::End(Range)) { }
FORCEINLINE explicit TList(R&& Range) : TList(Ranges::Begin(Range), Ranges::End(Range)) { }
/** Copy constructor. Constructs the container with the copy of the contents of 'InValue'. */
FORCEINLINE TList(const TList& InValue) requires (CCopyConstructible<FElementType>) : TList(InValue.Begin(), InValue.End()) { }
@ -115,7 +115,7 @@ public:
FORCEINLINE TList(TList&& InValue) : TList() { Swap(*this, InValue); }
/** Constructs the container with the contents of the initializer list. */
FORCEINLINE TList(initializer_list<FElementType> IL) requires (CCopyConstructible<FElementType>) : TList(Range::Begin(IL), Range::End(IL)) { }
FORCEINLINE TList(initializer_list<FElementType> IL) requires (CCopyConstructible<FElementType>) : TList(Ranges::Begin(IL), Ranges::End(IL)) { }
/** Destructs the list. The destructors of the elements are called and the used storage is deallocated. */
~TList()
@ -176,9 +176,9 @@ public:
TList& operator=(initializer_list<FElementType> IL) requires (CCopyable<FElementType>)
{
FIterator ThisIter = Begin();
const FElementType* OtherIter = Range::Begin(IL);
const FElementType* OtherIter = Ranges::Begin(IL);
while (ThisIter != End() && OtherIter != Range::End(IL))
while (ThisIter != End() && OtherIter != Ranges::End(IL))
{
*ThisIter = *OtherIter;
@ -188,18 +188,18 @@ public:
if (ThisIter == End())
{
while (OtherIter != Range::End(IL))
while (OtherIter != Ranges::End(IL))
{
EmplaceBack(*OtherIter);
++OtherIter;
}
}
else if (OtherIter == Range::End(IL))
else if (OtherIter == Ranges::End(IL))
{
Erase(ThisIter, End());
}
Impl.ListNum = Range::Num(IL);
Impl.ListNum = Ranges::Num(IL);
return *this;
}
@ -251,7 +251,7 @@ public:
/** Inserts 'Count' copies of the 'InValue' before 'Iter' in the container. */
FIterator Insert(FConstIterator Iter, size_t Count, const FElementType& InValue) requires (CCopyConstructible<FElementType>)
{
return Insert(Iter, Range::Repeat(InValue, Count));
return Insert(Iter, Ranges::Repeat(InValue, Count));
}
/** Inserts elements from range ['First', 'Last') before 'Iter'. */
@ -291,10 +291,10 @@ public:
/** Inserts elements from range ['First', 'Last') before 'Iter'. */
template <CInputRange R> requires (CConstructibleFrom<FElementType, TRangeReference<R>>)
FORCEINLINE FIterator Insert(FConstIterator Iter, R&& Range) { return Insert(Iter, Range::Begin(Range), Range::End(Range)); }
FORCEINLINE FIterator Insert(FConstIterator Iter, R&& Range) { return Insert(Iter, Ranges::Begin(Range), Ranges::End(Range)); }
/** Inserts elements from initializer list before 'Iter' in the container. */
FORCEINLINE FIterator Insert(FConstIterator Iter, initializer_list<FElementType> IL) requires (CCopyConstructible<FElementType>) { return Insert(Iter, Range::Begin(IL), Range::End(IL)); }
FORCEINLINE FIterator Insert(FConstIterator Iter, initializer_list<FElementType> IL) requires (CCopyConstructible<FElementType>) { return Insert(Iter, Ranges::Begin(IL), Ranges::End(IL)); }
/** Inserts a new element into the container directly before 'Iter'. */
template <typename... Ts> requires (CConstructibleFrom<FElementType, Ts...>)

0
Redcraft.Utility/Source/Public/Memory/Allocator.h → Redcraft.Utility/Source/Public/Memory/Allocators.h
View File

2
Redcraft.Utility/Source/Public/Numerics/Bit.h
View File

@ -2,7 +2,7 @@
#include "CoreTypes.h"
#include "Numerics/Limits.h"
#include "Numerics/Literal.h"
#include "Numerics/Literals.h"
#include "TypeTraits/TypeTraits.h"
#include <bit>

0
Redcraft.Utility/Source/Public/Numerics/Literal.h → Redcraft.Utility/Source/Public/Numerics/Literals.h
View File

2
Redcraft.Utility/Source/Public/Numerics/Numerics.h
View File

@ -1,7 +1,7 @@
#pragma once
#include "CoreTypes.h"
#include "Numerics/Literal.h"
#include "Numerics/Literals.h"
#include "Numerics/Limits.h"
#include "Numerics/Numbers.h"
#include "Numerics/Bit.h"

52
Redcraft.Utility/Source/Public/Ranges/AllView.h
View File

@ -11,7 +11,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/**
* A view adapter that references other range.
@ -31,12 +31,12 @@ public:
template <typename T> requires (!CSameAs<TRemoveCVRef<T>, TRefView> && CConvertibleTo<T, R&> && requires { Func(DeclVal<T>()); })
FORCEINLINE constexpr TRefView(T&& InRange) : Ptr(AddressOf(static_cast<R&>(Forward<T>(InRange)))) { }
NODISCARD FORCEINLINE constexpr TRangeIterator<R> Begin() const { return Range::Begin(*Ptr); }
NODISCARD FORCEINLINE constexpr TRangeSentinel<R> End() const { return Range::End (*Ptr); }
NODISCARD FORCEINLINE constexpr TRangeIterator<R> Begin() const { return Ranges::Begin(*Ptr); }
NODISCARD FORCEINLINE constexpr TRangeSentinel<R> End() const { return Ranges::End (*Ptr); }
NODISCARD FORCEINLINE constexpr auto GetData() const requires (CContiguousRange<R>) { return Range::GetData(*Ptr); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<R>) { return Range::Num (*Ptr); }
NODISCARD FORCEINLINE constexpr bool IsEmpty() const requires (requires(R Range) { Range::IsEmpty(Range); }) { return Range::IsEmpty(*Ptr); }
NODISCARD FORCEINLINE constexpr auto GetData() const requires (CContiguousRange<R>) { return Ranges::GetData(*Ptr); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<R>) { return Ranges::Num (*Ptr); }
NODISCARD FORCEINLINE constexpr bool IsEmpty() const requires (requires(R Range) { Ranges::IsEmpty(Range); }) { return Ranges::IsEmpty(*Ptr); }
NODISCARD FORCEINLINE constexpr R& GetBase() const { return *Ptr; }
@ -61,12 +61,12 @@ static_assert( CView<TRefView< IRange<IInputOrOutputIterator<int>>>>)
static_assert(COutputRange<TRefView<IRange<IOutputIterator<int&>>>, int>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename T>
constexpr bool bEnableBorrowedRange<Range::TRefView<T>> = true;
constexpr bool bEnableBorrowedRange<Ranges::TRefView<T>> = true;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/**
* A view adapter that has unique ownership of a range.
@ -88,19 +88,19 @@ public:
FORCEINLINE constexpr TOwningView& operator=(const TOwningView&) = delete;
FORCEINLINE constexpr TOwningView& operator=(TOwningView&&) = default;
NODISCARD FORCEINLINE constexpr auto Begin() { return Range::Begin(Base); }
NODISCARD FORCEINLINE constexpr auto End() { return Range::End (Base); }
NODISCARD FORCEINLINE constexpr auto Begin() const requires (CRange<const R>) { return Range::Begin(Base); }
NODISCARD FORCEINLINE constexpr auto End() const requires (CRange<const R>) { return Range::End (Base); }
NODISCARD FORCEINLINE constexpr auto Begin() { return Ranges::Begin(Base); }
NODISCARD FORCEINLINE constexpr auto End() { return Ranges::End (Base); }
NODISCARD FORCEINLINE constexpr auto Begin() const requires (CRange<const R>) { return Ranges::Begin(Base); }
NODISCARD FORCEINLINE constexpr auto End() const requires (CRange<const R>) { return Ranges::End (Base); }
NODISCARD FORCEINLINE constexpr auto GetData() requires (CContiguousRange< R>) { return Range::GetData(Base); }
NODISCARD FORCEINLINE constexpr auto GetData() const requires (CContiguousRange<const R>) { return Range::GetData(Base); }
NODISCARD FORCEINLINE constexpr auto GetData() requires (CContiguousRange< R>) { return Ranges::GetData(Base); }
NODISCARD FORCEINLINE constexpr auto GetData() const requires (CContiguousRange<const R>) { return Ranges::GetData(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() requires (CSizedRange< R>) { return Range::Num(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<const R>) { return Range::Num(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() requires (CSizedRange< R>) { return Ranges::Num(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<const R>) { return Ranges::Num(Base); }
NODISCARD FORCEINLINE constexpr bool IsEmpty() requires (requires( R Base) { Range::IsEmpty(Base); }) { return Range::IsEmpty(Base); }
NODISCARD FORCEINLINE constexpr bool IsEmpty() const requires (requires(const R Base) { Range::IsEmpty(Base); }) { return Range::IsEmpty(Base); }
NODISCARD FORCEINLINE constexpr bool IsEmpty() requires (requires( R Base) { Ranges::IsEmpty(Base); }) { return Ranges::IsEmpty(Base); }
NODISCARD FORCEINLINE constexpr bool IsEmpty() const requires (requires(const R Base) { Ranges::IsEmpty(Base); }) { return Ranges::IsEmpty(Base); }
NODISCARD FORCEINLINE constexpr R& GetBase() & { return Base; }
NODISCARD FORCEINLINE constexpr R&& GetBase() && { return MoveTemp(Base); }
@ -125,12 +125,12 @@ static_assert( CView<TOwningView< IRange<IInputOrOutputIterator<int>>
static_assert(COutputRange<TOwningView<IRange<IOutputIterator<int&>>>, int>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename T>
constexpr bool bEnableBorrowedRange<Range::TOwningView<T>> = bEnableBorrowedRange<T>;
constexpr bool bEnableBorrowedRange<Ranges::TOwningView<T>> = bEnableBorrowedRange<T>;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** Creates A view adapter that includes all elements of a range. */
template <CViewableRange R>
@ -152,9 +152,9 @@ NODISCARD FORCEINLINE constexpr auto All(R&& InRange)
/** Creates A view adapter that includes all elements of a range. */
NODISCARD FORCEINLINE constexpr auto All()
{
using FClosure = decltype([]<CViewableRange R> requires (requires { Range::All(DeclVal<R>()); }) (R&& Base)
using FClosure = decltype([]<CViewableRange R> requires (requires { Ranges::All(DeclVal<R>()); }) (R&& Base)
{
return Range::All(Forward<R>(Base));
return Ranges::All(Forward<R>(Base));
});
return TAdaptorClosure<FClosure>();
@ -162,7 +162,7 @@ NODISCARD FORCEINLINE constexpr auto All()
/** A view adapter that includes all elements of a range. */
template <CViewableRange R>
using TAllView = decltype(Range::All(DeclVal<R>()));
using TAllView = decltype(Ranges::All(DeclVal<R>()));
static_assert( CInputRange<TAllView<IRange< IInputIterator<int&>>>>);
static_assert( CForwardRange<TAllView<IRange< IForwardIterator<int&>>>>);
@ -176,7 +176,7 @@ static_assert( CView<TAllView< IRange<IInputOrOutputIterator<int>>>>)
static_assert(COutputRange<TAllView<IRange<IOutputIterator<int&>>>, int>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

22
Redcraft.Utility/Source/Public/Ranges/Conversion.h
View File

@ -49,7 +49,7 @@ concept CAppendableContainer =
);
};
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** Constructs a non-view object from the elements of the range. */
template <typename C, CInputRange R, typename... Ts> requires (!CView<C>)
@ -64,7 +64,7 @@ NODISCARD FORCEINLINE constexpr auto To(R&& Range, Ts&&... Args)
else if constexpr (CCommonRange<R> && CInputRange<R> && CConstructibleFrom<C, TRangeIterator<R>, TRangeSentinel<R>, Ts...>)
{
return C(Range::Begin(Range), Range::End(Range), Forward<Ts>(Args)...);
return C(Ranges::Begin(Range), Ranges::End(Range), Forward<Ts>(Args)...);
}
else if constexpr (CConstructibleFrom<C, Ts...> && CAppendableContainer<C, TRangeReference<R>>)
@ -73,7 +73,7 @@ NODISCARD FORCEINLINE constexpr auto To(R&& Range, Ts&&... Args)
if constexpr (CSizedRange<R> && CReservableContainer<C>)
{
Result.Reserve(Range::Num(Range));
Result.Reserve(Ranges::Num(Range));
}
for (TRangeReference<R> Element : Range)
@ -108,7 +108,7 @@ NODISCARD FORCEINLINE constexpr auto To(R&& Range, Ts&&... Args)
{
if constexpr (CInputRange<TRangeReference<C>>)
{
return Range::To<C>(Range::All(Range) | Range::Transform([]<typename T>(T&& Element) { return Range::To<TRangeElement<C>>(Forward<T>(Element)); }), Forward<Args>(Args)...);
return Ranges::To<C>(Ranges::All(Range) | Ranges::Transform([]<typename T>(T&& Element) { return Ranges::To<TRangeElement<C>>(Forward<T>(Element)); }), Forward<Args>(Args)...);
}
else static_assert(sizeof(R) == -1, "The container type is not constructible from a range");
@ -121,12 +121,12 @@ NODISCARD FORCEINLINE constexpr auto To(R&& Range, Ts&&... Args)
{
if constexpr (requires { C(DeclVal<R>(), DeclVal<Ts>()...); })
{
return Range::To<decltype(C(DeclVal<R>(), DeclVal<Ts>()...))>(Forward<R>(Range), Forward<Ts>(Args)...);
return Ranges::To<decltype(C(DeclVal<R>(), DeclVal<Ts>()...))>(Forward<R>(Range), Forward<Ts>(Args)...);
}
else if constexpr (requires { C(DeclVal<TRangeIterator<R>>(), DeclVal<TRangeSentinel<R>>(), DeclVal<Args>()...); })
{
return Range::To<decltype(C(DeclVal<TRangeIterator<R>>(), DeclVal<TRangeSentinel<R>>(), DeclVal<Args>()...))>(Forward<R>(Range), Forward<Ts>(Args)...);
return Ranges::To<decltype(C(DeclVal<TRangeIterator<R>>(), DeclVal<TRangeSentinel<R>>(), DeclVal<Args>()...))>(Forward<R>(Range), Forward<Ts>(Args)...);
}
else static_assert(sizeof(R) == -1, "The container type is not constructible from a range");
@ -136,9 +136,9 @@ NODISCARD FORCEINLINE constexpr auto To(R&& Range, Ts&&... Args)
template <typename C, typename... Ts> requires (!CView<C>)
NODISCARD FORCEINLINE constexpr auto To(Ts&&... Args)
{
using FClosure = decltype([]<CInputRange R, typename... Us> requires (requires { Range::To<C>(DeclVal<R>(), DeclVal<Us>()...); }) (R&& Range, Us&&... Args)
using FClosure = decltype([]<CInputRange R, typename... Us> requires (requires { Ranges::To<C>(DeclVal<R>(), DeclVal<Us>()...); }) (R&& Range, Us&&... Args)
{
return Range::To<C>(Forward<R>(Range), Forward<Us>(Args)...);
return Ranges::To<C>(Forward<R>(Range), Forward<Us>(Args)...);
});
return TAdaptorClosure<FClosure, TDecay<Ts>...>(Forward<Ts>(Args)...);
@ -148,15 +148,15 @@ NODISCARD FORCEINLINE constexpr auto To(Ts&&... Args)
template <template <typename...> typename C, typename... Ts>
NODISCARD FORCEINLINE constexpr auto To(Ts&&... Args)
{
using FClosure = decltype([]<CInputRange R, typename... Us> requires (requires { Range::To<C>(DeclVal<R>(), DeclVal<Us>()...); }) (R&& Range, Us&&... Args)
using FClosure = decltype([]<CInputRange R, typename... Us> requires (requires { Ranges::To<C>(DeclVal<R>(), DeclVal<Us>()...); }) (R&& Range, Us&&... Args)
{
return Range::To<C>(Forward<R>(Range), Forward<Us>(Args)...);
return Ranges::To<C>(Forward<R>(Range), Forward<Us>(Args)...);
});
return TAdaptorClosure<FClosure, TDecay<Ts>...>(Forward<Ts>(Args)...);
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

20
Redcraft.Utility/Source/Public/Ranges/Factory.h
View File

@ -11,7 +11,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** A view type that produces a view of no elements of a particular type. */
template <CObject T>
@ -39,12 +39,12 @@ static_assert( CCommonRange<TEmptyView<int>>);
static_assert( CSizedRange<TEmptyView<int>>);
static_assert( CView<TEmptyView<int>>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename T>
constexpr bool bEnableBorrowedRange<Range::TEmptyView<T>> = true;
constexpr bool bEnableBorrowedRange<Ranges::TEmptyView<T>> = true;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** A view type that contains exactly one element of a specified value. */
template <CObject T> requires (CMoveConstructible<T>)
@ -190,12 +190,12 @@ TIotaView(T, U) -> TIotaView<T, U>;
static_assert(CForwardRange<TIotaView<int>>);
static_assert( CView<TIotaView<int>>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename T, typename U>
constexpr bool bEnableBorrowedRange<Range::TIotaView<T, U>> = true;
constexpr bool bEnableBorrowedRange<Ranges::TIotaView<T, U>> = true;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** A view type that generates a sequence of elements by repeatedly producing the same value. Can be either bounded or unbounded. */
template <CObject W, bool bIsUnreachable = true> requires (CMoveConstructible<W> && CSameAs<W, TRemoveCV<W>>)
@ -307,9 +307,9 @@ static_assert( CCommonRange<TRepeatView<int, false>>);
static_assert( CSizedRange<TRepeatView<int, false>>);
static_assert( CView<TRepeatView<int, false>>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** A view of no elements of a particular type. */
template <CObject T>
@ -350,7 +350,7 @@ NODISCARD FORCEINLINE constexpr TRepeatView<TDecay<W>, false> Repeat(W&& Value,
return TRepeatView<TDecay<W>, false>(Forward<W>(Value), Count);
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

16
Redcraft.Utility/Source/Public/Ranges/FilterView.h
View File

@ -16,7 +16,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/**
* A view adapter that consists of the elements of a range that satisfies a predicate.
@ -46,7 +46,7 @@ public:
NODISCARD FORCEINLINE constexpr FIterator Begin()
{
FIterator Iter(*this, Range::Begin(Base));
FIterator Iter(*this, Ranges::Begin(Base));
do
{
@ -63,7 +63,7 @@ public:
return Iter;
}
NODISCARD FORCEINLINE constexpr FSentinel End() { return FSentinel(*this, Range::End(Base)); }
NODISCARD FORCEINLINE constexpr FSentinel End() { return FSentinel(*this, Ranges::End(Base)); }
NODISCARD FORCEINLINE constexpr V GetBase() const& requires (CCopyConstructible<V>) { return Base; }
NODISCARD FORCEINLINE constexpr V GetBase() && { return MoveTemp(Base); }
@ -161,9 +161,9 @@ static_assert(CBidirectionalRange<TFilterView<TAllView<IRange< IContiguousIter
static_assert(CCommonRange<TFilterView<TAllView<ICommonRange<IForwardIterator<int>>>, bool(*)(int)>>);
static_assert( CView<TFilterView<TAllView< IRange< IInputIterator<int>>>, bool(*)(int)>>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** Creates A view adapter that consists of the elements of a range that satisfies a predicate. */
template <CViewableRange R, typename Pred> requires (requires { TFilterView(DeclVal<R>(), DeclVal<Pred>()); })
@ -176,15 +176,15 @@ NODISCARD FORCEINLINE constexpr auto Filter(R&& Base, Pred&& Predicate)
template <typename Pred>
NODISCARD FORCEINLINE constexpr auto Filter(Pred&& Predicate)
{
using FClosure = decltype([]<CViewableRange R, typename T> requires (requires { Range::Filter(DeclVal<R>(), DeclVal<T>()); }) (R&& Base, T&& Predicate)
using FClosure = decltype([]<CViewableRange R, typename T> requires (requires { Ranges::Filter(DeclVal<R>(), DeclVal<T>()); }) (R&& Base, T&& Predicate)
{
return Range::Filter(Forward<R>(Base), Forward<T>(Predicate));
return Ranges::Filter(Forward<R>(Base), Forward<T>(Predicate));
});
return TAdaptorClosure<FClosure, TDecay<Pred>>(Forward<Pred>(Predicate));
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

30
Redcraft.Utility/Source/Public/Ranges/MoveView.h
View File

@ -15,7 +15,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/**
* A view adapter which dereferences to a rvalue reference.
@ -36,34 +36,34 @@ public:
NODISCARD FORCEINLINE constexpr auto Begin() requires (!CSimpleView<V>)
{
return MakeMoveIterator(Range::Begin(Base));
return MakeMoveIterator(Ranges::Begin(Base));
}
NODISCARD FORCEINLINE constexpr auto Begin() const requires (CRange<const V>)
{
return MakeMoveIterator(Range::Begin(Base));
return MakeMoveIterator(Ranges::Begin(Base));
}
NODISCARD FORCEINLINE constexpr auto End() requires (!CSimpleView<V>)
{
if constexpr (CCommonRange<V>)
{
return MakeMoveIterator(Range::End(Base));
return MakeMoveIterator(Ranges::End(Base));
}
else return MakeMoveSentinel(Range::End(Base));
else return MakeMoveSentinel(Ranges::End(Base));
}
NODISCARD FORCEINLINE constexpr auto End() const requires (CRange<const V>)
{
if constexpr (CCommonRange<V>)
{
return MakeMoveIterator(Range::End(Base));
return MakeMoveIterator(Ranges::End(Base));
}
else return MakeMoveSentinel(Range::End(Base));
else return MakeMoveSentinel(Ranges::End(Base));
}
NODISCARD FORCEINLINE constexpr size_t Num() requires (CSizedRange< V>) { return Range::Num(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<const V>) { return Range::Num(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() requires (CSizedRange< V>) { return Ranges::Num(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<const V>) { return Ranges::Num(Base); }
NODISCARD FORCEINLINE constexpr V GetBase() const& requires (CCopyConstructible<V>) { return Base; }
NODISCARD FORCEINLINE constexpr V GetBase() && { return MoveTemp(Base); }
@ -86,12 +86,12 @@ static_assert( CRandomAccessRange<TMoveView<TAllView<IRange< IContiguousIterat
static_assert(CCommonRange<TMoveView<TAllView<ICommonRange<IForwardIterator<int>>>>>);
static_assert( CView<TMoveView<TAllView< IRange< IInputIterator<int>>>>>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename T>
constexpr bool bEnableBorrowedRange<Range::TMoveView<T>> = bEnableBorrowedRange<T>;
constexpr bool bEnableBorrowedRange<Ranges::TMoveView<T>> = bEnableBorrowedRange<T>;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** Creates A view adapter that dereferences to a rvalue reference. */
template <CViewableRange R> requires (requires { TMoveView(DeclVal<R>()); })
@ -103,15 +103,15 @@ NODISCARD FORCEINLINE constexpr auto Move(R&& Base)
/** Creates A view adapter that dereferences to a rvalue reference. */
NODISCARD FORCEINLINE constexpr auto Move()
{
using FClosure = decltype([]<CViewableRange R> requires (requires { Range::Move(DeclVal<R>()); }) (R&& Base)
using FClosure = decltype([]<CViewableRange R> requires (requires { Ranges::Move(DeclVal<R>()); }) (R&& Base)
{
return Range::Move(Forward<R>(Base));
return Ranges::Move(Forward<R>(Base));
});
return TAdaptorClosure<FClosure>();
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

4
Redcraft.Utility/Source/Public/Ranges/Pipe.h
View File

@ -11,7 +11,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/**
* An interface class template for defining a range adaptor closure.
@ -139,7 +139,7 @@ NODISCARD FORCEINLINE constexpr auto operator|(T&& LHS, U&& RHS)
return TPipeClosure<TRemoveCVRef<T>, TRemoveCVRef<U>>(Forward<T>(LHS), Forward<U>(RHS));
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

38
Redcraft.Utility/Source/Public/Ranges/TakeView.h
View File

@ -16,7 +16,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/**
* A view adapter that includes a specified number of elements from the beginning of a range.
@ -42,11 +42,11 @@ public:
{
if constexpr (CRandomAccessRange<V>)
{
return Range::Begin(Base);
return Ranges::Begin(Base);
}
else return MakeCountedIterator(Range::Begin(Base), Num());
else return MakeCountedIterator(Ranges::Begin(Base), Num());
}
else return MakeCountedIterator(Range::Begin(Base), Count);
else return MakeCountedIterator(Ranges::Begin(Base), Count);
}
NODISCARD FORCEINLINE constexpr auto Begin() const requires (CRange<const V>)
@ -55,11 +55,11 @@ public:
{
if constexpr (CRandomAccessRange<const V>)
{
return Range::Begin(Base);
return Ranges::Begin(Base);
}
else return MakeCountedIterator(Range::Begin(Base), Num());
else return MakeCountedIterator(Ranges::Begin(Base), Num());
}
else return MakeCountedIterator(Range::Begin(Base), Count);
else return MakeCountedIterator(Ranges::Begin(Base), Count);
}
NODISCARD FORCEINLINE constexpr auto End() requires (!CSimpleView<V>)
@ -68,11 +68,11 @@ public:
{
if constexpr (CRandomAccessRange<V>)
{
return Range::Begin(Base) + Num();
return Ranges::Begin(Base) + Num();
}
else return DefaultSentinel;
}
else return FSentinelImpl<false>(Range::End(Base));
else return FSentinelImpl<false>(Ranges::End(Base));
}
NODISCARD FORCEINLINE constexpr auto End() const requires (CRange<const V>)
@ -81,15 +81,15 @@ public:
{
if constexpr (CRandomAccessRange<const V>)
{
return Range::Begin(Base) + Num();
return Ranges::Begin(Base) + Num();
}
else return DefaultSentinel;
}
else return FSentinelImpl<true>(Range::End(Base));
else return FSentinelImpl<true>(Ranges::End(Base));
}
NODISCARD FORCEINLINE constexpr size_t Num() requires (CSizedRange< V>) { return Math::Min(Range::Num(Base), Count); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<const V>) { return Math::Min(Range::Num(Base), Count); }
NODISCARD FORCEINLINE constexpr size_t Num() requires (CSizedRange< V>) { return Math::Min(Ranges::Num(Base), Count); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<const V>) { return Math::Min(Ranges::Num(Base), Count); }
NODISCARD FORCEINLINE constexpr V GetBase() const& requires (CCopyConstructible<V>) { return Base; }
NODISCARD FORCEINLINE constexpr V GetBase() && { return MoveTemp(Base); }
@ -154,12 +154,12 @@ static_assert( CView<TTakeView<TAllView< IRange<IInputOrOutputIterator
static_assert(COutputRange<TTakeView<TAllView<IRange<IOutputIterator<int&>>>>, int>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename T>
constexpr bool bEnableBorrowedRange<Range::TTakeView<T>> = bEnableBorrowedRange<T>;
constexpr bool bEnableBorrowedRange<Ranges::TTakeView<T>> = bEnableBorrowedRange<T>;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** Creates A view adapter that includes a specified number of elements from the beginning of a range. */
template <CViewableRange R> requires (requires { TTakeView(DeclVal<R>(), DeclVal<size_t>()); })
@ -171,15 +171,15 @@ NODISCARD FORCEINLINE constexpr auto Take(R&& Base, size_t Count)
/** Creates A view adapter that includes a specified number of elements from the beginning of a range. */
NODISCARD FORCEINLINE constexpr auto Take(size_t Count)
{
using FClosure = decltype([]<CViewableRange R> requires (requires { Range::Take(DeclVal<R>(), DeclVal<size_t>()); }) (R&& Base, size_t Count)
using FClosure = decltype([]<CViewableRange R> requires (requires { Ranges::Take(DeclVal<R>(), DeclVal<size_t>()); }) (R&& Base, size_t Count)
{
return Range::Take(Forward<R>(Base), Count);
return Ranges::Take(Forward<R>(Base), Count);
});
return TAdaptorClosure<FClosure, size_t>(Count);
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

20
Redcraft.Utility/Source/Public/Ranges/TakeWhileView.h
View File

@ -16,7 +16,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/**
* A view adapter that includes elements that satisfy the predicate from the beginning of the range.
@ -41,22 +41,22 @@ public:
NODISCARD FORCEINLINE constexpr auto Begin() requires (!CSimpleView<V>)
{
return Range::Begin(Base);
return Ranges::Begin(Base);
}
NODISCARD FORCEINLINE constexpr auto Begin() const requires (CRange<const V> && CPredicate<const Pred&, TRangeReference<const V>>)
{
return Range::Begin(Base);
return Ranges::Begin(Base);
}
NODISCARD FORCEINLINE constexpr auto End() requires (!CSimpleView<V>)
{
return FSentinelImpl<false>(Range::End(Base), AddressOf(Predicate));
return FSentinelImpl<false>(Ranges::End(Base), AddressOf(Predicate));
}
NODISCARD FORCEINLINE constexpr auto End() const requires (CRange<const V> && CPredicate<const Pred&, TRangeReference<const V>>)
{
return FSentinelImpl<true>(Range::End(Base), AddressOf(Predicate));
return FSentinelImpl<true>(Ranges::End(Base), AddressOf(Predicate));
}
NODISCARD FORCEINLINE constexpr V GetBase() const& requires (CCopyConstructible<V>) { return Base; }
@ -119,9 +119,9 @@ static_assert(CView<TTakeWhileView<TAllView<IRange<IInputIterator<int>>>, bool(*
static_assert(COutputRange<TTakeWhileView<TAllView<IRange<IForwardIterator<int&>>>, bool(*)(int)>, int>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** Creates A view adapter that includes elements that satisfy the predicate from the beginning of the range. */
template <CViewableRange R, typename Pred> requires (requires { TTakeWhileView(DeclVal<R>(), DeclVal<Pred>()); })
@ -134,15 +134,15 @@ NODISCARD FORCEINLINE constexpr auto TakeWhile(R&& Base, Pred&& Predicate)
template <typename Pred>
NODISCARD FORCEINLINE constexpr auto TakeWhile(Pred&& Predicate)
{
using FClosure = decltype([]<CViewableRange R, typename T> requires (requires { Range::TakeWhile(DeclVal<R>(), DeclVal<T>()); }) (R&& Base, T&& Predicate)
using FClosure = decltype([]<CViewableRange R, typename T> requires (requires { Ranges::TakeWhile(DeclVal<R>(), DeclVal<T>()); }) (R&& Base, T&& Predicate)
{
return Range::TakeWhile(Forward<R>(Base), Forward<T>(Predicate));
return Ranges::TakeWhile(Forward<R>(Base), Forward<T>(Predicate));
});
return TAdaptorClosure<FClosure, TDecay<Pred>>(Forward<Pred>(Predicate));
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

28
Redcraft.Utility/Source/Public/Ranges/TransformView.h
View File

@ -13,7 +13,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/**
* A view adapter of a sequence that applies a transformation function to each element.
@ -39,36 +39,36 @@ public:
NODISCARD FORCEINLINE constexpr auto Begin()
{
return FIteratorImpl<false>(*this, Range::Begin(Base));
return FIteratorImpl<false>(*this, Ranges::Begin(Base));
}
NODISCARD FORCEINLINE constexpr auto Begin() const requires (CRange<const V> && CRegularInvocable<const F&, TRangeReference<const V>>)
{
return FIteratorImpl<true>(*this, Range::Begin(Base));
return FIteratorImpl<true>(*this, Ranges::Begin(Base));
}
NODISCARD FORCEINLINE constexpr auto End()
{
if constexpr (CCommonRange<V>)
{
return FIteratorImpl<false>(*this, Range::End(Base));
return FIteratorImpl<false>(*this, Ranges::End(Base));
}
else return FSentinelImpl<false>(*this, Range::End(Base));
else return FSentinelImpl<false>(*this, Ranges::End(Base));
}
NODISCARD FORCEINLINE constexpr auto End() const requires (CRange<const V> && CRegularInvocable<const F&, TRangeReference<const V>>)
{
if constexpr (CCommonRange<const V>)
{
return FIteratorImpl<true>(*this, Range::End(Base));
return FIteratorImpl<true>(*this, Ranges::End(Base));
}
else return FSentinelImpl<true>(*this, Range::End(Base));
else return FSentinelImpl<true>(*this, Ranges::End(Base));
}
NODISCARD FORCEINLINE constexpr size_t Num() requires (CSizedRange< V>) { return Range::Num(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<const V>) { return Range::Num(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() requires (CSizedRange< V>) { return Ranges::Num(Base); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedRange<const V>) { return Ranges::Num(Base); }
NODISCARD FORCEINLINE constexpr V GetBase() const& requires (CCopyConstructible<V>) { return Base; }
NODISCARD FORCEINLINE constexpr V GetBase() && { return MoveTemp(Base); }
@ -206,9 +206,9 @@ static_assert( CView<TTransformView<TAllView< IRange< IInputIterator
static_assert(COutputRange<TTransformView<TAllView<IRange<IForwardIterator<int>>>, int&(*)(int)>, int>);
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** Creates A view adapter of a sequence that applies a transformation function to each element. */
template <CViewableRange R, typename F> requires (requires { TTransformView(DeclVal<R>(), DeclVal<F>()); })
@ -221,15 +221,15 @@ NODISCARD FORCEINLINE constexpr auto Transform(R&& Base, F&& Func)
template <typename F>
NODISCARD FORCEINLINE constexpr auto Transform(F&& Func)
{
using FClosure = decltype([]<CViewableRange R, typename T> requires (requires { Range::Transform(DeclVal<R>(), DeclVal<T>()); }) (R&& Base, T&& Func)
using FClosure = decltype([]<CViewableRange R, typename T> requires (requires { Ranges::Transform(DeclVal<R>(), DeclVal<T>()); }) (R&& Base, T&& Func)
{
return Range::Transform(Forward<R>(Base), Forward<T>(Func));
return Ranges::Transform(Forward<R>(Base), Forward<T>(Func));
});
return TAdaptorClosure<FClosure, TDecay<F>>(Forward<F>(Func));
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

50
Redcraft.Utility/Source/Public/Ranges/Utility.h
View File

@ -20,7 +20,7 @@ NAMESPACE_MODULE_BEGIN(Utility)
template <typename R>
inline constexpr bool bEnableBorrowedRange = false;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** @return The iterator to the beginning of a container. */
template <typename T> requires ((CLValueReference<T> || bEnableBorrowedRange<TRemoveCVRef<T>>)
@ -45,12 +45,12 @@ NODISCARD FORCEINLINE constexpr const T* Begin(initializer_list<T>& Container)
return Container.begin();
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename R>
using TRangeIterator = decltype(Range::Begin(DeclVal<R&>()));
using TRangeIterator = decltype(Ranges::Begin(DeclVal<R&>()));
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** @return The iterator to the end of a container. */
template <typename T> requires ((CLValueReference<T> || bEnableBorrowedRange<TRemoveCVRef<T>>)
@ -75,13 +75,13 @@ NODISCARD FORCEINLINE constexpr const T* End(initializer_list<T>& Container)
return Container.end();
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename R>
using TRangeSentinel = decltype(Range::End(DeclVal<R&>()));
using TRangeSentinel = decltype(Ranges::End(DeclVal<R&>()));
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** @return The reverse iterator to the beginning of a container. */
template <typename T> requires ((CLValueReference<T> || bEnableBorrowedRange<TRemoveCVRef<T>>)
@ -97,12 +97,12 @@ template <typename T> requires ((CLValueReference<T> || bEnableBorrowedRange<TRe
&& (CSameAs<TRangeIterator<T>, TRangeSentinel<T>> && CBidirectionalIterator<TRangeIterator<T>>))
NODISCARD FORCEINLINE constexpr auto RBegin(T&& Container)
{
return MakeReverseIterator(Range::End(Forward<T>(Container)));
return MakeReverseIterator(Ranges::End(Forward<T>(Container)));
}
/** @return The reverse iterator to the end of a container. */
template <typename T> requires ((CLValueReference<T> || bEnableBorrowedRange<TRemoveCVRef<T>>)
&& requires(T&& Container) { { Container.REnd() } -> CSentinelFor<decltype(Range::RBegin(DeclVal<T&>()))>; })
&& requires(T&& Container) { { Container.REnd() } -> CSentinelFor<decltype(Ranges::RBegin(DeclVal<T&>()))>; })
NODISCARD FORCEINLINE constexpr auto REnd(T&& Container)
{
return Container.REnd();
@ -110,14 +110,14 @@ NODISCARD FORCEINLINE constexpr auto REnd(T&& Container)
/** Overloads the REnd algorithm for synthesized. */
template <typename T> requires ((CLValueReference<T> || bEnableBorrowedRange<TRemoveCVRef<T>>)
&& !requires(T&& Container) { { Container.REnd() } -> CSentinelFor<decltype(Range::RBegin(DeclVal<T&>()))>; }
&& !requires(T&& Container) { { Container.REnd() } -> CSentinelFor<decltype(Ranges::RBegin(DeclVal<T&>()))>; }
&& (CSameAs<TRangeIterator<T>, TRangeSentinel<T>> && CBidirectionalIterator<TRangeIterator<T>>))
NODISCARD FORCEINLINE constexpr auto REnd(T&& Container)
{
return MakeReverseIterator(Range::Begin(Forward<T>(Container)));
return MakeReverseIterator(Ranges::Begin(Forward<T>(Container)));
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename R>
using TRangeElement = TIteratorElement<TRangeIterator<R>>;
@ -131,7 +131,7 @@ using TRangeReference = TIteratorReference<TRangeIterator<R>>;
template <typename R>
using TRangeRValueReference = TIteratorRValueReference<TRangeIterator<R>>;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** @return The pointer to the container element storage. */
template <typename T> requires ((CLValueReference<T> || bEnableBorrowedRange<TRemoveCVRef<T>>)
@ -144,19 +144,19 @@ NODISCARD FORCEINLINE constexpr auto GetData(T&& Container)
/** Overloads the GetData algorithm for synthesized. */
template <typename T> requires ((CLValueReference<T> || bEnableBorrowedRange<TRemoveCVRef<T>>)
&& !requires(T&& Container) { { Container.GetData() } -> CSameAs<TAddPointer<TRangeReference<T>>>; }
&& requires(T&& Container) { { Range::Begin(Forward<T>(Container)) } -> CContiguousIterator; })
&& requires(T&& Container) { { Ranges::Begin(Forward<T>(Container)) } -> CContiguousIterator; })
NODISCARD FORCEINLINE constexpr auto GetData(T&& Container)
{
return ToAddress(Range::Begin(Forward<T>(Container)));
return ToAddress(Ranges::Begin(Forward<T>(Container)));
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
/** Disable the CSizedRange concept for specific types. */
template <typename R>
inline constexpr bool bDisableSizedRange = false;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** @return The number of elements in the container. */
template <typename T> requires (!bDisableSizedRange<TRemoveCVRef<T>>
@ -180,7 +180,7 @@ template <typename T> requires (!bDisableSizedRange<TRemoveCVRef<T>>
&& CSizedSentinelFor<TRangeSentinel<T>, TRangeIterator<T>> && CForwardIterator<TRangeIterator<T>>)
NODISCARD FORCEINLINE constexpr size_t Num(T&& Container)
{
return Range::End(Forward<T>(Container)) - Range::Begin(Forward<T>(Container));
return Ranges::End(Forward<T>(Container)) - Ranges::Begin(Forward<T>(Container));
}
/** Overloads the Num algorithm for initializer_list. */
@ -203,7 +203,7 @@ template <typename T> requires ((CBoundedArray<TRemoveReference<T>>
&& !requires(T&& Container) { { Container.IsEmpty() } -> CBooleanTestable; })
NODISCARD FORCEINLINE constexpr bool IsEmpty(T&& Container)
{
return Range::Num(Forward<T>(Container)) == 0;
return Ranges::Num(Forward<T>(Container)) == 0;
}
/** Overloads the IsEmpty algorithm for synthesized. */
@ -213,10 +213,10 @@ template <typename T> requires (!CBoundedArray<TRemoveReference<T>>
&& CForwardIterator<TRangeIterator<T>>)
NODISCARD FORCEINLINE constexpr bool IsEmpty(T&& Container)
{
return Range::End(Forward<T>(Container)) == Range::Begin(Forward<T>(Container));
return Ranges::End(Forward<T>(Container)) == Ranges::Begin(Forward<T>(Container));
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
/**
* A concept specifies a type is a range.
@ -261,7 +261,7 @@ concept CBorrowedRange = CRange<R> && (CLValueReference<R> || bEnableBorrowedRan
/**
* A concept specifies a type is a sized range.
* Indicates the expression 'Range::Num(Range)' can get the size of the range at constant time
* Indicates the expression 'Ranges::Num(Range)' can get the size of the range at constant time
* without modifying the range object. Modifying the range usually occurs when the iterator of
* the range is an input iterator. Indirect calculation of the range by obtaining the iterator
* may cause the range to become invalid, that is, the iterator cannot be obtained again.
@ -270,7 +270,7 @@ template <typename R>
concept CSizedRange = CRange<R>
&& requires(R Range)
{
{ Range::Num(Range) } -> CConvertibleTo<size_t>;
{ Ranges::Num(Range) } -> CConvertibleTo<size_t>;
};
/** This is an example of a sized range type, indicate the traits that define a sized range type. */
@ -337,7 +337,7 @@ template <typename R>
concept CContiguousRange = CRandomAccessRange<R> && CContiguousIterator<TRangeIterator<R>>
&& requires(R& Range)
{
{ Range::GetData(Range) } -> CSameAs<TAddPointer<TRangeReference<R>>>;
{ Ranges::GetData(Range) } -> CSameAs<TAddPointer<TRangeReference<R>>>;
};
/** This is an example of a contiguous range type, indicate the traits that define a contiguous range type. */
@ -354,7 +354,7 @@ struct IContiguousRange /* : IRange<I, S> */
/**
* Get the pointer to the container element storage.
* The function is optional if the range size can be computed indirectly from the iterator.
* If the function is provided, then the expression 'ToAddress(Range::Begin(Range)) == Range::GetData(Range)'
* If the function is provided, then the expression 'ToAddress(Ranges::Begin(Range)) == Ranges::GetData(Range)'
* must be satisfied to always be true.
* If the function is const, it means that the const IContiguousRange satisfies CContiguousRange.
*/

62
Redcraft.Utility/Source/Public/Ranges/View.h
View File

@ -14,7 +14,7 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** An interface class template for defining a view. Not directly instantiable. */
template <CClass T> requires (CSameAs<T, TRemoveCV<T>>)
@ -23,43 +23,43 @@ class IBasicViewInterface
public:
/** @return The pointer to the underlying element storage. */
NODISCARD FORCEINLINE constexpr auto GetData() requires (CContiguousIterator<TRangeIterator< T>>) { return ToAddress(Range::Begin(static_cast< T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto GetData() const requires (CContiguousIterator<TRangeIterator<const T>>) { return ToAddress(Range::Begin(static_cast<const T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto GetData() requires (CContiguousIterator<TRangeIterator< T>>) { return ToAddress(Ranges::Begin(static_cast< T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto GetData() const requires (CContiguousIterator<TRangeIterator<const T>>) { return ToAddress(Ranges::Begin(static_cast<const T&>(*this))); }
/** @return The reverse iterator to the first or end element. */
NODISCARD FORCEINLINE constexpr auto RBegin() requires (CBidirectionalRange< T> && CCommonRange< T>) { return MakeReverseIterator(Range::End (static_cast< T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto REnd() requires (CBidirectionalRange< T> && CCommonRange< T>) { return MakeReverseIterator(Range::Begin(static_cast< T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto RBegin() const requires (CBidirectionalRange<const T> && CCommonRange<const T>) { return MakeReverseIterator(Range::End (static_cast<const T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto REnd() const requires (CBidirectionalRange<const T> && CCommonRange<const T>) { return MakeReverseIterator(Range::Begin(static_cast<const T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto RBegin() requires (CBidirectionalRange< T> && CCommonRange< T>) { return MakeReverseIterator(Ranges::End (static_cast< T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto REnd() requires (CBidirectionalRange< T> && CCommonRange< T>) { return MakeReverseIterator(Ranges::Begin(static_cast< T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto RBegin() const requires (CBidirectionalRange<const T> && CCommonRange<const T>) { return MakeReverseIterator(Ranges::End (static_cast<const T&>(*this))); }
NODISCARD FORCEINLINE constexpr auto REnd() const requires (CBidirectionalRange<const T> && CCommonRange<const T>) { return MakeReverseIterator(Ranges::Begin(static_cast<const T&>(*this))); }
/** @return The number of elements in the container. */
NODISCARD FORCEINLINE constexpr size_t Num() requires (CForwardRange< T> && CSizedSentinelFor<TRangeSentinel< T>, TRangeIterator< T>>) { T& Derived = static_cast< T&>(*this); return Range::End(Derived) - Range::Begin(Derived); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CForwardRange<const T> && CSizedSentinelFor<TRangeSentinel<const T>, TRangeIterator<const T>>) { const T& Derived = static_cast<const T&>(*this); return Range::End(Derived) - Range::Begin(Derived); }
NODISCARD FORCEINLINE constexpr size_t Num() requires (CForwardRange< T> && CSizedSentinelFor<TRangeSentinel< T>, TRangeIterator< T>>) { T& Derived = static_cast< T&>(*this); return Ranges::End(Derived) - Ranges::Begin(Derived); }
NODISCARD FORCEINLINE constexpr size_t Num() const requires (CForwardRange<const T> && CSizedSentinelFor<TRangeSentinel<const T>, TRangeIterator<const T>>) { const T& Derived = static_cast<const T&>(*this); return Ranges::End(Derived) - Ranges::Begin(Derived); }
/** @return true if the container is empty, false otherwise. */
NODISCARD FORCEINLINE constexpr bool IsEmpty() requires (CSizedRange< T> || CForwardRange< T>) { T& Derived = static_cast< T&>(*this); if constexpr (CSizedRange< T>) return Range::Num(Derived) == 0; else return Range::Begin(Derived) == Range::End(Derived); }
NODISCARD FORCEINLINE constexpr bool IsEmpty() const requires (CSizedRange<const T> || CForwardRange<const T>) { const T& Derived = static_cast<const T&>(*this); if constexpr (CSizedRange<const T>) return Range::Num(Derived) == 0; else return Range::Begin(Derived) == Range::End(Derived); }
NODISCARD FORCEINLINE constexpr bool IsEmpty() requires (CSizedRange< T> || CForwardRange< T>) { T& Derived = static_cast< T&>(*this); if constexpr (CSizedRange< T>) return Ranges::Num(Derived) == 0; else return Ranges::Begin(Derived) == Ranges::End(Derived); }
NODISCARD FORCEINLINE constexpr bool IsEmpty() const requires (CSizedRange<const T> || CForwardRange<const T>) { const T& Derived = static_cast<const T&>(*this); if constexpr (CSizedRange<const T>) return Ranges::Num(Derived) == 0; else return Ranges::Begin(Derived) == Ranges::End(Derived); }
/** @return true if the container is empty, false otherwise. */
NODISCARD FORCEINLINE constexpr explicit operator bool() requires (requires { Range::IsEmpty(DeclVal< T&>()); }) { return !Range::IsEmpty(static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr explicit operator bool() const requires (requires { Range::IsEmpty(DeclVal<const T&>()); }) { return !Range::IsEmpty(static_cast<const T&>(*this)); }
NODISCARD FORCEINLINE constexpr explicit operator bool() requires (requires { Ranges::IsEmpty(DeclVal< T&>()); }) { return !Ranges::IsEmpty(static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr explicit operator bool() const requires (requires { Ranges::IsEmpty(DeclVal<const T&>()); }) { return !Ranges::IsEmpty(static_cast<const T&>(*this)); }
/** @return The reference to the requested element. */
NODISCARD FORCEINLINE constexpr decltype(auto) operator[](size_t Index) requires (CRandomAccessRange< T>) { return Range::Begin(static_cast< T&>(*this))[Index]; }
NODISCARD FORCEINLINE constexpr decltype(auto) operator[](size_t Index) const requires (CRandomAccessRange<const T>) { return Range::Begin(static_cast<const T&>(*this))[Index]; }
NODISCARD FORCEINLINE constexpr decltype(auto) operator[](size_t Index) requires (CRandomAccessRange< T>) { return Ranges::Begin(static_cast< T&>(*this))[Index]; }
NODISCARD FORCEINLINE constexpr decltype(auto) operator[](size_t Index) const requires (CRandomAccessRange<const T>) { return Ranges::Begin(static_cast<const T&>(*this))[Index]; }
/** @return The reference to the first or last element. */
NODISCARD FORCEINLINE constexpr decltype(auto) Front() requires (CForwardRange< T>) { return *Range::Begin(static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr decltype(auto) Front() const requires (CForwardRange<const T>) { return *Range::Begin(static_cast<const T&>(*this)); }
NODISCARD FORCEINLINE constexpr decltype(auto) Back() requires (CBidirectionalRange< T> && CCommonRange< T>) { return *Range::RBegin(static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr decltype(auto) Back() const requires (CBidirectionalRange<const T> && CCommonRange<const T>) { return *Range::RBegin(static_cast<const T&>(*this)); }
NODISCARD FORCEINLINE constexpr decltype(auto) Front() requires (CForwardRange< T>) { return *Ranges::Begin(static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr decltype(auto) Front() const requires (CForwardRange<const T>) { return *Ranges::Begin(static_cast<const T&>(*this)); }
NODISCARD FORCEINLINE constexpr decltype(auto) Back() requires (CBidirectionalRange< T> && CCommonRange< T>) { return *Ranges::RBegin(static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr decltype(auto) Back() const requires (CBidirectionalRange<const T> && CCommonRange<const T>) { return *Ranges::RBegin(static_cast<const T&>(*this)); }
// ~Begin ENABLE_RANGE_BASED_FOR_LOOP_SUPPORT.
NODISCARD FORCEINLINE constexpr auto begin() requires (CRange< T>) { return Range::Begin(static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr auto end() requires (CRange< T>) { return Range::End (static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr auto begin() const requires (CRange<const T>) { return Range::Begin(static_cast<const T&>(*this)); }
NODISCARD FORCEINLINE constexpr auto end() const requires (CRange<const T>) { return Range::End (static_cast<const T&>(*this)); }
NODISCARD FORCEINLINE constexpr auto begin() requires (CRange< T>) { return Ranges::Begin(static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr auto end() requires (CRange< T>) { return Ranges::End (static_cast< T&>(*this)); }
NODISCARD FORCEINLINE constexpr auto begin() const requires (CRange<const T>) { return Ranges::Begin(static_cast<const T&>(*this)); }
NODISCARD FORCEINLINE constexpr auto end() const requires (CRange<const T>) { return Ranges::End (static_cast<const T&>(*this)); }
// ~End ENABLE_RANGE_BASED_FOR_LOOP_SUPPORT.
@ -75,14 +75,14 @@ private:
friend T;
};
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
/**
* A concept specifies that a range is a view, that is, it has constant time copy, move and assignment.
* Specify, a view can be movable only but not copyable, or it can be both movable and copyable.
*/
template <typename V>
concept CView = CRange<V> && CMovable<V> && CDerivedFrom<V, Range::IBasicViewInterface<TRemoveCVRef<V>>>;
concept CView = CRange<V> && CMovable<V> && CDerivedFrom<V, Ranges::IBasicViewInterface<TRemoveCVRef<V>>>;
NAMESPACE_PRIVATE_BEGIN
@ -91,7 +91,7 @@ template <typename T> struct TIsInitializerList<initializer_list<T>> : FTrue {
NAMESPACE_PRIVATE_END
/** A concept specifies that a viewable range that can be converted into a view through Range::All. */
/** A concept specifies that a viewable range that can be converted into a view through Ranges::All. */
template <typename R>
concept CViewableRange = CRange<R>
&& ((CView<TRemoveCVRef<R>> && CConstructibleFrom<TRemoveCVRef<R>, R>)
@ -104,7 +104,7 @@ concept CSimpleView = CView<V> && CRange<const V>
&& CSameAs<TRangeIterator<V>, TRangeIterator<const V>>
&& CSameAs<TRangeSentinel<V>, TRangeSentinel<const V>>;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** A simple view that combines an iterator-sentinel pair into a view. */
template <CInputOrOutputIterator I, CSentinelFor<I> S = I>
@ -137,12 +137,12 @@ private:
template <CInputOrOutputIterator I, CSentinelFor<I> S>
TRangeView(I, S) -> TRangeView<I, S>;
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
template <typename I, typename S>
constexpr bool bEnableBorrowedRange<Range::TRangeView<I, S>> = true;
constexpr bool bEnableBorrowedRange<Ranges::TRangeView<I, S>> = true;
NAMESPACE_BEGIN(Range)
NAMESPACE_BEGIN(Ranges)
/** Creates A simple view that combines an iterator-sentinel pair. */
template <CInputOrOutputIterator I, CSentinelFor<I> S = I>
@ -151,7 +151,7 @@ NODISCARD FORCEINLINE constexpr TRangeView<I, S> View(I First, S Last)
return TRangeView<I, S>(MoveTemp(First), Last);
}
NAMESPACE_END(Range)
NAMESPACE_END(Ranges)
NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)

10
Redcraft.Utility/Source/Public/Strings/Conversion.h.inl
View File

@ -900,7 +900,7 @@ struct TStringObjectFormatter
}
// Format the container value by format string.
else if constexpr (requires { Range::Begin(Object); Range::End(Object); })
else if constexpr (requires { Ranges::Begin(Object); Ranges::End(Object); })
{
auto FillAndAlign = ParseFillAndAlign();
@ -951,7 +951,7 @@ struct TStringObjectFormatter
return false;
}
if (Range::Begin(Object) == Range::End(Object))
if (Ranges::Begin(Object) == Ranges::End(Object))
{
Result += Begin;
Result += End;
@ -966,7 +966,7 @@ struct TStringObjectFormatter
struct { TStringView<T> Fmt; } ElementParam = { Subfmt };
// It is assumed that if the first element is successfully formatted, all elements will succeed.
bool bIsSuccessful = TStringObjectFormatter::Do(Buffer, *Range::Begin(Object), ElementParam);
bool bIsSuccessful = TStringObjectFormatter::Do(Buffer, *Ranges::Begin(Object), ElementParam);
if (!bIsSuccessful)
{
@ -977,9 +977,9 @@ struct TStringObjectFormatter
Result += Begin;
Result += Buffer;
auto Sentinel = Range::End(Object);
auto Sentinel = Ranges::End(Object);
for (auto Iter = ++Range::Begin(Object); Iter != Sentinel; ++Iter)
for (auto Iter = ++Ranges::Begin(Object); Iter != Sentinel; ++Iter)
{
Result += Separator;

22
Redcraft.Utility/Source/Public/Strings/String.h
View File

@ -5,7 +5,7 @@
#include "Templates/Utility.h"
#include "Templates/TypeHash.h"
#include "Templates/Optional.h"
#include "Memory/Allocator.h"
#include "Memory/Allocators.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Iterators/Utility.h"
@ -93,7 +93,7 @@ public:
/** Constructs the string with the contents of the range. */
template <CInputRange R> requires (!CSameAs<TRemoveCVRef<R>, TString>
&& !CSameAs<TRemoveCVRef<R>, TStringView<FElementType>> && CConstructibleFrom<FElementType, TRangeReference<R>>)
FORCEINLINE explicit TString(R&& Range) : TString(Range::Begin(Range), Range::End(Range)) { }
FORCEINLINE explicit TString(R&& Range) : TString(Ranges::Begin(Range), Ranges::End(Range)) { }
/** Copy constructor. Constructs the string with the copy of the contents of 'InValue'. */
FORCEINLINE TString(const TString&) = default;
@ -102,7 +102,7 @@ public:
FORCEINLINE TString(TString&&) = default;
/** Constructs the string with the contents of the initializer list. */
FORCEINLINE TString(initializer_list<FElementType> IL) : TString(Range::Begin(IL), Range::End(IL)) { }
FORCEINLINE TString(initializer_list<FElementType> IL) : TString(Ranges::Begin(IL), Ranges::End(IL)) { }
/** Copy assignment operator. Replaces the contents with a copy of the contents of 'InValue'. */
FORCEINLINE TString& operator=(const TString&) = default;
@ -249,7 +249,7 @@ public:
void StableErase(...) = delete;
/** Appends 'Count' copies of the 'InValue' to the end of the string. */
TString& Append(size_t Count, FElementType InChar) { return Append(Range::Repeat(InChar, Count)); }
TString& Append(size_t Count, FElementType InChar) { return Append(Ranges::Repeat(InChar, Count)); }
/** Appends the contents of the range ['InPtr', 'InPtr' + 'Count') to the end of the string. */
FORCEINLINE TString& Append(const FElementType* InPtr, size_t Count) { return Append(TStringView<FElementType>(InPtr, Count)); }
@ -296,10 +296,10 @@ public:
/** Appends the contents of the range to the end of the string. */
template <CInputRange R> requires (CConstructibleFrom<FElementType, TRangeReference<R>>)
FORCEINLINE TString& Append(R&& Range) { return Append(Range::Begin(Range), Range::End(Range)); }
FORCEINLINE TString& Append(R&& Range) { return Append(Ranges::Begin(Range), Ranges::End(Range)); }
/** Appends the contents of the initializer list to the end of the string. */
FORCEINLINE TString& Append(initializer_list<FElementType> IL) { return Append(Range::Begin(IL), Range::End(IL)); }
FORCEINLINE TString& Append(initializer_list<FElementType> IL) { return Append(Ranges::Begin(IL), Ranges::End(IL)); }
/** Appends the given character value to the end of the string. */
FORCEINLINE TString& operator+=(FElementType InChar) { return Append(1, InChar); }
@ -470,7 +470,7 @@ public:
{
checkf(this->IsValidIterator(First) && this->IsValidIterator(Last) && First <= Last, TEXT("Read access violation. Please check IsValidIterator()."));
return Replace(First, Last, Range::Repeat(InChar, Count));
return Replace(First, Last, Ranges::Repeat(InChar, Count));
}
/** Replace the substring [Index, Index + CountToReplace) with the contents of the ['InPtr', 'InPtr' + 'Count'). */
@ -599,7 +599,7 @@ public:
{
checkf(this->IsValidIterator(First) && this->IsValidIterator(Last) && First <= Last, TEXT("Read access violation. Please check IsValidIterator()."));
return Replace(First, Last, Range::Begin(Range), Range::End(Range));
return Replace(First, Last, Ranges::Begin(Range), Ranges::End(Range));
}
/** Replace the substring [Index, Index + CountToReplace) with the contents of the initializer list. */
@ -615,7 +615,7 @@ public:
{
checkf(this->IsValidIterator(First) && this->IsValidIterator(Last) && First <= Last, TEXT("Read access violation. Please check IsValidIterator()."));
return Replace(First, Last, Range::Begin(IL), Range::End(IL));
return Replace(First, Last, Ranges::Begin(IL), Ranges::End(IL));
}
/** Obtains a string that is a view over the 'Count' characters of this string view starting at 'Offset'. */
@ -808,7 +808,7 @@ public:
do
{
const auto Result = Facet.in(State, BeginFrom, EndFrom, NextFrom, Range::Begin(Buffer), Range::End(Buffer), NextTo);
const auto Result = Facet.in(State, BeginFrom, EndFrom, NextFrom, Ranges::Begin(Buffer), Ranges::End(Buffer), NextTo);
if (BeginFrom == NextFrom) return false;
@ -856,7 +856,7 @@ public:
do
{
const auto Result = Facet.out(State, BeginFrom, EndFrom, NextFrom, Range::Begin(Buffer), Range::End(Buffer), NextTo);
const auto Result = Facet.out(State, BeginFrom, EndFrom, NextFrom, Ranges::Begin(Buffer), Ranges::End(Buffer), NextTo);
if (BeginFrom == NextFrom) return false;

2
Redcraft.Utility/Source/Public/Strings/StringView.h
View File

@ -5,7 +5,7 @@
#include "Templates/Utility.h"
#include "Templates/TypeHash.h"
#include "Templates/Noncopyable.h"
#include "Memory/Allocator.h"
#include "Memory/Allocators.h"
#include "Memory/MemoryOperator.h"
#include "Containers/ArrayView.h"
#include "Iterators/Utility.h"

2
Redcraft.Utility/Source/Public/Templates/Variant.h
View File

@ -479,7 +479,7 @@ struct TVariantVisitImpl
for (size_t Index = 0; Index < sizeof...(VariantTypes); ++Index)
{
Result *= VariantNums[Index];
Result += Range::Begin(Indices)[Index];
Result += Ranges::Begin(Indices)[Index];
}
return Result;