Implement std::system_error.

Notice that std::system_error depends on std::string, which means that
it cannot be nothrow-copyable. If it didn't have that pointless dependency,
i.e. if it really just contained a std::error_code and nothing else, then
it could have been trivially copyable!

The rationale for making it so heavyweight is presumably that you're
going to be throwing this object, i.e. not copying it (since a throw-expression
will usually result in a move, not a copy, of the thrown object), and
the cost of the memory allocation for std::string (if it is not SSO'ed)
will be negligible compared to the cost of the throw itself.

Author: Quuxplusone

include/scratch/bits/stdexcept/system-error.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "scratch/bits/containers/string.h"
+#include "scratch/bits/error-code/error-code.h"
+#include "scratch/bits/stdexcept/stdexcept.h"
+
+namespace scratch {
+
+class system_error : public runtime_error {
+    error_code m_code;
+    string m_what;
+public:
+    explicit system_error(error_code v) : m_code(v), m_what(v.to_string()) {}
+    explicit system_error(error_code v, const string& prefix) : m_code(v), m_what(prefix + ": " + v.to_string()) {}
+    explicit system_error(error_code v, const char *prefix) : m_code(v), m_what(prefix + (": " + v.to_string())) {}
+    explicit system_error(int v, const error_category& cat) : m_code(v, cat), m_what(v.to_string()) {}
+    explicit system_error(int v, const error_category& cat, const char *prefix) : m_code(v, cat), m_what(prefix + (": " + v.to_string())) {}
+    explicit system_error(int v, const error_category& cat, string prefix) : m_code(v, cat), m_what(prefix + ": " + v.to_string()) {}
+
+    const error_code& code() const noexcept { return m_code; }
+    const char* what() const noexcept { return m_what.c_str(); }
+};
+
+} // namespace scratch

include/scratch/system_error

@@ -2,3 +2,4 @@
 
 #include "bits/error-code/error-code.h"
 #include "bits/error-code/system-category.h"
+#include "bits/stdexcept/system-error.h"