RTL Evolution

.codecov.yml

@@ -0,0 +1,12 @@
+coverage:
+  status:
+    project:
+      rtl:
+        paths:
+          - ReflectionTemplateLib/rtl
+        target: 85%
+        informational: true
+
+comment:
+  layout: "diff, flags, files"
+  behavior: default

.github/workflows/build.yml

@@ -2,11 +2,11 @@ name: RTL Build
 
 on:
   push:
-    branches: [ release ]
+    branches: [ release, develop ]
     paths-ignore:
       - '**/*.md'
   pull_request:
-    branches: [ release ]
+    branches: [ release, develop ]
     paths-ignore:
       - '**/*.md'
   workflow_dispatch:

.github/workflows/coverage.yml

@@ -0,0 +1,71 @@
+name: RTL Coverage
+
+on:
+  push:
+    branches: [ release, develop ]
+    paths-ignore:
+      - '**/*.md'
+  pull_request:
+    branches: [ release, develop ]
+    paths-ignore:
+      - '**/*.md'
+  workflow_dispatch:
+
+jobs:
+  coverage:
+    name: RTL Coverage (Linux / GCC)
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Install coverage tools
+        run: |
+          sudo apt update
+          sudo apt install -y lcov gcovr ninja-build g++
+
+      - name: Configure (Coverage)
+        run: |
+          cmake -B build -G Ninja \
+                -DENABLE_COVERAGE=ON \
+                -DCMAKE_BUILD_TYPE=Debug \
+                -DCMAKE_CXX_COMPILER=g++
+
+      - name: Build
+        run: cmake --build build --parallel
+
+      - name: Run tests
+        run: |
+          ./bin/RTLTestRunApp
+
+      - name: Capture RTL coverage
+        run: |
+          lcov --capture --directory . \
+               --output-file coverage.info \
+               --ignore-errors=inconsistent,negative,mismatch
+
+          lcov --extract coverage.info \
+               '*ReflectionTemplateLib/rtl/*' \
+               -o coverage_rtl.info
+
+      - name: Generate HTML report
+        run: |
+          genhtml coverage_rtl.info \
+            --output-directory coverage_rtl \
+            --ignore-errors inconsistent,corrupt
+
+      - name: Upload coverage report
+        uses: actions/upload-artifact@v4
+        with:
+          name: rtl-coverage-report
+          path: coverage_rtl
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          files: coverage_rtl.info
+          flags: rtl
+          name: RTL-Core-Coverage
+          token: ${{ secrets.CODECOV_TOKEN }}
+          fail_ci_if_error: true

CMakeLists.txt

@@ -1,14 +1,25 @@
-# CMakeLists.txt for the entire project
 cmake_minimum_required(VERSION 3.20)
-# Set the project name
 project(CxxReflectionProject)
 
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin")
 
-# Add the subdirectories
+# ----------------------------
+# Coverage Support (Linux)
+# ----------------------------
+option(ENABLE_COVERAGE "Enable code coverage" OFF)
+
+if(ENABLE_COVERAGE AND CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    message(STATUS "Code coverage enabled")
+    add_compile_options(--coverage -O0 -g)
+    add_link_options(--coverage)
+endif()
+
+# ----------------------------
+# Subdirectories
+# ----------------------------
+add_subdirectory(ReflectionTemplateLib)
 add_subdirectory(CxxTestRegistration)
-add_subdirectory(RTLTestRunApp)
-add_subdirectory(RTLBenchmarkApp)
 add_subdirectory(CxxTestProps)
 add_subdirectory(CxxTestUtils)
-add_subdirectory(ReflectionTemplateLib)
+add_subdirectory(RTLTestRunApp)
+add_subdirectory(RTLBenchmarkApp)

CxxTestProps/inc/Complex.h

@@ -2,14 +2,9 @@
 
 #include <string>
 
+// C-style/free-functions.
 std::string getComplexNumAsString();
 
-std::string reverseString();
-
-std::string reverseString(std::string pStr);
-
-std::string reverseString(const char* pStr);
-
 namespace complex
 {
 	double getMagnitude();

CxxTestProps/inc/StringConst.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <string>
+
+// 'StrConst' - String-Const, all methods are const.
+struct StrConst
+{
+	constexpr static const char* struct_ = "StrConst";
+
+	std::string reverseString() const;
+
+	std::string reverseString(const char* pStr) const;
+
+	std::string reverseString(std::string pStr) const;					// (1) by value
+
+	std::string reverseString(std::string& pStr) const;					// (2) lvalue ref
+
+	std::string reverseString(const std::string& pStr) const;			// (3) const lvalue ref
+
+	std::string reverseString(std::string&& pStr) const;				// (4) rvalue ref
+
+	std::string reverseString(std::string* pStr) const;					// (5) pointer
+
+	std::string reverseString(const std::string* pStr) const;			// (6) pointer to const
+
+	std::string revStrConstRefArg(const std::string_view& pStr) const;
+
+	std::string revStrNonConstRefArg(std::string_view& pStr) const;
+
+	std::string revStrRValueRefArg(std::string_view&& pStr) const;
+
+	std::string revStrOverloadValRef(std::string_view pStr) const;
+
+	std::string revStrOverloadValRef(std::string_view& pStr) const;
+
+	std::string revStrOverloadValCRef(std::string_view pStr) const;
+
+	std::string revStrOverloadValCRef(const std::string_view& pStr) const;
+
+	std::string revStrOverloadRefAndCRef(std::string_view& pStr) const;
+
+	std::string revStrOverloadRefAndCRef(const std::string_view& pStr) const;
+};

CxxTestProps/inc/StringConstOverload.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+
+struct StrConstOverload 
+{
+	constexpr static const char* struct_ = "StrConstOverload";
+
+	std::string reverseString();
+
+	std::string reverseString() const;
+};

CxxTestProps/inc/StringMute.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <string>
+
+// 'StrMute' - String-Mutable, all methods are non-const.
+struct StrMute
+{
+	constexpr static const char* struct_ = "StrMute";
+
+	std::string reverseString();
+
+	std::string reverseString(const char* pStr);
+
+	std::string reverseString(std::string pStr);              // (1) by value
+
+	std::string reverseString(std::string& pStr);             // (2) lvalue ref
+
+	std::string reverseString(const std::string& pStr);       // (3) const lvalue ref
+
+	std::string reverseString(std::string&& pStr);            // (4) rvalue ref
+
+	std::string reverseString(std::string* pStr);			  // (5) pointer
+
+	std::string reverseString(const std::string* pStr);		  // (6) pointer to const
+
+	std::string revStrConstRefArg(const std::string_view& pStr);
+
+	std::string revStrNonConstRefArg(std::string_view& pStr);
+
+	std::string revStrRValueRefArg(std::string_view&& pStr);
+
+	std::string revStrOverloadValRef(std::string_view pStr);
+
+	std::string revStrOverloadValRef(std::string_view& pStr);
+
+	std::string revStrOverloadValCRef(std::string_view pStr);
+
+	std::string revStrOverloadValCRef(const std::string_view& pStr);
+
+	std::string revStrOverloadRefAndCRef(std::string_view& pStr);
+
+	std::string revStrOverloadRefAndCRef(const std::string_view& pStr);
+};

CxxTestProps/inc/StringOps.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <string>
+
+std::string reverseString();
+
+std::string reverseString(const char* pStr);
+
+std::string reverseString(std::string pStr);              // (1) by value
+
+std::string reverseString(std::string& pStr);             // (2) lvalue ref
+
+std::string reverseString(const std::string& pStr);       // (3) const lvalue ref
+
+std::string reverseString(std::string&& pStr);            // (4) rvalue ref
+
+std::string reverseString(std::string* pStr);			  // (5) pointer
+
+std::string reverseString(const std::string* pStr);		  // (6) pointer to const
+
+std::string revStrConstRefArg(const std::string_view& pStr);
+
+std::string revStrNonConstRefArg(std::string_view& pStr);
+
+std::string revStrRValueRefArg(std::string_view&& pStr);
+
+std::string revStrOverloadValRef(std::string_view pStr);
+
+std::string revStrOverloadValRef(std::string_view& pStr);
+
+std::string revStrOverloadValCRef(std::string_view pStr);
+
+std::string revStrOverloadValCRef(const std::string_view& pStr);
+
+std::string revStrOverloadRefAndCRef(std::string_view& pStr);
+
+std::string revStrOverloadRefAndCRef(const std::string_view& pStr);

CxxTestProps/inc/StringStatic.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <string>
+
+// 'StrStatic' - String-Static, all methods are static.
+struct StrStatic
+{
+	constexpr static const char* struct_ = "StrStatic";
+
+	static std::string reverseString();
+
+	static std::string reverseString(const char* pStr);
+
+	static std::string reverseString(std::string pStr);					// (1) by value
+
+	static std::string reverseString(std::string& pStr);					// (2) lvalue ref
+
+	static std::string reverseString(const std::string& pStr);			// (3) const lvalue ref
+
+	static std::string reverseString(std::string&& pStr);				// (4) rvalue ref
+
+	static std::string reverseString(std::string* pStr);					// (5) pointer
+
+	static std::string reverseString(const std::string* pStr);			// (6) pointer to const
+
+	static std::string revStrConstRefArg(const std::string_view& pStr);
+
+	static std::string revStrNonConstRefArg(std::string_view& pStr);
+
+	static std::string revStrRValueRefArg(std::string_view&& pStr);
+
+	static std::string revStrOverloadValRef(std::string_view pStr);
+
+	static std::string revStrOverloadValRef(std::string_view& pStr);
+
+	static std::string revStrOverloadValCRef(std::string_view pStr);
+
+	static std::string revStrOverloadValCRef(const std::string_view& pStr);
+
+	static std::string revStrOverloadRefAndCRef(std::string_view& pStr);
+
+	static std::string revStrOverloadRefAndCRef(const std::string_view& pStr);
+};

CxxTestProps/inc/StringWrap.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <string>
+
+struct StrWrap
+{
+	const std::string m_str;
+	const std::string& sstr() const;
+
+	StrWrap(const std::string& pStr);
+};
+
+// 'StrWrapA' - String-Wrapper, only constructors for testing.
+struct StrWrapA : public StrWrap
+{
+	constexpr static const char* struct_ = "StrWrapA";
+
+	StrWrapA();
+
+	StrWrapA(std::string_view pStr);              // (1) by value
+
+	StrWrapA(std::string& pStr);             // (2) lvalue ref
+
+	StrWrapA(const std::string& pStr);       // (3) const lvalue ref
+
+	StrWrapA(std::string&& pStr);            // (4) rvalue ref
+
+	StrWrapA(const char* pStr);			  // (5) pointer
+};
+
+
+// 'StrWrapB' - String-Wrapper, only constructors for testing.
+struct StrWrapB : public StrWrap
+{
+	constexpr static const char* struct_ = "StrWrapB";
+	StrWrapB(std::string& pStr);
+	StrWrapB(const std::string& pStr);
+};
+
+
+// 'StrWrapC' - String-Wrapper, only constructors for testing.
+struct StrWrapC : public StrWrap
+{
+	constexpr static const char* struct_ = "StrWrapC";
+	StrWrapC(std::string& pStr);
+};
+
+
+// 'StrWrapD' - String-Wrapper, only constructors for testing.
+struct StrWrapD : public StrWrap
+{
+	constexpr static const char* struct_ = "StrWrapD";
+	StrWrapD(const std::string& pStr);
+};