Replace adl_exception with std::system_error and adl_error_category.

Author: crowbar27

power_overwhelming/src/adl_exception.cpp …_overwhelming/src/adl_error_category.cpppower_overwhelming/src/adl_exception.cpp renamed to power_overwhelming/src/adl_error_category.cpp power_overwhelming/src/adl_exception.cpp renamed to power_overwhelming/src/adl_error_category.cpp

@@ -1,20 +1,33 @@
-// <copyright file="adl_exception.cpp" company="Visualisierungsinstitut der Universität Stuttgart">
-// Copyright © 2021 - 2025 Visualisierungsinstitut der Universität Stuttgart.
+// <copyright file="adl_error_category.cpp" company="Visualisierungsinstitut der Universität Stuttgart">
+// Copyright © 2025 Visualisierungsinstitut der Universität Stuttgart.
 // Licensed under the MIT licence. See LICENCE file for details.
 // </copyright>
+// <author>Christoph Müller</author>
 
-#include "adl_exception.h"
+#if defined(POWER_OVERWHELMING_WITH_ADL)
+#include "adl_error_category.h"
+
+#include <string>
 
 #include <adl_defines.h>
 
 
-/// <summary>
-/// Get a human-readable error description for the given ADL error code.
-/// </summary>
-/// <param name="code"></param>
-/// <returns></returns>
-static std::string adl_to_string(const int code) {
-    switch (code) {
+/*
+ * PWROWG_DETAIL_NAMESPACE::adl_error_category::default_error_condition
+ */
+std::error_condition
+PWROWG_DETAIL_NAMESPACE::adl_error_category::default_error_condition(
+        int status) const noexcept {
+    return std::error_condition(status, adl_category());
+}
+
+
+/*
+ * PWROWG_DETAIL_NAMESPACE::message
+ */
+std::string PWROWG_DETAIL_NAMESPACE::adl_error_category::message(
+        int status) const {
+    switch (status) {
         case ADL_OK_WAIT:
             return "Try again later.";
 
@@ -77,34 +90,34 @@ static std::string adl_to_string(const int code) {
             return "The graphics drvier is incompatible with ADL.";
 
         default:
-            return std::to_string(code);
+            return std::to_string(status);
     }
 }
 
 
 /*
- * PWROWG_DETAIL_NAMESPACE::adl_exception::check_error
+ * PWROWG_DETAIL_NAMESPACE::adl_category
  */
-bool PWROWG_DETAIL_NAMESPACE::adl_exception::check_error(
-        _In_ const value_type status) {
-    return (status < 0);
+const std::error_category& PWROWG_DETAIL_NAMESPACE::adl_category(
+        void) noexcept {
+    static const adl_error_category retval;
+    return retval;
 }
 
 
 /*
- * PWROWG_DETAIL_NAMESPACE::adl_exception::throw_on_error
+ * PWROWG_DETAIL_NAMESPACE::throw_if_adl_failed
  */
-void PWROWG_DETAIL_NAMESPACE::adl_exception::throw_on_error(
-        _In_ const value_type status) {
+void PWROWG_DETAIL_NAMESPACE::throw_if_adl_failed(
+        _In_ const int status,
+        _In_opt_z_ const char *message) {
     if (status < 0) {
-        throw adl_exception(status);
+        if (message == nullptr) {
+            throw std::system_error(status, adl_category());
+        } else {
+            throw std::system_error(status, adl_category(), message);
+        }
     }
 }
 
-
-/*
- * PWROWG_DETAIL_NAMESPACE::adl_exception::adl_exception
- */
-PWROWG_DETAIL_NAMESPACE::adl_exception::adl_exception(
-        _In_ const value_type code)
-    : std::runtime_error(adl_to_string(code).c_str()), _code(code) { }
+#endif /* defined(POWER_OVERWHELMING_WITH_ADL) */

power_overwhelming/src/adl_error_category.h

@@ -0,0 +1,76 @@
+// <copyright file="adl_error_category.h" company="Visualisierungsinstitut der Universität Stuttgart">
+// Copyright © 2025 Visualisierungsinstitut der Universität Stuttgart.
+// Licensed under the MIT licence. See LICENCE file for details.
+// </copyright>
+// <author>Christoph Müller</author>
+
+#if !defined(_PWROWG_ADL_ERROR_CATEGORY_H)
+#define _PWROWG_ADL_ERROR_CATEGORY_H
+#pragma once
+
+#include <system_error>
+
+#include "visus/pwrowg/api.h"
+
+#if defined(POWER_OVERWHELMING_WITH_ADL)
+
+PWROWG_DETAIL_NAMESPACE_BEGIN
+
+/// <summary>
+/// An error category for ADL errors.
+/// </summary>
+class PWROWG_TEST_API adl_error_category final : public std::error_category {
+
+public:
+
+    using std::error_category::error_category;
+
+    /// <summary>
+    /// Converts the error code into a portable description.
+    /// </summary>
+    /// <param name="status">The error code to be converted.</param>
+    /// <returns>The portable description of the ADL error.</returns>
+    std::error_condition default_error_condition(
+        _In_ int status) const noexcept override;
+
+    /// <summary>
+    /// Convert the given error code into a string.
+    /// </summary>
+    /// <param name="status">The error code to get the message for.</param>
+    /// <returns>The error message associated with the error code.
+    /// </returns>
+    std::string message(_In_ int status) const override;
+
+    /// <summary>
+    /// Answer the name of the error category.
+    /// </summary>
+    /// <returns>The name of the category.</returns>
+    inline const char *name(void) const noexcept override {
+        return "ADL";
+    }
+};
+
+
+/// <summary>
+/// Answer the one and only <see cref="adl_error_category" />.
+/// </summary>
+/// <returns>The only instance of <see cref="adl_error_category" />.
+/// </returns>
+PWROWG_TEST_API const std::error_category& adl_category(void) noexcept;
+
+/// <summary>
+/// Check whether <paramref name="status" /> indicates failure, and if so,
+/// throw an exception.
+/// </summary>
+/// <param name="status">The status code to be checked.</param>
+/// <param name="message">An optional error message to be included in the
+/// exception.</param>
+/// <exception cref="std::system_error">If <paramref name="status" /> indicates
+/// failure.</exception>
+PWROWG_TEST_API void throw_if_adl_failed(_In_ const int status,
+    _In_opt_z_ const char *message = nullptr);
+
+PWROWG_DETAIL_NAMESPACE_END
+
+#endif /* defined(POWER_OVERWHELMING_WITH_ADL) */
+#endif /* !defined(_PWROWG_ADL_ERROR_CATEGORY_H) */

power_overwhelming/src/adl_exception.h

@@ -4,12 +4,13 @@
 // </copyright>
 // <author>Christoph Müller</author>
 
+#if defined(POWER_OVERWHELMING_WITH_ADL)
 #include "adl_scope.h"
 
 #include <cassert>
 #include <cstdint>
 
-#include "adl_exception.h"
+#include "adl_error_category.h"
 #include "amd_display_library.h"
 
 
@@ -37,9 +38,7 @@ void __stdcall PWROWG_DETAIL_NAMESPACE::adl_scope::deallocate(void **buffer) {
 PWROWG_DETAIL_NAMESPACE::adl_scope::adl_scope(void) : _handle(0) {
     auto status = amd_display_library::instance().ADL2_Main_Control_Create(
         adl_scope::allocate, 1, &this->_handle);
-    if (status != ADL_OK) {
-        throw adl_exception(status);
-    }
+    throw_if_adl_failed(status);
 }
 
 
@@ -49,3 +48,5 @@ PWROWG_DETAIL_NAMESPACE::adl_scope::adl_scope(void) : _handle(0) {
 PWROWG_DETAIL_NAMESPACE::adl_scope::~adl_scope(void) {
     amd_display_library::instance().ADL2_Main_Control_Destroy(this->_handle);
 }
+
+#endif /* defined(POWER_OVERWHELMING_WITH_ADL) */

power_overwhelming/src/adl_scope.cpp

@@ -6,6 +6,7 @@
 #if !defined(_PWROWG_ADL_SCOPE_H)
 #define _PWROWG_ADL_SCOPE_H
 #pragma once
+#if defined(POWER_OVERWHELMING_WITH_ADL)
 
 #include <adl_sdk.h>
 
@@ -42,7 +43,7 @@ class PWROWG_TEST_API adl_scope final {
     /// <summary>
     /// Initialises a new instance.
     /// </summary>
-    /// <exception cref="adl_exception">If the ADL could not be loaded.
+    /// <exception cref="std::system_error">If the ADL could not be loaded.
     /// </exception>
     adl_scope(void);
 
@@ -71,4 +72,5 @@ class PWROWG_TEST_API adl_scope final {
 
 PWROWG_DETAIL_NAMESPACE_END
 
+#endif /* defined(POWER_OVERWHELMING_WITH_ADL) */
 #endif /* !defined(_PWROWG_ADL_SCOPE_H) */

power_overwhelming/src/adl_scope.h

@@ -3,13 +3,15 @@
 // Licensed under the MIT licence. See LICENCE file for details.
 // </copyright>
 
+#if defined(POWER_OVERWHELMING_WITH_ADL)
 #include "adl_sensor.h"
 
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <vector>
 
+#include "adl_error_category.h"
 #include "adl_utils.h"
 #include "sensor_array_impl.h"
 #include "sensor_description_builder.h"
@@ -304,7 +306,7 @@ PWROWG_DETAIL_NAMESPACE::adl_sensor::adl_sensor(
                 this->_scope,
                 this->_adapter_index,
                 &this->_device);
-        adl_exception::throw_on_error(status);
+        throw_if_adl_failed(status);
     }
 
     // Store all the sources we are interested in the startup block that will
@@ -327,7 +329,7 @@ PWROWG_DETAIL_NAMESPACE::adl_sensor::adl_sensor(
                 &this->_start_input,
                 &this->_start_output,
                 this->_device);
-        adl_exception::throw_on_error(status);
+        throw_if_adl_failed(status);
     }
 }
 
@@ -447,6 +449,7 @@ bool PWROWG_DETAIL_NAMESPACE::adl_sensor::specialise(
     return true;
 }
 
+#endif /* defined(POWER_OVERWHELMING_WITH_ADL) */
 
 
 

power_overwhelming/src/adl_sensor.cpp

@@ -7,6 +7,7 @@
 #if !defined(_PWROWG_ADL_SENSOR_H)
 #define _PWROWG_ADL_SENSOR_H
 #pragma once
+#if defined(POWER_OVERWHELMING_WITH_ADL)
 
 #include <chrono>
 #include <list>
@@ -19,7 +20,6 @@
 #include "visus/pwrowg/sensor_filters.h"
 
 #include "adl_scope.h"
-#include "adl_exception.h"
 #include "amd_display_library.h"
 #include "sensor_description_builder.h"
 #include "sensor_utilities.h"
@@ -127,7 +127,7 @@ class PWROWG_TEST_API adl_sensor final {
     /// <param name="index">The index of the first of the
     /// <paramref name="sources" />.</param>
     /// <returns></returns>
-    /// <exception cref="adl_exception">If the specified device was not
+    /// <exception cref="std::system_error">If the specified device was not
     /// found, or another error occurred in ADL.</exception>
     static inline std::shared_ptr<adl_sensor> from_index(
             _In_ const int adapter_index,
@@ -154,7 +154,7 @@ class PWROWG_TEST_API adl_sensor final {
     /// <exception cref="std::invalid_argument">If <paramref name="udid" />
     /// is <c>nullptr</c> or if it did not match exactly one device.
     /// </exception>
-    /// <exception cref="adl_exception">If the specified device was not
+    /// <exception cref="std::system_error">If the specified device was not
     /// found, or another error occurred in ADL.</exception>
     static std::shared_ptr<adl_sensor> from_udid(
         _In_z_ const char *udid,
@@ -176,7 +176,7 @@ class PWROWG_TEST_API adl_sensor final {
     /// <exception cref="std::invalid_argument">If <paramref name="udid" />
     /// is <c>nullptr</c> or if it did not match exactly one device.
     /// </exception>
-    /// <exception cref="adl_exception">If the specified device was not
+    /// <exception cref="std::system_error">If the specified device was not
     /// found, or another error occurred in ADL.</exception>
     static inline std::shared_ptr<adl_sensor> from_udid(
             _In_z_ const wchar_t *udid,
@@ -300,4 +300,5 @@ PWROWG_DETAIL_NAMESPACE_END
 
 #include "adl_sensor.inl"
 
+#endif /* defined(POWER_OVERWHELMING_WITH_ADL) */
 #endif /* defined(_PWROWG_ADL_SENSOR_H) */