Remove template-based type of TraceableException

Author: Bill-hbrhbr

src/ystdlib/error_handling/CMakeLists.txt

@@ -4,7 +4,6 @@ cpp_library(
     PUBLIC_HEADERS
         ErrorCode.hpp
         TraceableException.hpp
-        types.hpp
         utils.hpp
     TESTS_SOURCES
         test/constants.hpp

src/ystdlib/error_handling/TraceableException.hpp

@@ -8,7 +8,6 @@
 #include <system_error>
 #include <utility>
 
-#include "types.hpp"
 #include "utils.hpp"
 
 namespace ystdlib::error_handling {
@@ -23,43 +22,42 @@ namespace ystdlib::error_handling {
  * @see std::source_location::function_name()
  * @see std::source_location::line()
  */
-template <ErrorCodeType ErrorType = std::error_code>
 class TraceableException : public std::exception {
 public:
     // Constructors
     explicit TraceableException(
-            ErrorType error_code,
+            std::error_code error_code,
             std::source_location const& where = std::source_location::current()
     )
-            : m_error_code{std::move(error_code)},
+            : m_error_code{error_code},
               m_where{where} {
         std::ostringstream oss;
         oss << where;
         m_what = oss.str();
     }
 
     explicit TraceableException(
-            ErrorType error_code,
+            std::error_code error_code,
             std::string what,
             std::source_location const& where = std::source_location::current()
     )
-            : m_error_code{std::move(error_code)},
+            : m_error_code{error_code},
               m_what{std::move(what)},
               m_where{where} {}
 
     // Methods implementing std::exception
     [[nodiscard]] auto what() const noexcept -> char const* override { return m_what.c_str(); }
 
     // Methods
-    [[nodiscard]] auto error_code() const -> ErrorType { return m_error_code; }
+    [[nodiscard]] auto error_code() const -> std::error_code { return m_error_code; }
 
     [[nodiscard]] auto what() -> std::string& { return m_what; }
 
     [[nodiscard]] auto where() const noexcept -> std::source_location const& { return m_where; }
 
 private:
     // Variables
-    ErrorType m_error_code;
+    std::error_code m_error_code;
     std::string m_what;
     std::source_location m_where;
 };
@@ -70,13 +68,8 @@ class TraceableException : public std::exception {
  */
 // NOLINTBEGIN(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
 #define YSTDLIB_ERROR_HANDLING_DEFINE_TRACEABLE_EXCEPTION(T) \
-    class T : public ystdlib::error_handling::TraceableException<> { \
-        using ystdlib::error_handling::TraceableException<>::TraceableException; \
-    }
-
-#define YSTDLIB_ERROR_HANDLING_DEFINE_TRACEABLE_EXCEPTION_WITH_ERROR_TYPE(T, E) \
-    class T : public ystdlib::error_handling::TraceableException<E> { \
-        using ystdlib::error_handling::TraceableException<E>::TraceableException; \
+    class T : public ystdlib::error_handling::TraceableException { \
+        using ystdlib::error_handling::TraceableException::TraceableException; \
     }
 // NOLINTEND(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
 

src/ystdlib/error_handling/test/test_TraceableException.cpp

@@ -2,13 +2,11 @@
 #include <cstring>
 
 #include <ystdlib/error_handling/TraceableException.hpp>
-#include <ystdlib/error_handling/types.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 
 #include "types.hpp"
 
-using ystdlib::error_handling::ErrorCodeType;
 using ystdlib::error_handling::TraceableException;
 
 namespace {
@@ -41,14 +39,14 @@ class Worker {
 }  // namespace ystdlib::error_handling::test
 
 namespace {
-template <ErrorCodeType ErrorType = std::error_code, typename Callable>
-[[nodiscard]] auto capture_exception(Callable&& f) -> TraceableException<ErrorType>;
+template <typename Callable>
+[[nodiscard]] auto capture_exception(Callable&& f) -> TraceableException;
 
-template <ErrorCodeType ErrorType, typename Callable>
-auto capture_exception(Callable&& f) -> TraceableException<ErrorType> {
+template <typename Callable>
+auto capture_exception(Callable&& f) -> TraceableException {
     try {
         std::forward<Callable>(f)();
-    } catch (TraceableException<ErrorType>& e) {
+    } catch (TraceableException& e) {
         return e;
     }
     assert(false && "The function is expected to throw.");
@@ -57,11 +55,11 @@ auto capture_exception(Callable&& f) -> TraceableException<ErrorType> {
 
 namespace ystdlib::error_handling::test {
 TEST_CASE("test_traceable_exception", "[error_handling][TraceableException]") {
-    auto const ex_success{capture_exception<>(Worker::execute_with_success)};
+    auto const ex_success{capture_exception(Worker::execute_with_success)};
     REQUIRE(std::string{ex_success.where().file_name()}.ends_with(cCurrentFileName));
     REQUIRE((0 == std::strcmp(ex_success.where().function_name(), cSuccessFuncName)));
 
-    auto const ex_failure{capture_exception<>(Worker::execute_with_failure)};
+    auto const ex_failure{capture_exception(Worker::execute_with_failure)};
     REQUIRE((0 == std::strcmp(ex_failure.what(), cCustomFailureDescription)));
     REQUIRE(std::string{ex_failure.where().file_name()}.ends_with(cCurrentFileName));
     REQUIRE((0 == std::strcmp(ex_failure.where().function_name(), cFailureFuncName)));

src/ystdlib/error_handling/types.hpp

@@ -5,6 +5,12 @@
 #include <source_location>
 
 namespace ystdlib::error_handling {
+/**
+ * Writes a formatted representation of `std::source_location` to the output stream.
+ *
+ * @param os
+ * @param where
+ */
 inline auto operator<<(std::ostream& os, std::source_location const& where) -> std::ostream& {
     return os << where.file_name() << "(" << where.line() << ":" << where.column()
               << "), function `" << where.function_name() << "`";