Switched to use Unreal Engine's naming convention (#30)

* Initial naming refactor pass

* Fixed build issues from the refactor

* Started work on doing the partial refactor

* Last renames

* Added a few name aliases

* Additional naming convention fixes

* Additional generator fixes

* Made it so COROUTINES can be toggled off theoretically

* Fixed test case failures

* Fixed a bad include

Author: retroandchill

RetroLib/CMakeLists.txt

@@ -8,7 +8,8 @@ if (RETROLIB_WITH_MODULES)
                 src/RetroLib.ixx)
     target_compile_definitions(RetroLib
         PUBLIC
-            RETROLIB_WITH_MODULES=1)
+            RETROLIB_WITH_MODULES=1
+            RETROLIB_WITH_COROUTINES=1)
 
     target_include_directories(RetroLib
             PUBLIC
@@ -21,6 +22,7 @@ else()
             ${CMAKE_CURRENT_SOURCE_DIR}/include)
     target_compile_definitions(RetroLib
             INTERFACE
-            RETROLIB_WITH_MODULES=0)
+            RETROLIB_WITH_MODULES=0
+            RETROLIB_WITH_COROUTINES=1)
 endif()
 

RetroLib/include/RetroLib/Casting/ByteCast.h

@@ -16,7 +16,7 @@
 #define RETROLIB_EXPORT
 #endif
 
-namespace retro {
+namespace Retro {
     /**
      * Represents a type we see as a valid opaque byte pointer.
      *
@@ -26,9 +26,8 @@ namespace retro {
     concept ValidByteType =
         std::same_as<T, std::byte> || std::same_as<T, uint8_t> || std::same_as<T, int8_t> || std::same_as<T, void>;
 
-    template <typename T>
     /**
-     * @class ByteCast
+     * @class ByteCastFunction
      * @brief A utility class for casting various data types to byte representations.
      *
      * TByteCast provides functionality to cast different data types such as integers,
@@ -42,7 +41,8 @@ namespace retro {
      * - Ensure proper endianess during the casting process.
      * - Utility methods to handle casting of custom objects, if needed.
      */
-    struct ByteCast {
+    template <typename T>
+    struct ByteCastFunction {
         /**
          * @brief Casts a byte pointer to a specified data type.
          *
@@ -75,5 +75,5 @@ namespace retro {
      * - Provides additional functionality for custom object conversions if necessary.
      */
     RETROLIB_EXPORT template <typename T>
-    constexpr ByteCast<T> byte_cast;
+    constexpr ByteCastFunction<T> ByteCast;
 } // namespace retro

…Lib/include/RetroLib/Casting/ClassCast.h …b/include/RetroLib/Casting/DynamicCast.hRetroLib/include/RetroLib/Casting/ClassCast.h renamed to RetroLib/include/RetroLib/Casting/DynamicCast.h RetroLib/include/RetroLib/Casting/ClassCast.h renamed to RetroLib/include/RetroLib/Casting/DynamicCast.h

@@ -1,5 +1,5 @@
 /**
- * @file ClassCast.h
+ * @file DynamicCast.h
  * @brief Functor for performing runtime conversions between types.
  *
  * @author Retro & Chill
@@ -20,7 +20,7 @@
 #define RETROLIB_EXPORT
 #endif
 
-namespace retro {
+namespace Retro {
 
     /**
      * Attempts to dynamically cast a reference of type U to a reference of type T.
@@ -38,16 +38,16 @@ namespace retro {
      * Optional reference to T is returned.
      */
     RETROLIB_EXPORT template <Class T, Class U, bool Checked = false>
-    constexpr decltype(auto) dyn_cast_ref(U &value) {
+    constexpr decltype(auto) DynCastRef(U &Value) {
         if constexpr (std::is_base_of_v<T, U>) {
-            return static_cast<T &>(value);
+            return static_cast<T &>(Value);
         } else {
-            auto ptr = dynamic_cast<T *>(&value);
+            auto Ptr = dynamic_cast<T *>(&Value);
             if constexpr (Checked) {
-                RETROLIB_ASSERT(valid_ptr(ptr));
-                return dynamic_cast<T &>(value);
+                RETROLIB_ASSERT(valid_ptr(Ptr));
+                return dynamic_cast<T &>(Value);
             } else {
-                return ptr != nullptr ? Optional<T &>(*ptr) : Optional<T &>();
+                return Ptr != nullptr ? Optional<T &>(*Ptr) : Optional<T &>();
             }
         }
     }
@@ -63,19 +63,19 @@ namespace retro {
      * @tparam Checked A boolean template parameter to indicate whether to perform runtime checks during casting.
      */
     template <Class T, bool Checked = false>
-    struct ClassCast {
+    struct DynamicCastFunction {
         /**
          * Overloaded function call operator which performs a dynamic cast of a reference type.
          * This function attempts to cast a reference of type U to a reference of type T.
          * If the Checked parameter is considered, it might involve runtime checks for safety.
-         *
-         * @param value A reference to a value of type U that is to be casted.
+         *D
+         * @param Value A reference to a value of type U that is to be casted.
          * @return The result of the dynamic cast to type T. The return is of the same reference type,
          * which is determined by the use of `decltype(auto)`.
          */
         template <Class U>
-        constexpr decltype(auto) operator()(U &value) {
-            return dyn_cast_ref<T, U, Checked>(value);
+        constexpr decltype(auto) operator()(U &Value) {
+            return DynCastRef<T, U, Checked>(Value);
         }
 
         /**
@@ -84,25 +84,25 @@ namespace retro {
          * This operator function checks if the provided value is a valid pointer, and depending on compile-time
          * conditions, it performs a dynamic cast or derives reference conversion.
          *
-         * @param value A universal reference to a value that will be checked for validity and conditionally
+         * @param Value A universal reference to a value that will be checked for validity and conditionally
          * transformed. This can be a pointer or a reference to an object.
          *
          * @return An Optional containing a reference to the object of type T if the pointer is valid and the
          * cast/conversion succeeds. If the pointer is invalid, an empty Optional is returned.
          */
         template <PointerType U>
-        constexpr decltype(auto) operator()(U &&value) const {
+        constexpr decltype(auto) operator()(U &&Value) const {
             if constexpr (Checked) {
-                RETROLIB_ASSERT(valid_ptr(std::forward<U>(value)));
-                return dyn_cast_ref<T, std::remove_pointer_t<U>, Checked>(*std::forward<U>(value));
+                RETROLIB_ASSERT(valid_ptr(std::forward<U>(Value)));
+                return DynCastRef<T, std::remove_pointer_t<U>, Checked>(*std::forward<U>(Value));
             } else if constexpr (std::derived_from<std::decay_t<DereferencedType<U>>, std::decay_t<T>>) {
-                return valid_ptr(std::forward<U>(value)) ? Optional<T &>(*std::forward<U>(value)) : Optional<T &>();
+                return ValidPtr(std::forward<U>(Value)) ? Optional<T &>(*std::forward<U>(Value)) : Optional<T &>();
             } else {
-                if (!valid_ptr(std::forward<U>(value))) {
+                if (!ValidPtr(std::forward<U>(Value))) {
                     return Optional<T &>();
                 }
 
-                return dyn_cast_ref<T, std::decay_t<DereferencedType<U>>, Checked>(*std::forward<U>(value));
+                return DynCastRef<T, std::decay_t<DereferencedType<U>>, Checked>(*std::forward<U>(Value));
             }
         }
 
@@ -111,15 +111,15 @@ namespace retro {
          * to a Polymorphic object, effectively de-referencing it and invoking the functor on the
          * underlying object that the Polymorphic reference points to.
          *
-         * @param value A reference to a Polymorphic<U> object, where U must be a type that supports
+         * @param Value A reference to a Polymorphic<U> object, where U must be a type that supports
          *              the operations defined within the functor.
          * @return The result of invoking the functor on the de-referenced object. The return type is
          *         deduced using decltype(auto), meaning it will preserve the value category and type
          *         of the final operation's result.
          */
         template <Class U>
-        constexpr decltype(auto) operator()(Polymorphic<U> &value) const {
-            return (*this)(*value);
+        constexpr decltype(auto) operator()(Polymorphic<U> &Value) const {
+            return (*this)(*Value);
         }
 
         /**
@@ -128,12 +128,12 @@ namespace retro {
          * This operator allows the functor to be called on a given polymorphic object,
          * effectively dereferencing it and calling the functor with its underlying value.
          *
-         * @param value A constant reference to a Polymorphic object containing the value.
+         * @param Value A constant reference to a Polymorphic object containing the value.
          * @return The result of applying the functor to the dereferenced value stored in the Polymorphic object.
          */
         template <Class U>
-        constexpr decltype(auto) operator()(const Polymorphic<U> &value) const {
-            return (*this)(*value);
+        constexpr decltype(auto) operator()(const Polymorphic<U> &Value) const {
+            return (*this)(*Value);
         }
 
         constexpr Optional<T &> operator()(std::nullptr_t) const
@@ -156,7 +156,7 @@ namespace retro {
      * @tparam T The target class type to which the casting is to be performed.
      */
     RETROLIB_EXPORT template <Class T>
-    constexpr ClassCast<T> class_cast;
+    constexpr DynamicCastFunction<T> DynamicCast;
 
     /**
      * @brief A compile-time constant expression representing a checked class cast operation.
@@ -170,6 +170,6 @@ namespace retro {
      *           be specified to indicate the destination class type for the casting operation.
      */
     RETROLIB_EXPORT template <Class T>
-    constexpr ClassCast<T, true> class_cast_checked;
+    constexpr DynamicCastFunction<T, true> ClassCastChecked;
 
 } // namespace retro

RetroLib/include/RetroLib/Casting/InstanceOf.h

@@ -19,31 +19,38 @@
 #define RETROLIB_EXPORT
 #endif
 
-namespace retro {
+namespace Retro {
 
-    /**
-     * Checks if the given instance of type U is a valid instance of the desired base type T.
-     *
-     * @param value The instance of type U to be checked for validity.
-     * @return True if the instance is valid, meaning that U is derived from T or is an instance
-     *         that can be dynamically cast to T. Otherwise, returns false.
-     */
-    RETROLIB_EXPORT template <Class T, Class U>
-    constexpr bool is_valid_instance(const U &value) {
-        if constexpr (std::derived_from<U, T>) {
-            // Trivial case, U is derived from T, so we know with certainty that this is valid
-            return true;
-        } else {
+    RETROLIB_EXPORT template <Class T>
+    struct InstanceChecker {
+        /**
+         * Checks if the given instance of type U is a valid instance of the desired base type T.
+         *
+         * @param Value The instance of type U to be checked for validity.
+         * @return True if the instance is valid, meaning that U is derived from T or is an instance
+         *         that can be dynamically cast to T. Otherwise, returns false.
+         */
+        template <Class U>
+        constexpr bool operator()(const U& Value) const {
+            if constexpr (std::derived_from<U, T>) {
+                // Trivial case, U is derived from T, so we know with certainty that this is valid
+                return true;
+            } else {
 #ifndef RTTI_ENABLED
-            static_assert(false, "RTTI is disabled, but the type is not derived from T")
-#endif
-                auto casted = dynamic_cast<const T *>(&value);
-            return casted != nullptr;
+                static_assert(false, "RTTI is disabled, but the type is not derived from T");
+    #endif
+                    auto casted = dynamic_cast<const T *>(&Value);
+                return casted != nullptr;
+            }
         }
-    }
+    };
+
+
+    template <Class T>
+    static constexpr InstanceChecker<T> IsValidInstance;
 
     /**
-     * @struct InstanceOf
+     * @struct InstanceOfFunction
      * @brief A utility to check if an object or a pointer is a valid instance of a specified type.
      *
      * The InstanceOf struct provides overloaded function call operators to determine if a given
@@ -52,16 +59,16 @@ namespace retro {
      * @tparam T The type against which the object's type is being checked.
      */
     template <Class T>
-    struct InstanceOf {
+    struct InstanceOfFunction {
         /**
          * Checks if the given value is a valid instance of type U.
          *
-         * @param value The value to be checked against the type U.
+         * @param Value The value to be checked against the type U.
          * @return A boolean indicating whether the value is a valid instance of type U.
          */
         template <Class U>
-        constexpr bool operator()(const U &value) const {
-            return is_valid_instance<T, U>(value);
+        constexpr bool operator()(const U &Value) const {
+            return IsValidInstance<T>(Value);
         }
 
         /**
@@ -71,13 +78,13 @@ namespace retro {
          * to the `valid_ptr` function and whether the functor applied to the value pointed to by
          * the pointer is true.
          *
-         * @param ptr Pointer to the object that needs to be checked.
+         * @param Ptr Pointer to the object that needs to be checked.
          * @return true if the pointer is valid and the functor evaluates to true for the
          * dereferenced value, otherwise false.
          */
         template <PointerType U>
-        constexpr bool operator()(U &&ptr) const {
-            return valid_ptr(std::forward<U>(ptr)) && (*this)(*std::forward<U>(ptr));
+        constexpr bool operator()(U &&Ptr) const {
+            return ValidPtr(std::forward<U>(Ptr)) && (*this)(*std::forward<U>(Ptr));
         }
 
         /**
@@ -86,21 +93,21 @@ namespace retro {
          * This function is a callable operator that takes a polymorphic object
          * and applies this operator to its dereferenced value.
          *
-         * @param polymorphic A Polymorphic object which contains a type U of
+         * @param Polymorphic A Polymorphic object which contains a type U of
          *        a certain size. The object will be dereferenced and the
          *        result will be passed to the operator function.
          * @return A boolean value indicating the result of applying the operator
          *         to the dereferenced value of the polymorphic object.
          */
         template <Class U, size_t Size>
-        constexpr bool operator()(const Polymorphic<U, Size> &polymorphic) const {
-            return (*this)(*polymorphic);
+        constexpr bool operator()(const Polymorphic<U, Size> &Polymorphic) const {
+            return (*this)(*Polymorphic);
         }
 
         /**
          * Determines the boolean value for a nullptr.
          *
-         * @param A parameter of type std::nullptr_t representing a null pointer.
+         * @param std::nullptr_t A parameter of type std::nullptr_t representing a null pointer.
          * @return Always returns false as null pointers are considered false.
          */
         constexpr bool operator()(std::nullptr_t) const {
@@ -124,5 +131,5 @@ namespace retro {
      * are performed at compile-time.
      */
     RETROLIB_EXPORT template <Class T>
-    constexpr InstanceOf<T> instance_of;
+    constexpr InstanceOfFunction<T> InstanceOf;
 } // namespace retro