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
Download Patch File Download Diff File Expand all files Collapse all files

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)