Diff: MaximInterfaceCore/system_error.hpp

Revision:

8:5ea891c7d1a1

Parent:

7:9cd16581b578

--- a/MaximInterfaceCore/system_error.hpp	Mon Jul 22 11:44:07 2019 -0500
+++ b/MaximInterfaceCore/system_error.hpp	Mon Sep 16 11:13:37 2019 -0500
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (C) 2017 Maxim Integrated Products, Inc., All Rights Reserved.
+* Copyright (C) Maxim Integrated Products, Inc., All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -35,13 +35,15 @@
 /// Error handling constructs similar to std::error_code, std::error_condition,
 /// and std::error_category.
 
-#ifndef MaximInterfaceCore_system_error
-#define MaximInterfaceCore_system_error
+#ifndef MaximInterfaceCore_system_error_hpp
+#define MaximInterfaceCore_system_error_hpp
 
+#include <stddef.h>
 #include <stdexcept>
 #include <string>
 #include "Config.hpp"
 #include "SafeBool.hpp"
+#include "type_traits.hpp"
 #include "Uncopyable.hpp"
 
 namespace MaximInterfaceCore {
@@ -49,6 +51,7 @@
 class error_condition;
 class error_code;
 
+/// Error category interface.
 class error_category : private Uncopyable {
 public:
   virtual ~error_category() {}
@@ -79,8 +82,15 @@
   return &lhs < &rhs;
 }
 
+/// Default error category.
 MaximInterfaceCore_EXPORT const error_category & system_category();
 
+/// Checks if an enum type is implicitly convertible to an error_condition.
+template <typename T> struct is_error_condition_enum : false_type {};
+
+/// @brief
+/// Used for classifying groups of error_code into higher-level error conditions
+/// through the error_category::equivalent methods.
 class error_condition {
 public:
   error_condition() : value_(0), category_(&system_category()) {}
@@ -88,6 +98,22 @@
   error_condition(int value, const error_category & category)
       : value_(value), category_(&category) {}
 
+  template <typename ErrorConditionEnum>
+  error_condition(
+      ErrorConditionEnum e,
+      typename enable_if<
+          is_error_condition_enum<ErrorConditionEnum>::value>::type * = NULL) {
+    *this = make_error_condition(e);
+  }
+
+  template <typename ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value,
+                     error_condition &>::type
+  operator=(ErrorConditionEnum e) {
+    *this = make_error_condition(e);
+    return *this;
+  }
+
   void assign(int value, const error_category & category) {
     value_ = value;
     category_ = &category;
@@ -127,6 +153,15 @@
          ((lhs.category() == rhs.category()) && (lhs.value() < rhs.value()));
 }
 
+/// Checks if an enum type is implicitly convertible to an error_code.
+template <typename T> struct is_error_code_enum : false_type {};
+
+/// @brief Holds a raw error code produced by a subsystem.
+/// @details
+/// An error_code is composed of a pair of values: a category of errors, usually
+/// one per subsystem, and a number representing a specific error value within
+/// that category. While not required, zero is typically used as the success
+/// value so that the boolean conversion can be used as a failure test.
 class error_code {
 public:
   error_code() : value_(0), category_(&system_category()) {}
@@ -134,6 +169,22 @@
   error_code(int value, const error_category & category)
       : value_(value), category_(&category) {}
 
+  template <typename ErrorCodeEnum>
+  error_code(
+      ErrorCodeEnum e,
+      typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type * =
+          NULL) {
+    *this = make_error_code(e);
+  }
+
+  template <typename ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value,
+                     error_code &>::type
+  operator=(ErrorCodeEnum e) {
+    *this = make_error_code(e);
+    return *this;
+  }
+
   void assign(int value, const error_category & category) {
     value_ = value;
     category_ = &category;
@@ -198,6 +249,7 @@
   return !operator==(lhs, rhs);
 }
 
+/// Wrapper for throwing error_code as an exception.
 class system_error : public std::runtime_error {
 public:
   MaximInterfaceCore_EXPORT system_error(const error_code & ec);