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

refactor(templates): enhance encapsulation by changing part of the struct to a class

Browse Source
This commit is contained in:
_Redstone_c_ 2022-11-15 19:28:43 +08:00
parent 226f5a34e9
commit af07b1a134
7 changed files with 104 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Redcraft.Utility/Source/Private/Testing/TemplatesTesting.cpp
View File

@ -784,10 +784,10 @@ void TestTuple()
{ {
int8 Flag; int8 Flag;
FTracker(int8 InFlag) : Flag(InFlag) { } FTracker(int8 InFlag) : Flag(InFlag) { }
FTracker(const FTracker& InValue) { Flag = InValue.Flag - 1; always_check(!Flag); } FTracker(const FTracker& InValue) { Flag = InValue.Flag - 1; always_check(!Flag); }
FTracker(FTracker&& InValue) { Flag = InValue.Flag + 1; always_check(!Flag); } FTracker(FTracker&& InValue) { Flag = InValue.Flag + 1; always_check(!Flag); }
FTracker& operator=(const FTracker& InValue) { Flag = InValue.Flag - 1; always_check(!Flag); return *this; } FTracker& operator=(const FTracker& InValue) { Flag = InValue.Flag - 1; always_check(!Flag); return *this; }
FTracker& operator=(FTracker&& InValue) { Flag = InValue.Flag + 1; always_check(!Flag); return *this; } FTracker& operator=(FTracker&& InValue) { Flag = InValue.Flag + 1; always_check(!Flag); return *this; }
}; };
{ {

4
Redcraft.Utility/Source/Public/Templates/Any.h
View File

@ -72,8 +72,10 @@ static_assert(CAnyCustomStorage<FAnyDefaultStorage>);
// You can add custom storage area through CustomStorage, such as TFunction. // You can add custom storage area through CustomStorage, such as TFunction.
// It is not recommended to use this, FAny is recommended. // It is not recommended to use this, FAny is recommended.
template <CAnyCustomStorage CustomStorage = FAnyDefaultStorage> template <CAnyCustomStorage CustomStorage = FAnyDefaultStorage>
struct TAny class TAny
{ {
public:
inline static constexpr size_t InlineSize = CustomStorage::InlineSize; inline static constexpr size_t InlineSize = CustomStorage::InlineSize;
inline static constexpr size_t InlineAlignment = CustomStorage::InlineAlignment; inline static constexpr size_t InlineAlignment = CustomStorage::InlineAlignment;

160
Redcraft.Utility/Source/Public/Templates/Function.h
View File

@ -13,14 +13,14 @@ NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft) NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility) NAMESPACE_MODULE_BEGIN(Utility)
template <typename F> requires CFunction<F> template <CFunction F>
struct TFunctionRef; class TFunctionRef;
template <typename F> requires CFunction<F> template <CFunction F>
struct TFunction; class TFunction;
template <typename F> requires CFunction<F> template <CFunction F>
struct TUniqueFunction; class TUniqueFunction;
NAMESPACE_PRIVATE_BEGIN NAMESPACE_PRIVATE_BEGIN
@ -80,38 +80,10 @@ template <typename Ret, typename... Types> struct TFunctionInfo<Ret(Types...) co
template <typename Ret, typename... Types> struct TFunctionInfo<Ret(Types...) const& > { using Fn = Ret(Types...); using CVRef = const int&; }; template <typename Ret, typename... Types> struct TFunctionInfo<Ret(Types...) const& > { using Fn = Ret(Types...); using CVRef = const int&; };
template <typename Ret, typename... Types> struct TFunctionInfo<Ret(Types...) const&&> { using Fn = Ret(Types...); using CVRef = const int&&; }; template <typename Ret, typename... Types> struct TFunctionInfo<Ret(Types...) const&&> { using Fn = Ret(Types...); using CVRef = const int&&; };
template <typename CallableType> template <typename F, typename CVRef, bool bIsRef> class TFunctionImpl;
struct alignas(16) FFunctionStorage
{
//~ Begin CAnyCustomStorage Interface
inline static constexpr size_t InlineSize = 64 - sizeof(uintptr) - sizeof(CallableType);
inline static constexpr size_t InlineAlignment = 16;
constexpr void* InlineAllocation() { return &InlineAllocationImpl; }
constexpr const void* InlineAllocation() const { return &InlineAllocationImpl; }
constexpr void*& HeapAllocation() { return HeapAllocationImpl; }
constexpr void* HeapAllocation() const { return HeapAllocationImpl; }
constexpr uintptr& TypeInfo() { return TypeInfoImpl; }
constexpr uintptr TypeInfo() const { return TypeInfoImpl; }
constexpr void CopyCustom(const FFunctionStorage& InValue) { Callable = InValue.Callable; }
constexpr void MoveCustom( FFunctionStorage&& InValue) { Callable = InValue.Callable; }
//~ End CAnyCustomStorage Interface
union
{
uint8 InlineAllocationImpl[InlineSize];
void* HeapAllocationImpl;
};
uintptr TypeInfoImpl;
CallableType Callable;
};
template <typename F, typename CVRef, bool bIsRef> struct TFunctionImpl;
template <typename Ret, typename... Types, typename CVRef, bool bIsRef> template <typename Ret, typename... Types, typename CVRef, bool bIsRef>
struct TFunctionImpl<Ret(Types...), CVRef, bIsRef> class TFunctionImpl<Ret(Types...), CVRef, bIsRef>
{ {
public: public:
@ -175,6 +147,34 @@ private:
StoragePtrType Ptr; StoragePtrType Ptr;
CallableType Callable; CallableType Callable;
}; };
template <typename CallableType>
struct alignas(16) FFunctionStorage
{
//~ Begin CAnyCustomStorage Interface
inline static constexpr size_t InlineSize = 64 - sizeof(uintptr) - sizeof(CallableType);
inline static constexpr size_t InlineAlignment = 16;
constexpr void* InlineAllocation() { return &InlineAllocationImpl; }
constexpr const void* InlineAllocation() const { return &InlineAllocationImpl; }
constexpr void*& HeapAllocation() { return HeapAllocationImpl; }
constexpr void* HeapAllocation() const { return HeapAllocationImpl; }
constexpr uintptr& TypeInfo() { return TypeInfoImpl; }
constexpr uintptr TypeInfo() const { return TypeInfoImpl; }
constexpr void CopyCustom(const FFunctionStorage& InValue) { Callable = InValue.Callable; }
constexpr void MoveCustom( FFunctionStorage&& InValue) { Callable = InValue.Callable; }
//~ End CAnyCustomStorage Interface
union
{
uint8 InlineAllocationImpl[InlineSize];
void* HeapAllocationImpl;
};
uintptr TypeInfoImpl;
CallableType Callable;
};
using FunctionStorage = TAny<FFunctionStorage<CallableType>>; using FunctionStorage = TAny<FFunctionStorage<CallableType>>;
using StorageType = TConditional<bIsRef, FunctionRefStorage, FunctionStorage>; using StorageType = TConditional<bIsRef, FunctionRefStorage, FunctionStorage>;
@ -207,7 +207,7 @@ private:
else return GetCallableImpl()(&Storage, Forward<Types>(Args)...); else return GetCallableImpl()(&Storage, Forward<Types>(Args)...);
} }
protected: protected: // These functions should not be used by user-defined class.
template <typename DecayedType, typename... ArgTypes> template <typename DecayedType, typename... ArgTypes>
FORCEINLINE void EmplaceImpl(ArgTypes&&... Args) FORCEINLINE void EmplaceImpl(ArgTypes&&... Args)
@ -257,8 +257,8 @@ protected:
NAMESPACE_PRIVATE_END NAMESPACE_PRIVATE_END
template <typename F> requires CFunction<F> template <CFunction F>
struct TFunctionRef class TFunctionRef
: public NAMESPACE_PRIVATE::TFunctionImpl< : public NAMESPACE_PRIVATE::TFunctionImpl<
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn,
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef,
@ -266,7 +266,7 @@ struct TFunctionRef
{ {
private: private:
using Super = NAMESPACE_PRIVATE::TFunctionImpl< using Impl = NAMESPACE_PRIVATE::TFunctionImpl<
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn,
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef,
true>; true>;
@ -287,7 +287,7 @@ public:
{ {
using DecayedType = TDecay<T>; using DecayedType = TDecay<T>;
checkf(NAMESPACE_PRIVATE::FunctionIsBound(InValue), TEXT("Cannot bind a null/unbound callable to a TFunctionRef")); checkf(NAMESPACE_PRIVATE::FunctionIsBound(InValue), TEXT("Cannot bind a null/unbound callable to a TFunctionRef"));
Super::template EmplaceImpl<DecayedType>(Forward<T>(InValue)); Impl::template EmplaceImpl<DecayedType>(Forward<T>(InValue));
} }
template <typename T> template <typename T>
@ -295,8 +295,8 @@ public:
}; };
template <typename F> requires CFunction<F> template <CFunction F>
struct TFunction class TFunction
: public NAMESPACE_PRIVATE::TFunctionImpl< : public NAMESPACE_PRIVATE::TFunctionImpl<
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn,
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef,
@ -304,28 +304,28 @@ struct TFunction
{ {
private: private:
using Super = NAMESPACE_PRIVATE::TFunctionImpl< using Impl = NAMESPACE_PRIVATE::TFunctionImpl<
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn,
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef,
false>; false>;
public: public:
constexpr TFunction(nullptr_t = nullptr) { Super::ResetImpl(); } constexpr TFunction(nullptr_t = nullptr) { Impl::ResetImpl(); }
FORCEINLINE TFunction(const TFunction& InValue) = default; FORCEINLINE TFunction(const TFunction& InValue) = default;
FORCEINLINE TFunction(TFunction&& InValue) : Super(MoveTemp(InValue)) { InValue.ResetImpl(); } FORCEINLINE TFunction(TFunction&& InValue) : Impl(MoveTemp(InValue)) { InValue.ResetImpl(); }
FORCEINLINE TFunction& operator=(const TFunction& InValue) FORCEINLINE TFunction& operator=(const TFunction& InValue)
{ {
Super::AssignImpl(InValue); Impl::AssignImpl(InValue);
return *this; return *this;
} }
FORCEINLINE TFunction& operator=(TFunction&& InValue) FORCEINLINE TFunction& operator=(TFunction&& InValue)
{ {
if (&InValue == this) return *this; if (&InValue == this) return *this;
Super::AssignImpl(MoveTemp(InValue)); Impl::AssignImpl(MoveTemp(InValue));
return *this; return *this;
} }
@ -336,8 +336,8 @@ public:
FORCEINLINE TFunction(T&& InValue) FORCEINLINE TFunction(T&& InValue)
{ {
using DecayedType = TDecay<T>; using DecayedType = TDecay<T>;
if (!NAMESPACE_PRIVATE::FunctionIsBound(InValue)) Super::ResetImpl(); if (!NAMESPACE_PRIVATE::FunctionIsBound(InValue)) Impl::ResetImpl();
else Super::template EmplaceImpl<DecayedType>(Forward<T>(InValue)); else Impl::template EmplaceImpl<DecayedType>(Forward<T>(InValue));
} }
template <typename T, typename... ArgTypes> requires NAMESPACE_PRIVATE::TIsInvocableSignature<F, TDecay<T>>::Value template <typename T, typename... ArgTypes> requires NAMESPACE_PRIVATE::TIsInvocableSignature<F, TDecay<T>>::Value
@ -345,10 +345,10 @@ public:
FORCEINLINE TFunction(TInPlaceType<T>, ArgTypes&&... Args) FORCEINLINE TFunction(TInPlaceType<T>, ArgTypes&&... Args)
{ {
using DecayedType = TDecay<T>; using DecayedType = TDecay<T>;
Super::template EmplaceImpl<DecayedType>(Forward<ArgTypes>(Args)...); Impl::template EmplaceImpl<DecayedType>(Forward<ArgTypes>(Args)...);
} }
constexpr TFunction& operator=(nullptr_t) { Super::ResetImpl(); return *this; } constexpr TFunction& operator=(nullptr_t) { Impl::ResetImpl(); return *this; }
template <typename T> requires NAMESPACE_PRIVATE::TIsInvocableSignature<F, TDecay<T>>::Value template <typename T> requires NAMESPACE_PRIVATE::TIsInvocableSignature<F, TDecay<T>>::Value
&& (!CTFunctionRef<TDecay<T>>) && (!CTFunction<TDecay<T>>) && (!CTUniqueFunction<TDecay<T>>) && (!CTFunctionRef<TDecay<T>>) && (!CTFunction<TDecay<T>>) && (!CTUniqueFunction<TDecay<T>>)
@ -357,8 +357,8 @@ public:
{ {
using DecayedType = TDecay<T>; using DecayedType = TDecay<T>;
if (!NAMESPACE_PRIVATE::FunctionIsBound(InValue)) Super::ResetImpl(); if (!NAMESPACE_PRIVATE::FunctionIsBound(InValue)) Impl::ResetImpl();
else Super::template EmplaceImpl<DecayedType>(Forward<T>(InValue)); else Impl::template EmplaceImpl<DecayedType>(Forward<T>(InValue));
return *this; return *this;
} }
@ -368,62 +368,62 @@ public:
FORCEINLINE TDecay<T>& Emplace(ArgTypes&&... Args) FORCEINLINE TDecay<T>& Emplace(ArgTypes&&... Args)
{ {
using DecayedType = TDecay<T>; using DecayedType = TDecay<T>;
Super::template EmplaceImpl<DecayedType>(Forward<ArgTypes>(Args)...); Impl::template EmplaceImpl<DecayedType>(Forward<ArgTypes>(Args)...);
return Super::template Target<DecayedType>(); return Impl::template Target<DecayedType>();
} }
constexpr void Reset() { Super::ResetImpl(); } constexpr void Reset() { Impl::ResetImpl(); }
}; };
template <typename F> requires CFunction<F> template <CFunction F>
struct TUniqueFunction class TUniqueFunction
: public NAMESPACE_PRIVATE::TFunctionImpl< : public NAMESPACE_PRIVATE::TFunctionImpl<
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn,
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef,
false> false>
{ {
private: private:
using Super = NAMESPACE_PRIVATE::TFunctionImpl< using Impl = NAMESPACE_PRIVATE::TFunctionImpl<
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::Fn,
typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef, typename NAMESPACE_PRIVATE::TFunctionInfo<F>::CVRef,
false>; false>;
public: public:
constexpr TUniqueFunction(nullptr_t = nullptr) { Super::ResetImpl(); } constexpr TUniqueFunction(nullptr_t = nullptr) { Impl::ResetImpl(); }
FORCEINLINE TUniqueFunction(const TUniqueFunction& InValue) = delete; FORCEINLINE TUniqueFunction(const TUniqueFunction& InValue) = delete;
TUniqueFunction(TUniqueFunction&& InValue) : Super(MoveTemp(InValue)) { InValue.ResetImpl(); } TUniqueFunction(TUniqueFunction&& InValue) : Impl(MoveTemp(InValue)) { InValue.ResetImpl(); }
FORCEINLINE TUniqueFunction& operator=(const TUniqueFunction& InValue) = delete; FORCEINLINE TUniqueFunction& operator=(const TUniqueFunction& InValue) = delete;
FORCEINLINE TUniqueFunction& operator=(TUniqueFunction&& InValue) FORCEINLINE TUniqueFunction& operator=(TUniqueFunction&& InValue)
{ {
if (&InValue == this) return *this; if (&InValue == this) return *this;
Super::AssignImpl(MoveTemp(InValue)); Impl::AssignImpl(MoveTemp(InValue));
return *this; return *this;
} }
FORCEINLINE TUniqueFunction(const TFunction<F>& InValue) FORCEINLINE TUniqueFunction(const TFunction<F>& InValue)
: Super(*reinterpret_cast<const TUniqueFunction*>(&InValue)) : Impl(*reinterpret_cast<const TUniqueFunction*>(&InValue))
{ } { }
FORCEINLINE TUniqueFunction(TFunction<F>&& InValue) FORCEINLINE TUniqueFunction(TFunction<F>&& InValue)
: Super(MoveTemp(*reinterpret_cast<const TUniqueFunction*>(&InValue))) : Impl(MoveTemp(*reinterpret_cast<const TUniqueFunction*>(&InValue)))
{ {
InValue.Reset(); InValue.Reset();
} }
FORCEINLINE TUniqueFunction& operator=(const TFunction<F>& InValue) FORCEINLINE TUniqueFunction& operator=(const TFunction<F>& InValue)
{ {
Super::AssignImpl(*reinterpret_cast<const TUniqueFunction*>(&InValue)); Impl::AssignImpl(*reinterpret_cast<const TUniqueFunction*>(&InValue));
return *this; return *this;
} }
FORCEINLINE TUniqueFunction& operator=(TFunction<F>&& InValue) FORCEINLINE TUniqueFunction& operator=(TFunction<F>&& InValue)
{ {
Super::AssignImpl(MoveTemp(*reinterpret_cast<TUniqueFunction*>(&InValue))); Impl::AssignImpl(MoveTemp(*reinterpret_cast<TUniqueFunction*>(&InValue)));
return *this; return *this;
} }
@ -434,8 +434,8 @@ public:
FORCEINLINE TUniqueFunction(T&& InValue) FORCEINLINE TUniqueFunction(T&& InValue)
{ {
using DecayedType = TDecay<T>; using DecayedType = TDecay<T>;
if (!NAMESPACE_PRIVATE::FunctionIsBound(InValue)) Super::ResetImpl(); if (!NAMESPACE_PRIVATE::FunctionIsBound(InValue)) Impl::ResetImpl();
else Super::template EmplaceImpl<DecayedType>(Forward<T>(InValue)); else Impl::template EmplaceImpl<DecayedType>(Forward<T>(InValue));
} }
template <typename T, typename... ArgTypes> requires NAMESPACE_PRIVATE::TIsInvocableSignature<F, TDecay<T>>::Value template <typename T, typename... ArgTypes> requires NAMESPACE_PRIVATE::TIsInvocableSignature<F, TDecay<T>>::Value
@ -443,10 +443,10 @@ public:
FORCEINLINE TUniqueFunction(TInPlaceType<T>, ArgTypes&&... Args) FORCEINLINE TUniqueFunction(TInPlaceType<T>, ArgTypes&&... Args)
{ {
using DecayedType = TDecay<T>; using DecayedType = TDecay<T>;
Super::template EmplaceImpl<DecayedType>(Forward<ArgTypes>(Args)...); Impl::template EmplaceImpl<DecayedType>(Forward<ArgTypes>(Args)...);
} }
constexpr TUniqueFunction& operator=(nullptr_t) { Super::ResetImpl(); return *this; } constexpr TUniqueFunction& operator=(nullptr_t) { Impl::ResetImpl(); return *this; }
template <typename T> requires NAMESPACE_PRIVATE::TIsInvocableSignature<F, TDecay<T>>::Value template <typename T> requires NAMESPACE_PRIVATE::TIsInvocableSignature<F, TDecay<T>>::Value
&& (!CTFunctionRef<TDecay<T>>) && (!CTFunction<TDecay<T>>) && (!CTUniqueFunction<TDecay<T>>) && (!CTFunctionRef<TDecay<T>>) && (!CTFunction<TDecay<T>>) && (!CTUniqueFunction<TDecay<T>>)
@ -455,8 +455,8 @@ public:
{ {
using DecayedType = TDecay<T>; using DecayedType = TDecay<T>;
if (!NAMESPACE_PRIVATE::FunctionIsBound(InValue)) Super::ResetImpl(); if (!NAMESPACE_PRIVATE::FunctionIsBound(InValue)) Impl::ResetImpl();
else Super::template EmplaceImpl<DecayedType>(Forward<T>(InValue)); else Impl::template EmplaceImpl<DecayedType>(Forward<T>(InValue));
return *this; return *this;
} }
@ -466,27 +466,27 @@ public:
FORCEINLINE TDecay<T>& Emplace(ArgTypes&&... Args) FORCEINLINE TDecay<T>& Emplace(ArgTypes&&... Args)
{ {
using DecayedType = TDecay<T>; using DecayedType = TDecay<T>;
Super::template EmplaceImpl<DecayedType>(Forward<ArgTypes>(Args)...); Impl::template EmplaceImpl<DecayedType>(Forward<ArgTypes>(Args)...);
return Super::template Target<DecayedType>(); return Impl::template Target<DecayedType>();
} }
constexpr void Reset() { Super::ResetImpl(); } constexpr void Reset() { Impl::ResetImpl(); }
}; };
template <typename F> template <CFunction F>
constexpr bool operator==(const TFunctionRef<F>& LHS, nullptr_t) constexpr bool operator==(const TFunctionRef<F>& LHS, nullptr_t)
{ {
return !LHS; return !LHS;
} }
template <typename F> template <CFunction F>
constexpr bool operator==(const TFunction<F>& LHS, nullptr_t) constexpr bool operator==(const TFunction<F>& LHS, nullptr_t)
{ {
return !LHS; return !LHS;
} }
template <typename F> template <CFunction F>
constexpr bool operator==(const TUniqueFunction<F>& LHS, nullptr_t) constexpr bool operator==(const TUniqueFunction<F>& LHS, nullptr_t)
{ {
return !LHS; return !LHS;

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

@ -12,7 +12,7 @@ NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility) NAMESPACE_MODULE_BEGIN(Utility)
template <typename OptionalType> requires CDestructible<OptionalType> template <typename OptionalType> requires CDestructible<OptionalType>
struct TOptional class TOptional
{ {
private: private:

10
Redcraft.Utility/Source/Public/Templates/ReferenceWrapper.h
View File

@ -11,7 +11,7 @@ NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility) NAMESPACE_MODULE_BEGIN(Utility)
template <typename ReferencedType> requires (CObject<ReferencedType> || CFunction<ReferencedType>) template <typename ReferencedType> requires (CObject<ReferencedType> || CFunction<ReferencedType>)
struct TReferenceWrapper class TReferenceWrapper
{ {
public: public:
@ -61,11 +61,11 @@ private:
ReferencedType* Pointer; ReferencedType* Pointer;
template <typename T> requires (CObject<T> || CFunction<T>) friend struct TReferenceWrapper; template <typename T> requires (CObject<T> || CFunction<T>) friend class TReferenceWrapper;
// Optimize TOptional with these hacking // Optimize TOptional with these hacking
constexpr TReferenceWrapper(FInvalid) : Pointer(nullptr) { }; constexpr TReferenceWrapper(FInvalid) : Pointer(nullptr) { };
template <typename T> requires CDestructible<T> friend struct TOptional; template <typename T> requires CDestructible<T> friend class TOptional;
}; };
@ -121,7 +121,7 @@ template <typename T>
using TUnwrapRefDecay = typename NAMESPACE_PRIVATE::TUnwrapRefDecayImpl<T>::Type; using TUnwrapRefDecay = typename NAMESPACE_PRIVATE::TUnwrapRefDecayImpl<T>::Type;
template <typename ReferencedType> template <typename ReferencedType>
struct TOptional<TReferenceWrapper<ReferencedType>> class TOptional<TReferenceWrapper<ReferencedType>>
{ {
private: private:
@ -235,7 +235,7 @@ public:
private: private:
TReferenceWrapper<ReferencedType> Reference; TReferenceWrapper<ReferencedType> Reference;
template <typename T> requires CDestructible<T> friend struct TOptional; template <typename T> requires CDestructible<T> friend class TOptional;
}; };

14
Redcraft.Utility/Source/Public/Templates/Tuple.h
View File

@ -17,7 +17,7 @@ NAMESPACE_MODULE_BEGIN(Utility)
#define RS_TUPLE_ELEMENT_STATIC_ALIAS 1 #define RS_TUPLE_ELEMENT_STATIC_ALIAS 1
template <typename... Types> template <typename... Types>
struct TTuple; class TTuple;
NAMESPACE_PRIVATE_BEGIN NAMESPACE_PRIVATE_BEGIN
@ -209,10 +209,10 @@ constexpr TTuple<TUnwrapRefDecay<Types>...> MakeTupleImpl(Types&&... Args)
} }
template <typename Indices, typename... Types> template <typename Indices, typename... Types>
struct TTupleImpl; class TTupleImpl;
template <size_t... Indices, typename... Types> template <size_t... Indices, typename... Types>
struct TTupleImpl<TIndexSequence<Indices...>, Types...> : TTupleBasicElement<Types, Indices>... class TTupleImpl<TIndexSequence<Indices...>, Types...> : public TTupleBasicElement<Types, Indices>...
{ {
protected: protected:
@ -237,11 +237,13 @@ protected:
}; };
template <typename Indices, typename... Types> template <typename Indices, typename... Types>
struct TTupleHelper; class TTupleHelper;
template <size_t... Indices> template <size_t... Indices>
struct TTupleHelper<TIndexSequence<Indices...>> class TTupleHelper<TIndexSequence<Indices...>>
{ {
public:
template <typename LHSTupleType, typename RHSTupleType> template <typename LHSTupleType, typename RHSTupleType>
static constexpr void Assign(LHSTupleType& LHS, RHSTupleType&& RHS) static constexpr void Assign(LHSTupleType& LHS, RHSTupleType&& RHS)
{ {
@ -299,7 +301,7 @@ template <size_t I, typename TupleType>
using TTupleElement = typename NAMESPACE_PRIVATE::TTupleElementImpl<I, TupleType>::Type; using TTupleElement = typename NAMESPACE_PRIVATE::TTupleElementImpl<I, TupleType>::Type;
template <typename... Types> template <typename... Types>
struct TTuple : NAMESPACE_PRIVATE::TTupleImpl<TIndexSequenceFor<Types...>, Types...> class TTuple : public NAMESPACE_PRIVATE::TTupleImpl<TIndexSequenceFor<Types...>, Types...>
{ {
private: private:

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

@ -14,7 +14,7 @@ NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility) NAMESPACE_MODULE_BEGIN(Utility)
template <typename... Types> requires (true && ... && CDestructible<Types>) template <typename... Types> requires (true && ... && CDestructible<Types>)
struct TVariant; class TVariant;
NAMESPACE_PRIVATE_BEGIN NAMESPACE_PRIVATE_BEGIN
@ -139,8 +139,10 @@ template <size_t I, typename VariantType>
using TVariantAlternative = typename NAMESPACE_PRIVATE::TVariantAlternativeImpl<I, VariantType>::Type; using TVariantAlternative = typename NAMESPACE_PRIVATE::TVariantAlternativeImpl<I, VariantType>::Type;
template <typename... Types> requires (true && ... && CDestructible<Types>) template <typename... Types> requires (true && ... && CDestructible<Types>)
struct TVariant class TVariant
{ {
public:
constexpr TVariant() : TypeIndex(0xFF) { }; constexpr TVariant() : TypeIndex(0xFF) { };
constexpr TVariant(FInvalid) : TVariant() { }; constexpr TVariant(FInvalid) : TVariant() { };