feat(concept): add basic concepts and the corresponding testing

Redcraft.Utility/Source/Private/Testing/ConceptsTesting.cpp

@@ -0,0 +1,121 @@
+#include "Testing/ConceptsTesting.h"
+#include "Misc/AssertionMacros.h"
+#include "Concepts/Concepts.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+// Warning: The test here is not a complete test, it is only used to determine whether the environment supports the concepts
+
+NAMESPACE_UNNAMED_BEGIN
+
+int32 TestObject;
+void TestFunction() { }
+
+struct FTestStructA { };
+struct FTestStructB : FTestStructA { int32 Member; };
+struct FTestStructC { FTestStructC() { } };
+struct FTestStructD { FTestStructD(const FTestStructD&) { } };
+struct FTestStructE { virtual void Member() = 0; };
+struct FTestStructF { int32 MemberA; private: int32 MemberB; };
+struct FTestStructG { char MemberA; float MemberB; short MemberC; int MemberD; };
+struct FTestStructH final : FTestStructE { virtual void Member() override { } };
+struct FTestStructI { int32 MemberA; double MemberB; FTestStructI(int32 A, double B) { } FTestStructI& operator=(int32) { return *this; };  };
+struct FTestStructJ { int32 MemberA; double MemberB; FTestStructJ() { }; };
+struct FTestStructK { int32 MemberA; double MemberB; FTestStructK() = default; };
+struct FTestStructL { int32 MemberA; double MemberB; FTestStructL() = delete; };
+struct FTestStructM { int32 MemberA; double MemberB; FTestStructM(const FTestStructM&) { }; FTestStructM& operator=(const FTestStructM&) { return *this; }; };
+struct FTestStructN { int32 MemberA; double MemberB; FTestStructN(const FTestStructN&) = default; FTestStructN& operator=(const FTestStructN&) = default;  };
+struct FTestStructO { int32 MemberA; double MemberB; FTestStructO(const FTestStructO&) = delete; FTestStructO& operator=(const FTestStructO&) = delete;  };
+struct FTestStructP { int32 MemberA; double MemberB; FTestStructP(FTestStructP&&) { }; FTestStructP& operator=(FTestStructP&&) { return *this; }; };
+struct FTestStructQ { int32 MemberA; double MemberB; FTestStructQ(FTestStructQ&&) = default; FTestStructQ& operator=(FTestStructQ&&) = default; };
+struct FTestStructR { int32 MemberA; double MemberB; FTestStructR(FTestStructR&&) = delete; FTestStructR& operator=(FTestStructR&&) = delete; };
+struct FTestStructS { int32 MemberA; double MemberB; ~FTestStructS() { } };
+struct FTestStructT { int32 MemberA; double MemberB; ~FTestStructT() = default; };
+struct FTestStructU { int32 MemberA; double MemberB; ~FTestStructU() = delete; };
+struct FTestStructV { int32 MemberA; double MemberB; virtual ~FTestStructV() { }; };
+struct FTestStructW { int32 MemberA; double MemberB; operator FTestStructV() { return FTestStructV(); } };
+
+enum ETestEnum { };
+enum class ETestEnumClass { };
+enum class ETestEnumClass8 : uint8 { };
+enum class ETestEnumClass32 : uint32 { };
+enum class ETestEnumClass64 : uint64 { };
+
+union FTestUnion { };
+
+NAMESPACE_UNNAMED_END
+
+void TestConcepts()
+{
+	// Same.h
+
+	always_check(!(CSameAs<int32, int64>));
+	always_check((CSameAs<int32, int32>));
+
+	// Destructible.h
+
+	always_check(CDestructible<FTestStructS>);
+	always_check(CDestructible<FTestStructT>);
+	always_check(!CDestructible<FTestStructU>);
+
+	// Derived.h
+
+	always_check(!(CDerivedFrom<FTestStructH, FTestStructD>));
+	always_check((CDerivedFrom<FTestStructH, FTestStructE>));
+	always_check(!(CDerivedFrom<FTestStructE, FTestStructH>));
+
+	// Convertible.h
+
+	always_check((CConvertibleTo<int32, uint32>));
+	always_check(!(CConvertibleTo<FTestStructH*, FTestStructD*>));
+	always_check((CConvertibleTo<FTestStructH*, FTestStructE*>));
+	always_check(!(CConvertibleTo<FTestStructE*, FTestStructH*>));
+	always_check((CConvertibleTo<FTestStructW, FTestStructV>));
+
+	// Constructible.h
+
+	always_check((CConstructibleFrom<FTestStructJ>));
+	always_check((CConstructibleFrom<FTestStructK>));
+	always_check(!(CConstructibleFrom<FTestStructI, int32>));
+	always_check((CConstructibleFrom<FTestStructI, FTestStructI&>));
+	always_check((CConstructibleFrom<FTestStructI, int32, double>));
+
+	always_check(!CDefaultInitializable<FTestStructI>);
+	always_check(CDefaultInitializable<FTestStructJ>);
+	always_check(CDefaultInitializable<FTestStructK>);
+	always_check(!CDefaultInitializable<FTestStructL>);
+
+	always_check(CMoveConstructible<FTestStructP>);
+	always_check(CMoveConstructible<FTestStructQ>);
+	always_check(!CMoveConstructible<FTestStructR>);
+
+	always_check(CCopyConstructible<FTestStructM>);
+	always_check(CCopyConstructible<FTestStructN>);
+	always_check(!CCopyConstructible<FTestStructO>);
+
+	// BuiltinType.h
+
+	always_check(CIntegral<bool>);
+	always_check(CIntegral<int32>);
+	always_check(!CIntegral<float>);
+
+	always_check(CSignedIntegral<signed>);
+	always_check(!CSignedIntegral<unsigned>);
+
+	always_check(!CUnsignedIntegral<signed>);
+	always_check(CUnsignedIntegral<unsigned>);
+
+	always_check(!CNonBooleanIntegral<bool>);
+	always_check(CNonBooleanIntegral<int32>);
+	always_check(!CNonBooleanIntegral<float>);
+
+	always_check(!CFloatingPoint<int32>);
+	always_check(CFloatingPoint<float>);
+
+}
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END

Redcraft.Utility/Source/Private/Testing/TypeTraitsTesting.cpp

@@ -8,6 +8,8 @@ NAMESPACE_MODULE_BEGIN(Utility)
 
 // Warning: The test here is not a complete test, it is only used to determine whether the environment supports the traits
 
+NAMESPACE_UNNAMED_BEGIN
+
 int32 TestObject;
 void TestFunction() { }
 
@@ -43,6 +45,8 @@ enum class ETestEnumClass64 : uint64 { };
 
 union FTestUnion { };
 
+NAMESPACE_UNNAMED_END
+
 void TestTypeTraits()
 {
 	// HelperClasses.h

Redcraft.Utility/Source/Public/Concepts/BuiltinType.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "TypeTraits/TypeTraits.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T> concept CIntegral           = TIsIntegral<T>::Value;
+template <typename T> concept CSignedIntegral     = CIntegral<T> && TIsSigned<T>::Value;
+template <typename T> concept CUnsignedIntegral   = CIntegral<T> && TIsUnsigned<T>::Value;
+template <typename T> concept CNonBooleanIntegral = CIntegral<T> && !TIsSame<typename TRemoveCVRef<T>::Type, bool>::Value;
+template <typename T> concept CFloatingPoint      = TIsFloatingPoint<T>::Value;
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END

Redcraft.Utility/Source/Public/Concepts/Concepts.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "Concepts/Same.h"
+#include "Concepts/Derived.h"
+#include "Concepts/BuiltinType.h"
+#include "Concepts/Convertible.h"
+#include "Concepts/Destructible.h"
+#include "Concepts/Constructible.h"
+
+//template <typename T> concept CBooleanTestable; // Prerequisites: Forward
+//template <typename T> concept CMovable;         // Prerequisites: CAssignableFrom
+//template <typename T> concept CCopyable;        // Prerequisites: CAssignableFrom
+//template <typename T> concept CSemiregular;     // Prerequisites: CCopyable
+//template <typename T> concept CRegular;         // Prerequisites: CEqualityComparable
+
+//template <typename T, typename U> concept CAssignableFrom;         // Prerequisites: Forward
+//template <typename T> concept CEqualityComparable;                 // Prerequisites: CBooleanTestable
+//template <typename T, typename U> concept CEqualityComparableWith; // Prerequisites: CBooleanTestable
+//template <typename T> concept CTotallyOrdered;                     // Prerequisites: CBooleanTestable
+//template <typename T, typename U> concept CTotallyOrderedWith;     // Prerequisites: CBooleanTestable
+
+//template <typename T, typename U> concept CCommonWith;                     // Prerequisites: Declval
+//template <typename T, typename U> concept CCommonReferenceWith;            // Prerequisites: Declval
+//template <typename F, typename... Args> concept CInvocable;                // Prerequisites: Invoke, Forward
+//template <typename F, typename... Args> concept CRegularInvocable;         // Prerequisites: Invoke, Forward
+//template <typename F, typename... Args> concept CPredicate;                // Prerequisites: CBooleanTestable, CRegularInvocable
+//template <typename F, typename T, typename U> concept CRelation;           // Prerequisites: CPredicate
+//template <typename F, typename T, typename U> concept CEquivalenceRelation // Prerequisites: CRelation
+//template <typename F, typename T, typename U> concept CStrictWeakOrder     // Prerequisites: CRelation

Redcraft.Utility/Source/Public/Concepts/Constructible.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "TypeTraits/TypeTraits.h"
+#include "Concepts/Convertible.h"
+
+#include <new>
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T, typename... Args>
+concept CConstructibleFrom = CDestructible<T> && TIsConstructible<T, Args...>::Value;
+
+template <typename T>
+concept CDefaultInitializable = CConstructibleFrom<T> && requires { T{}; ::new(static_cast<void*>(nullptr)) T; };
+
+template <typename T>
+concept CMoveConstructible = CConstructibleFrom<T, T> && CConvertibleTo<T, T>;
+
+template <typename T>
+concept CCopyConstructible = CMoveConstructible<T> &&
+	CConstructibleFrom<T, T&>       && CConvertibleTo<T&, T> &&
+	CConstructibleFrom<T, const T&> && CConvertibleTo<const T&, T> &&
+	CConstructibleFrom<T, const T>  && CConvertibleTo<const T, T>;
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END

Redcraft.Utility/Source/Public/Concepts/Convertible.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "TypeTraits/TypeTraits.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T, typename U>
+concept CConvertibleTo = TIsConvertible<T, U>::Value && requires(T(&Func)()) { static_cast<U>(Func()); };
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END

Redcraft.Utility/Source/Public/Concepts/Derived.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "TypeTraits/TypeTraits.h"
+#include "Concepts/Convertible.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T, typename U>
+concept CDerivedFrom = TIsBaseOf<U, T>::Value && CConvertibleTo<const volatile T*, const volatile U*>;
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END

Redcraft.Utility/Source/Public/Concepts/Destructible.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "TypeTraits/TypeTraits.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T>
+concept CDestructible = TIsDestructible<T>::Value;
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END

Redcraft.Utility/Source/Public/Concepts/Same.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "TypeTraits/TypeTraits.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+template <typename T, typename U>
+concept CSameAs = TIsSame<T, U>::Value && TIsSame<U, T>::Value;
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END

Redcraft.Utility/Source/Public/Testing/ConceptsTesting.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "CoreTypes.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+void REDCRAFTUTILITY_API TestConcepts();
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END