Merge branch 'master' of git://git.ucc.asn.au/tpg/acess2

[tpg/acess2.git] / Usermode / Libraries / libc++.so_src / include_exp / system_error

diff --git a/Usermode/Libraries/libc++.so_src/include_exp/system_error b/Usermode/Libraries/libc++.so_src/include_exp/system_error
new file mode 100644 (file)
index 0000000..496970e
--- /dev/null
+++ b/Usermode/Libraries/libc++.so_src/include_exp/system_error
@@ -0,0 +1,189 @@
+/*
+ * Acess2 C++ Library
+ * - By John Hodge (thePowersGang)
+ *
+ * system_error (header)
+ * - C++11's system_error exception
+ */
+#ifndef _LIBCXX_SYSTEM_ERROR_
+#define _LIBCXX_SYSTEM_ERROR_
+
+#include "_libcxx_helpers.h"
+
+#if !_CXX11_AVAIL
+# error "This header requires C++11 support enabled"
+#endif
+
+#include <exception>
+#include <string>
+
+namespace std {
+
+class error_category;
+class error_condition;
+class error_code;
+
+static bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
+static bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
+static bool operator< (const error_condition& lhs, const error_condition& rhs) noexcept;
+static bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
+static bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
+static bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
+static bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
+
+extern const error_category&   generic_category() noexcept;
+extern const error_category&   system_category() noexcept;
+
+class error_condition
+{
+        int    m_val;
+       const error_category*   m_cat;
+public:
+       error_condition() noexcept:
+               error_condition(0, ::std::generic_category())
+       {
+       }
+       error_condition(int val, const error_category& cat) noexcept:
+               m_val(val),
+               m_cat(&cat)
+       {
+       }
+       //template <class ErrorConditionEnum> error_condition(ErrorConditionEnum e) noexcept;
+       //template <class ErrorConditionEnum> error_condition& operator=(ErrorConditionEnum e) noexcept;
+       void assign(int val, const error_category& cat) noexcept {
+               m_val = val;
+               m_cat = &cat;
+       }
+       void clear() noexcept {
+               assign(0, ::std::generic_category());
+       }
+       int value() const noexcept {
+               return m_val;
+       }
+       const error_category& category() const noexcept {
+               return *m_cat;
+       }
+       string message() const;
+       explicit operator bool() const noexcept {
+               return m_val != 0;
+       }
+};
+
+class error_category
+{
+public:
+       error_category() {
+       }
+       error_category(const error_category&) = delete; // disallow copying
+       virtual ~error_category() noexcept {
+       }
+       bool operator==(const error_category& rhs) const noexcept {
+               return this == &rhs;
+       }
+       bool operator!=(const error_category& rhs) const noexcept {
+               return !(*this == rhs);
+       }
+       bool operator<(const error_category& rhs) const noexcept {
+               return this < &rhs;
+       }
+       virtual const char* name() const noexcept = 0;
+       virtual error_condition default_error_condition(int val) const noexcept {
+               return error_condition(val, *this);
+       }
+       virtual bool equivalent(int valcode, const ::std::error_condition& cond) const noexcept {
+               return default_error_condition(valcode) == cond;
+       }
+       virtual bool equivalent(const error_code& code, int valcond) const noexcept;    // in system_error.cc
+       virtual ::std::string message(int val) const = 0;
+};
+
+class error_code
+{
+       int     m_ev;
+       const ::std::error_category*    m_ecat;
+public:
+       error_code() noexcept:
+               error_code(0, ::std::generic_category())
+       {
+       }
+       error_code(int ev, const ::std::error_category& ecat) noexcept:
+               m_ev(ev),
+               m_ecat(&ecat)
+       {
+       }
+       //template <class ErrorCodeEnum>
+       //error_code(ErrorCodeEnum e) noexcept;
+       void assign(int val, const error_category& ecat) noexcept {
+               m_ev = val;
+               m_ecat = &ecat;
+       }
+       //template <class ErrorCodeEnum>
+       //error_code& operator= (ErrorCodeEnum e) noexcept;
+       void clear() noexcept {
+               m_ev = 0;
+               m_ecat = 0;
+       }
+       int value() const noexcept {
+               return m_ev;
+       }
+       const error_category& category() const noexcept {
+               return *m_ecat;
+       }
+       error_condition default_error_condition() const noexcept {
+               return category().default_error_condition(value());
+       }
+       ::std::string message() const {
+               return category().message(value());
+       }
+       operator bool() const noexcept {
+               return m_ev != 0;
+       }
+};
+
+class system_error:
+       public ::std::exception
+{
+       const error_code        m_error_code;
+       ::std::string   m_what_str;
+public:
+       system_error(::std::error_code ec);
+       system_error(::std::error_code ec, const ::std::string& what_arg);
+       system_error(::std::error_code ec, const char* what_arg);
+       system_error(int ev, const ::std::error_category& ecat);
+       system_error(int ev, const ::std::error_category& ecat, const ::std::string& what_arg);
+       system_error(int ev, const ::std::error_category& ecat, const char* what_arg);
+       ~system_error() noexcept;
+       
+       const char* what() const noexcept;
+};
+
+static inline bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept {
+       return lhs.category() == rhs.category() && lhs.value() == rhs.value();
+}
+static inline bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept {
+       return !(lhs == rhs);
+}
+static inline bool operator< (const error_condition& lhs, const error_condition& rhs) noexcept {
+       return lhs.category() < rhs.category() || lhs.value() < rhs.value();
+}
+static inline bool operator==(const error_condition& lhs, const error_code& rhs) noexcept {
+       return lhs.category().equivalent(rhs, lhs.value()) || rhs.category().equivalent(rhs.value(), lhs);
+}
+static inline bool operator==(const error_code& lhs, const error_condition& rhs) noexcept {
+       return lhs.category().equivalent(lhs.value(),rhs) || rhs.category().equivalent(lhs,rhs.value());
+}
+static inline bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept {
+       return !(lhs == rhs);
+}
+static inline bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept {
+       return !(lhs == rhs);
+}
+
+
+
+};     // namespace std
+
+#endif
+
+// vim: ft=cpp
+