includes are removed based on the language version used. Incidental transitive
inclusions of the following headers have been removed:
- - C++2b: ``atomic``, ``bit``, ``cstdint``, ``cstdlib``, ``cstring``, ``initializer_list``, ``new``, ``stdexcept``,
- ``type_traits``, ``typeinfo``
+ - C++2b: ``atomic``, ``bit``, ``cstdint``, ``cstdlib``, ``cstring``, ``initializer_list``, ``limits``, ``new``,
+ ``stdexcept``, ``system_error``, ``type_traits``, ``typeinfo``
- The headers ``<experimental/algorithm>`` and ``<experimental/functional>`` have been removed, since all the contents
have been implemented in namespace ``std`` for at least two releases.
__support/xlocale/__nop_locale_mgmt.h
__support/xlocale/__posix_l_fallback.h
__support/xlocale/__strtonum_fallback.h
+ __system_error/error_category.h
+ __system_error/error_code.h
+ __system_error/error_condition.h
+ __system_error/system_error.h
__thread/poll_with_backoff.h
__thread/timed_backoff_policy.h
__threading_support
#include <__config>
#include <__mutex/mutex.h>
#include <__mutex/unique_lock.h>
+#include <__system_error/system_error.h>
#include <__threading_support>
#include <__type_traits/enable_if.h>
#include <__type_traits/is_floating_point.h>
#include <__utility/move.h>
#include <ratio>
-#include <system_error>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__availability>
#include <__chrono/time_point.h>
+#include <__compare/ordering.h>
#include <__config>
#include <__errc>
#include <__filesystem/file_status.h>
#include <__filesystem/operations.h>
#include <__filesystem/path.h>
#include <__filesystem/perms.h>
+#include <__system_error/error_code.h>
+#include <__utility/move.h>
#include <__utility/unreachable.h>
#include <cstdint>
#include <iosfwd>
-#include <system_error>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__memory/shared_ptr.h>
#include <__ranges/enable_borrowed_range.h>
#include <__ranges/enable_view.h>
+#include <__system_error/error_code.h>
+#include <__utility/move.h>
#include <cstddef>
-#include <system_error>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__config>
#include <__filesystem/path.h>
#include <__memory/shared_ptr.h>
+#include <__system_error/error_code.h>
+#include <__system_error/system_error.h>
#include <__utility/forward.h>
#include <__verbose_abort>
#include <iosfwd>
#include <new>
-#include <system_error>
+#include <string>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__filesystem/perm_options.h>
#include <__filesystem/perms.h>
#include <__filesystem/space_info.h>
+#include <__system_error/error_code.h>
#include <cstdint>
-#include <system_error>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__memory/shared_ptr.h>
#include <__ranges/enable_borrowed_range.h>
#include <__ranges/enable_view.h>
+#include <__system_error/error_code.h>
+#include <__utility/move.h>
#include <cstddef>
-#include <system_error>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#include <__config>
#include <__memory/addressof.h>
#include <__mutex/tag_types.h>
+#include <__system_error/system_error.h>
#include <__utility/swap.h>
-#include <system_error>
+#include <cerrno>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
--- /dev/null
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___SYSTEM_ERROR_ERROR_CATEGORY_H
+#define _LIBCPP___SYSTEM_ERROR_ERROR_CATEGORY_H
+
+#include <__compare/ordering.h>
+#include <__config>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_TYPE_VIS error_condition;
+class _LIBCPP_TYPE_VIS error_code;
+
+class _LIBCPP_HIDDEN __do_message;
+
+class _LIBCPP_TYPE_VIS error_category
+{
+public:
+ virtual ~error_category() _NOEXCEPT;
+
+#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
+ error_category() noexcept;
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ _LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
+#endif
+ error_category(const error_category&) = delete;
+ error_category& operator=(const error_category&) = delete;
+
+ virtual const char* name() const _NOEXCEPT = 0;
+ virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
+ virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
+ virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
+ virtual string message(int __ev) const = 0;
+
+ _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
+
+#if _LIBCPP_STD_VER >= 20
+
+ _LIBCPP_HIDE_FROM_ABI
+ strong_ordering operator<=>(const error_category& __rhs) const noexcept {return compare_three_way()(this, std::addressof(__rhs));}
+
+#else // _LIBCPP_STD_VER >= 20
+
+ _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
+
+ _LIBCPP_INLINE_VISIBILITY
+ bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
+
+#endif // _LIBCPP_STD_VER >= 20
+
+ friend class _LIBCPP_HIDDEN __do_message;
+};
+
+class _LIBCPP_HIDDEN __do_message
+ : public error_category
+{
+public:
+ string message(int __ev) const override;
+};
+
+_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
+_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CATEGORY_H
--- /dev/null
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H
+#define _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H
+
+#include <__compare/ordering.h>
+#include <__config>
+#include <__errc>
+#include <__functional/hash.h>
+#include <__functional/unary_function.h>
+#include <__system_error/error_category.h>
+#include <__system_error/error_condition.h>
+#include <cstddef>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
+ : public false_type {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
+#endif
+
+namespace __adl_only {
+ // Those cause ADL to trigger but they are not viable candidates,
+ // so they are never actually selected.
+ void make_error_code() = delete;
+} // namespace __adl_only
+
+class _LIBCPP_TYPE_VIS error_code
+{
+ int __val_;
+ const error_category* __cat_;
+public:
+ _LIBCPP_INLINE_VISIBILITY
+ error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ error_code(int __val, const error_category& __cat) _NOEXCEPT
+ : __val_(__val), __cat_(&__cat) {}
+
+ template <class _Ep>
+ _LIBCPP_INLINE_VISIBILITY
+ error_code(_Ep __e,
+ typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr
+ ) _NOEXCEPT
+ {
+ using __adl_only::make_error_code;
+ *this = make_error_code(__e);
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ void assign(int __val, const error_category& __cat) _NOEXCEPT
+ {
+ __val_ = __val;
+ __cat_ = &__cat;
+ }
+
+ template <class _Ep>
+ _LIBCPP_INLINE_VISIBILITY
+ typename enable_if
+ <
+ is_error_code_enum<_Ep>::value,
+ error_code&
+ >::type
+ operator=(_Ep __e) _NOEXCEPT
+ {
+ using __adl_only::make_error_code;
+ *this = make_error_code(__e);
+ return *this;
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ void clear() _NOEXCEPT
+ {
+ __val_ = 0;
+ __cat_ = &system_category();
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ int value() const _NOEXCEPT {return __val_;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ const error_category& category() const _NOEXCEPT {return *__cat_;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ error_condition default_error_condition() const _NOEXCEPT
+ {return __cat_->default_error_condition(__val_);}
+
+ string message() const;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
+};
+
+inline _LIBCPP_INLINE_VISIBILITY
+error_code
+make_error_code(errc __e) _NOEXCEPT
+{
+ return error_code(static_cast<int>(__e), generic_category());
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
+{
+ return __x.category() == __y.category() && __x.value() == __y.value();
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
+{
+ return __x.category().equivalent(__x.value(), __y)
+ || __y.category().equivalent(__x, __y.value());
+}
+
+#if _LIBCPP_STD_VER <= 17
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
+{
+ return __y == __x;
+}
+#endif
+
+#if _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
+{
+ return __x.category() < __y.category()
+ || (__x.category() == __y.category() && __x.value() < __y.value());
+}
+
+#else // _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_HIDE_FROM_ABI strong_ordering
+operator<=>(const error_code& __x, const error_code& __y) noexcept
+{
+ if (auto __c = __x.category() <=> __y.category(); __c != 0)
+ return __c;
+ return __x.value() <=> __y.value();
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<error_code>
+ : public __unary_function<error_code, size_t>
+{
+ _LIBCPP_INLINE_VISIBILITY
+ size_t operator()(const error_code& __ec) const _NOEXCEPT
+ {
+ return static_cast<size_t>(__ec.value());
+ }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H
--- /dev/null
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H
+#define _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H
+
+#include <__compare/ordering.h>
+#include <__config>
+#include <__errc>
+#include <__functional/unary_function.h>
+#include <__system_error/error_category.h>
+#include <cstddef>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
+ : public false_type {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
+#endif
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
+ : true_type { };
+
+#ifdef _LIBCPP_CXX03_LANG
+template <>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
+ : true_type { };
+#endif
+
+namespace __adl_only {
+ // Those cause ADL to trigger but they are not viable candidates,
+ // so they are never actually selected.
+ void make_error_condition() = delete;
+} // namespace __adl_only
+
+class _LIBCPP_TYPE_VIS error_condition
+{
+ int __val_;
+ const error_category* __cat_;
+public:
+ _LIBCPP_INLINE_VISIBILITY
+ error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ error_condition(int __val, const error_category& __cat) _NOEXCEPT
+ : __val_(__val), __cat_(&__cat) {}
+
+ template <class _Ep>
+ _LIBCPP_INLINE_VISIBILITY
+ error_condition(_Ep __e,
+ typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr
+ ) _NOEXCEPT
+ {
+ using __adl_only::make_error_condition;
+ *this = make_error_condition(__e);
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ void assign(int __val, const error_category& __cat) _NOEXCEPT
+ {
+ __val_ = __val;
+ __cat_ = &__cat;
+ }
+
+ template <class _Ep>
+ _LIBCPP_INLINE_VISIBILITY
+ typename enable_if
+ <
+ is_error_condition_enum<_Ep>::value,
+ error_condition&
+ >::type
+ operator=(_Ep __e) _NOEXCEPT
+ {
+ using __adl_only::make_error_condition;
+ *this = make_error_condition(__e);
+ return *this;
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ void clear() _NOEXCEPT
+ {
+ __val_ = 0;
+ __cat_ = &generic_category();
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ int value() const _NOEXCEPT {return __val_;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ const error_category& category() const _NOEXCEPT {return *__cat_;}
+ string message() const;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
+};
+
+inline _LIBCPP_INLINE_VISIBILITY
+error_condition
+make_error_condition(errc __e) _NOEXCEPT
+{
+ return error_condition(static_cast<int>(__e), generic_category());
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+{
+ return __x.category() == __y.category() && __x.value() == __y.value();
+}
+
+#if _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+{
+ return __x.category() < __y.category()
+ || (__x.category() == __y.category() && __x.value() < __y.value());
+}
+
+
+#else // _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_HIDE_FROM_ABI strong_ordering
+operator<=>(const error_condition& __x, const error_condition& __y) noexcept
+{
+ if (auto __c = __x.category() <=> __y.category(); __c != 0)
+ return __c;
+ return __x.value() <=> __y.value();
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
+ : public __unary_function<error_condition, size_t>
+{
+ _LIBCPP_INLINE_VISIBILITY
+ size_t operator()(const error_condition& __ec) const _NOEXCEPT
+ {
+ return static_cast<size_t>(__ec.value());
+ }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H
--- /dev/null
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H
+#define _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H
+
+#include <__config>
+#include <__system_error/error_category.h>
+#include <__system_error/error_code.h>
+#include <stdexcept>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_TYPE_VIS system_error
+ : public runtime_error
+{
+ error_code __ec_;
+public:
+ system_error(error_code __ec, const string& __what_arg);
+ system_error(error_code __ec, const char* __what_arg);
+ system_error(error_code __ec);
+ system_error(int __ev, const error_category& __ecat, const string& __what_arg);
+ system_error(int __ev, const error_category& __ecat, const char* __what_arg);
+ system_error(int __ev, const error_category& __ecat);
+ system_error(const system_error&) _NOEXCEPT = default;
+ ~system_error() _NOEXCEPT override;
+
+ _LIBCPP_INLINE_VISIBILITY
+ const error_code& code() const _NOEXCEPT {return __ec_;}
+
+private:
+ static string __init(const error_code&, string);
+};
+
+_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
+void __throw_system_error(int __ev, const char* __what_arg);
+
+
+_LIBCPP_END_NAMESPACE_STD
+#endif // _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H
# include <initializer_list>
# include <new>
# include <stdexcept>
+# include <system_error>
# include <type_traits>
# include <typeinfo>
#endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <concepts>
# include <cstdlib>
+# include <system_error>
#endif
#endif // _LIBCPP_FILESYSTEM
#include <__chrono/time_point.h>
#include <__config>
#include <__exception/exception_ptr.h>
+#include <__memory/allocator.h>
#include <__memory/allocator_arg_t.h>
#include <__memory/allocator_destructor.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
#include <__memory/shared_ptr.h>
#include <__memory/unique_ptr.h>
#include <__memory/uses_allocator.h>
+#include <__system_error/error_category.h>
+#include <__system_error/error_code.h>
+#include <__system_error/error_condition.h>
#include <__type_traits/aligned_storage.h>
#include <__type_traits/alignment_of.h>
#include <__type_traits/strip_signature.h>
#include <__utility/move.h>
#include <mutex>
#include <new>
-#include <system_error>
+#include <stdexcept>
#include <thread>
#include <version>
# include <atomic>
# include <cstdlib>
# include <exception>
+# include <system_error>
#endif
#endif // _LIBCPP_FUTURE
#include <__assert> // all public C++ headers provide the assertion handler
#include <__ios/fpos.h>
#include <__locale>
+#include <__system_error/error_category.h>
+#include <__system_error/error_code.h>
+#include <__system_error/error_condition.h>
+#include <__system_error/system_error.h>
#include <__utility/swap.h>
#include <__verbose_abort>
-#include <system_error>
#include <version>
// standard-mandated includes
# include <limits>
# include <new>
# include <stdexcept>
+# include <system_error>
# include <type_traits>
# include <typeinfo>
#endif
{ include: [ "@<__ranges/.*>", "private", "<ranges>", "public" ] },
{ include: [ "@<__string/.*>", "private", "<string>", "public" ] },
{ include: [ "@<__support/.*>", "private", "<support>", "public" ] },
+ { include: [ "@<__system_error/.*>", "private", "<system_error>", "public" ] },
{ include: [ "@<__thread/.*>", "private", "<thread>", "public" ] },
{ include: [ "@<__tuple_dir/.*>", "private", "<tuple>", "public" ] },
{ include: [ "@<__type_traits/.*>", "private", "<type_traits>", "public" ] },
#include <__locale>
#include <__memory/unique_ptr.h>
#include <__type_traits/make_unsigned.h>
+#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <ctime>
private header "__format/format_context.h"
export optional
export locale
+ export __locale
}
module format_error { private header "__format/format_error.h" }
module format_functions {
}
module system_error {
header "system_error"
+ export __errc
export *
+ module __system_error {
+ module error_category { private header "__system_error/error_category.h" }
+ module error_code {
+ private header "__system_error/error_code.h"
+ export functional.__functional.hash
+ export functional.__functional.unary_function
+ }
+ module error_condition {
+ private header "__system_error/error_condition.h"
+ export functional.__functional.hash
+ export functional.__functional.unary_function
+ }
+ module system_error { private header "__system_error/system_error.h" }
+ }
}
module thread {
@requires_LIBCXX_ENABLE_THREADS@
# include <initializer_list>
# include <new>
# include <stdexcept>
+# include <system_error>
# include <type_traits>
# include <typeinfo>
#endif
#include <__exception/operations.h>
#include <__memory/shared_ptr.h>
#include <__memory/unique_ptr.h>
+#include <__system_error/error_code.h>
#include <__type_traits/conjunction.h>
#include <__type_traits/enable_if.h>
#include <__type_traits/is_base_of.h>
#include <__mutex/mutex.h>
#include <__mutex/tag_types.h>
#include <__mutex/unique_lock.h>
+#include <__system_error/system_error.h>
#include <__utility/swap.h>
#include <cerrno>
-#include <system_error>
#include <version>
_LIBCPP_PUSH_MACROS
_LIBCPP_POP_MACROS
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <system_error>
+#endif
+
#endif // _LIBCPP_SHARED_MUTEX
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
-#include <__errc>
-#include <__functional/hash.h>
-#include <__functional/unary_function.h>
-#include <__memory/addressof.h>
-#include <stdexcept>
-#include <string>
+#include <__system_error/error_category.h>
+#include <__system_error/error_code.h>
+#include <__system_error/error_condition.h>
+#include <__system_error/system_error.h>
#include <version>
// standard-mandated includes
# pragma GCC system_header
#endif
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// is_error_code_enum
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
- : public false_type {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
-#endif
-
-// is_error_condition_enum
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
- : public false_type {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
-#endif
-
-template <>
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
- : true_type { };
-
-#ifdef _LIBCPP_CXX03_LANG
-template <>
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
- : true_type { };
-#endif
-
-class _LIBCPP_TYPE_VIS error_condition;
-class _LIBCPP_TYPE_VIS error_code;
-
-// class error_category
-
-class _LIBCPP_HIDDEN __do_message;
-
-class _LIBCPP_TYPE_VIS error_category
-{
-public:
- virtual ~error_category() _NOEXCEPT;
-
-#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
- error_category() noexcept;
-#else
- _LIBCPP_INLINE_VISIBILITY
- _LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
-#endif
- error_category(const error_category&) = delete;
- error_category& operator=(const error_category&) = delete;
-
- virtual const char* name() const _NOEXCEPT = 0;
- virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
- virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
- virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
- virtual string message(int __ev) const = 0;
-
- _LIBCPP_INLINE_VISIBILITY
- bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
-
-#if _LIBCPP_STD_VER >= 20
-
- _LIBCPP_HIDE_FROM_ABI
- strong_ordering operator<=>(const error_category& __rhs) const noexcept {return compare_three_way()(this, std::addressof(__rhs));}
-
-#else // _LIBCPP_STD_VER >= 20
-
- _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
-
- _LIBCPP_INLINE_VISIBILITY
- bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
-
-#endif // _LIBCPP_STD_VER >= 20
-
- friend class _LIBCPP_HIDDEN __do_message;
-};
-
-class _LIBCPP_HIDDEN __do_message
- : public error_category
-{
-public:
- string message(int __ev) const override;
-};
-
-_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
-_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
-
-namespace __adl_only {
- // Those cause ADL to trigger but they are not viable candidates,
- // so they are never actually selected.
- void make_error_condition() = delete;
- void make_error_code() = delete;
-} // namespace __adl_only
-
-class _LIBCPP_TYPE_VIS error_condition
-{
- int __val_;
- const error_category* __cat_;
-public:
- _LIBCPP_INLINE_VISIBILITY
- error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
-
- _LIBCPP_INLINE_VISIBILITY
- error_condition(int __val, const error_category& __cat) _NOEXCEPT
- : __val_(__val), __cat_(&__cat) {}
-
- template <class _Ep>
- _LIBCPP_INLINE_VISIBILITY
- error_condition(_Ep __e,
- typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr
- ) _NOEXCEPT
- {
- using __adl_only::make_error_condition;
- *this = make_error_condition(__e);
- }
-
- _LIBCPP_INLINE_VISIBILITY
- void assign(int __val, const error_category& __cat) _NOEXCEPT
- {
- __val_ = __val;
- __cat_ = &__cat;
- }
-
- template <class _Ep>
- _LIBCPP_INLINE_VISIBILITY
- typename enable_if
- <
- is_error_condition_enum<_Ep>::value,
- error_condition&
- >::type
- operator=(_Ep __e) _NOEXCEPT
- {
- using __adl_only::make_error_condition;
- *this = make_error_condition(__e);
- return *this;
- }
-
- _LIBCPP_INLINE_VISIBILITY
- void clear() _NOEXCEPT
- {
- __val_ = 0;
- __cat_ = &generic_category();
- }
-
- _LIBCPP_INLINE_VISIBILITY
- int value() const _NOEXCEPT {return __val_;}
-
- _LIBCPP_INLINE_VISIBILITY
- const error_category& category() const _NOEXCEPT {return *__cat_;}
- string message() const;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
-};
-
-inline _LIBCPP_INLINE_VISIBILITY
-error_condition
-make_error_condition(errc __e) _NOEXCEPT
-{
- return error_condition(static_cast<int>(__e), generic_category());
-}
-
-// error_code
-
-class _LIBCPP_TYPE_VIS error_code
-{
- int __val_;
- const error_category* __cat_;
-public:
- _LIBCPP_INLINE_VISIBILITY
- error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
-
- _LIBCPP_INLINE_VISIBILITY
- error_code(int __val, const error_category& __cat) _NOEXCEPT
- : __val_(__val), __cat_(&__cat) {}
-
- template <class _Ep>
- _LIBCPP_INLINE_VISIBILITY
- error_code(_Ep __e,
- typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr
- ) _NOEXCEPT
- {
- using __adl_only::make_error_code;
- *this = make_error_code(__e);
- }
-
- _LIBCPP_INLINE_VISIBILITY
- void assign(int __val, const error_category& __cat) _NOEXCEPT
- {
- __val_ = __val;
- __cat_ = &__cat;
- }
-
- template <class _Ep>
- _LIBCPP_INLINE_VISIBILITY
- typename enable_if
- <
- is_error_code_enum<_Ep>::value,
- error_code&
- >::type
- operator=(_Ep __e) _NOEXCEPT
- {
- using __adl_only::make_error_code;
- *this = make_error_code(__e);
- return *this;
- }
-
- _LIBCPP_INLINE_VISIBILITY
- void clear() _NOEXCEPT
- {
- __val_ = 0;
- __cat_ = &system_category();
- }
-
- _LIBCPP_INLINE_VISIBILITY
- int value() const _NOEXCEPT {return __val_;}
-
- _LIBCPP_INLINE_VISIBILITY
- const error_category& category() const _NOEXCEPT {return *__cat_;}
-
- _LIBCPP_INLINE_VISIBILITY
- error_condition default_error_condition() const _NOEXCEPT
- {return __cat_->default_error_condition(__val_);}
-
- string message() const;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
-};
-
-inline _LIBCPP_INLINE_VISIBILITY
-error_code
-make_error_code(errc __e) _NOEXCEPT
-{
- return error_code(static_cast<int>(__e), generic_category());
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
-{
- return __x.category() == __y.category() && __x.value() == __y.value();
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
-{
- return __x.category().equivalent(__x.value(), __y)
- || __y.category().equivalent(__x, __y.value());
-}
-
-#if _LIBCPP_STD_VER <= 17
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
-{
- return __y == __x;
-}
-#endif
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
-{
- return __x.category() == __y.category() && __x.value() == __y.value();
-}
-
-#if _LIBCPP_STD_VER <= 17
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
-{
- return __x.category() < __y.category()
- || (__x.category() == __y.category() && __x.value() < __y.value());
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
-{
- return __x.category() < __y.category()
- || (__x.category() == __y.category() && __x.value() < __y.value());
-}
-
-#else // _LIBCPP_STD_VER <= 17
-
-inline _LIBCPP_HIDE_FROM_ABI strong_ordering
-operator<=>(const error_code& __x, const error_code& __y) noexcept
-{
- if (auto __c = __x.category() <=> __y.category(); __c != 0)
- return __c;
- return __x.value() <=> __y.value();
-}
-
-inline _LIBCPP_HIDE_FROM_ABI strong_ordering
-operator<=>(const error_condition& __x, const error_condition& __y) noexcept
-{
- if (auto __c = __x.category() <=> __y.category(); __c != 0)
- return __c;
- return __x.value() <=> __y.value();
-}
-
-#endif // _LIBCPP_STD_VER <= 17
-
-template <>
-struct _LIBCPP_TEMPLATE_VIS hash<error_code>
- : public __unary_function<error_code, size_t>
-{
- _LIBCPP_INLINE_VISIBILITY
- size_t operator()(const error_code& __ec) const _NOEXCEPT
- {
- return static_cast<size_t>(__ec.value());
- }
-};
-
-template <>
-struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
- : public __unary_function<error_condition, size_t>
-{
- _LIBCPP_INLINE_VISIBILITY
- size_t operator()(const error_condition& __ec) const _NOEXCEPT
- {
- return static_cast<size_t>(__ec.value());
- }
-};
-
-// system_error
-
-class _LIBCPP_TYPE_VIS system_error
- : public runtime_error
-{
- error_code __ec_;
-public:
- system_error(error_code __ec, const string& __what_arg);
- system_error(error_code __ec, const char* __what_arg);
- system_error(error_code __ec);
- system_error(int __ev, const error_category& __ecat, const string& __what_arg);
- system_error(int __ev, const error_category& __ecat, const char* __what_arg);
- system_error(int __ev, const error_category& __ecat);
- system_error(const system_error&) _NOEXCEPT = default;
- ~system_error() _NOEXCEPT override;
-
- _LIBCPP_INLINE_VISIBILITY
- const error_code& code() const _NOEXCEPT {return __ec_;}
-
-private:
- static string __init(const error_code&, string);
-};
-
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
-void __throw_system_error(int __ev, const char* __what_arg);
-
-_LIBCPP_END_NAMESPACE_STD
-
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+# include <cstdint>
+# include <cstring>
+# include <limits>
# include <type_traits>
#endif
#include <__format/formatter_integral.h>
#include <__format/parser_std_format_spec.h>
#include <__functional/hash.h>
+#include <__functional/unary_function.h>
#include <__memory/addressof.h>
#include <__memory/unique_ptr.h>
#include <__mutex/mutex.h>
#include <__mutex/unique_lock.h>
+#include <__system_error/system_error.h>
#include <__thread/poll_with_backoff.h>
#include <__thread/timed_backoff_policy.h>
#include <__threading_support>
#include <__utility/forward.h>
#include <cstddef>
+#include <cstdint>
#include <iosfwd>
-#include <system_error>
#include <tuple>
#include <version>
#endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-# include <cstdint>
# include <cstring>
# include <functional>
# include <new>
+# include <system_error>
#endif
#endif // _LIBCPP_THREAD
#define _LARGE_TIME_API
#endif
-#include <cerrno> // errno
+#include <__system_error/system_error.h>
+#include <cerrno> // errno
#include <chrono>
-#include <system_error> // __throw_system_error
#if defined(__MVS__)
#include <__support/ibm/gettod_zos.h> // gettimeofdayMonotonic
#include <condition_variable>
#include <thread>
-#include <system_error>
#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
# pragma comment(lib, "pthread")
#include <ctime>
#include <filesystem>
#include <ratio>
-#include <system_error>
#include <utility>
+#include <system_error>
#if defined(_LIBCPP_WIN32API)
# define WIN32_LEAN_AND_MEAN
#include <__assert>
#include <limits>
#include <mutex>
-#include <system_error>
#include "include/atomic_support.h"
# define _CRT_RAND_S
#endif // defined(_LIBCPP_USING_WIN32_RANDOM)
+#include <__system_error/system_error.h>
#include <limits>
#include <random>
-#include <system_error>
#if defined(__sun__)
# define rename solaris_headers_are_broken
#include <__config>
#include <charconv>
#include <cstring>
-#include <system_error>
#include "include/ryu/common.h"
#include "include/ryu/d2fixed.h"
#include <new>
#include <stdexcept>
#include <string>
-#include <system_error>
#ifdef _LIBCPP_ABI_VCRUNTIME
#include "support/runtime/stdexcept_vcruntime.ipp"
#include <__string/char_traits.h> // expected-error@*:* {{use of private header from outside its module: '__string/char_traits.h'}}
#include <__string/constexpr_c_functions.h> // expected-error@*:* {{use of private header from outside its module: '__string/constexpr_c_functions.h'}}
#include <__string/extern_template_lists.h> // expected-error@*:* {{use of private header from outside its module: '__string/extern_template_lists.h'}}
+#include <__system_error/error_category.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/error_category.h'}}
+#include <__system_error/error_code.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/error_code.h'}}
+#include <__system_error/error_condition.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/error_condition.h'}}
+#include <__system_error/system_error.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/system_error.h'}}
#include <__thread/poll_with_backoff.h> // expected-error@*:* {{use of private header from outside its module: '__thread/poll_with_backoff.h'}}
#include <__thread/timed_backoff_policy.h> // expected-error@*:* {{use of private header from outside its module: '__thread/timed_backoff_policy.h'}}
#include <__tuple_dir/apply_cv.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/apply_cv.h'}}
concepts type_traits
concepts version
condition_variable atomic
+condition_variable cerrno
condition_variable concepts
condition_variable cstddef
condition_variable cstdint
condition_variable new
condition_variable ratio
condition_variable stdexcept
+condition_variable string
condition_variable system_error
condition_variable type_traits
condition_variable typeinfo
functional vector
functional version
future atomic
+future cerrno
future chrono
future cstddef
future cstdint
future new
future ratio
future stdexcept
+future string
future system_error
future thread
future type_traits
list version
locale atomic
locale cctype
+locale cerrno
locale concepts
locale cstdarg
locale cstddef
memory_resource tuple
memory_resource version
mutex atomic
+mutex cerrno
mutex concepts
mutex cstddef
mutex cstdint
mutex new
mutex ratio
mutex stdexcept
+mutex string
mutex system_error
mutex type_traits
mutex typeinfo
optional version
ostream atomic
ostream bitset
+ostream cerrno
ostream concepts
ostream cstddef
ostream cstdint
ostream new
ostream stdexcept
ostream streambuf
+ostream string
ostream type_traits
ostream typeinfo
ostream version
shared_mutex iosfwd
shared_mutex limits
shared_mutex ratio
+shared_mutex stdexcept
+shared_mutex string
shared_mutex system_error
shared_mutex type_traits
shared_mutex version
system_error type_traits
system_error version
thread array
+thread cerrno
thread chrono
thread compare
thread cstddef
thread locale
thread new
thread ratio
+thread stdexcept
thread string
thread string_view
thread system_error
concepts type_traits
concepts version
condition_variable atomic
+condition_variable cerrno
condition_variable concepts
condition_variable cstddef
condition_variable cstdint
condition_variable new
condition_variable ratio
condition_variable stdexcept
+condition_variable string
condition_variable system_error
condition_variable type_traits
condition_variable typeinfo
functional vector
functional version
future atomic
+future cerrno
future chrono
future cstddef
future cstdint
future new
future ratio
future stdexcept
+future string
future system_error
future thread
future type_traits
list version
locale atomic
locale cctype
+locale cerrno
locale concepts
locale cstdarg
locale cstddef
memory_resource tuple
memory_resource version
mutex atomic
+mutex cerrno
mutex concepts
mutex cstddef
mutex cstdint
mutex new
mutex ratio
mutex stdexcept
+mutex string
mutex system_error
mutex tuple
mutex type_traits
optional version
ostream atomic
ostream bitset
+ostream cerrno
ostream concepts
ostream cstddef
ostream cstdint
ostream new
ostream stdexcept
ostream streambuf
+ostream string
ostream type_traits
ostream typeinfo
ostream version
shared_mutex iosfwd
shared_mutex limits
shared_mutex ratio
+shared_mutex stdexcept
+shared_mutex string
shared_mutex system_error
shared_mutex type_traits
shared_mutex version
system_error type_traits
system_error version
thread array
+thread cerrno
thread chrono
thread compare
thread cstddef
thread locale
thread new
thread ratio
+thread stdexcept
thread string
thread string_view
thread system_error
concepts type_traits
concepts version
condition_variable atomic
+condition_variable cerrno
condition_variable concepts
condition_variable cstddef
condition_variable cstdint
condition_variable new
condition_variable ratio
condition_variable stdexcept
+condition_variable string
condition_variable system_error
condition_variable type_traits
condition_variable typeinfo
functional vector
functional version
future atomic
+future cerrno
future chrono
future cstddef
future cstdint
future new
future ratio
future stdexcept
+future string
future system_error
future thread
future type_traits
list version
locale atomic
locale cctype
+locale cerrno
locale concepts
locale cstdarg
locale cstddef
memory_resource tuple
memory_resource version
mutex atomic
+mutex cerrno
mutex concepts
mutex cstddef
mutex cstdint
mutex new
mutex ratio
mutex stdexcept
+mutex string
mutex system_error
mutex tuple
mutex type_traits
optional version
ostream atomic
ostream bitset
+ostream cerrno
ostream concepts
ostream cstddef
ostream cstdint
ostream new
ostream stdexcept
ostream streambuf
+ostream string
ostream type_traits
ostream typeinfo
ostream version
shared_mutex iosfwd
shared_mutex limits
shared_mutex ratio
+shared_mutex stdexcept
+shared_mutex string
shared_mutex system_error
shared_mutex type_traits
shared_mutex version
system_error type_traits
system_error version
thread array
+thread cerrno
thread chrono
thread compare
thread cstddef
thread locale
thread new
thread ratio
+thread stdexcept
thread string
thread string_view
thread system_error
concepts type_traits
concepts version
condition_variable atomic
+condition_variable cerrno
condition_variable concepts
condition_variable cstddef
condition_variable cstdint
condition_variable new
condition_variable ratio
condition_variable stdexcept
+condition_variable string
condition_variable system_error
condition_variable type_traits
condition_variable typeinfo
functional vector
functional version
future atomic
+future cerrno
future chrono
future cstddef
future cstdint
future new
future ratio
future stdexcept
+future string
future system_error
future thread
future type_traits
list version
locale atomic
locale cctype
+locale cerrno
locale concepts
locale cstdarg
locale cstddef
memory_resource tuple
memory_resource version
mutex atomic
+mutex cerrno
mutex concepts
mutex cstddef
mutex cstdint
mutex new
mutex ratio
mutex stdexcept
+mutex string
mutex system_error
mutex tuple
mutex type_traits
optional version
ostream atomic
ostream bitset
+ostream cerrno
ostream concepts
ostream cstddef
ostream cstdint
ostream new
ostream stdexcept
ostream streambuf
+ostream string
ostream type_traits
ostream typeinfo
ostream version
shared_mutex iosfwd
shared_mutex limits
shared_mutex ratio
+shared_mutex stdexcept
+shared_mutex string
shared_mutex system_error
shared_mutex type_traits
shared_mutex version
system_error type_traits
system_error version
thread array
+thread cerrno
thread chrono
thread compare
thread cstddef
thread locale
thread new
thread ratio
+thread stdexcept
thread string
thread string_view
thread system_error
concepts type_traits
concepts version
condition_variable atomic
+condition_variable cerrno
condition_variable concepts
condition_variable cstddef
condition_variable cstdint
condition_variable new
condition_variable ratio
condition_variable stdexcept
+condition_variable string
condition_variable system_error
condition_variable type_traits
condition_variable typeinfo
functional vector
functional version
future atomic
+future cerrno
future cstddef
future cstdint
future cstdlib
future new
future ratio
future stdexcept
+future string
future system_error
future thread
future type_traits
list version
locale atomic
locale cctype
+locale cerrno
locale concepts
locale cstdarg
locale cstddef
memory_resource tuple
memory_resource version
mutex atomic
+mutex cerrno
mutex concepts
mutex cstddef
mutex cstdint
mutex new
mutex ratio
mutex stdexcept
+mutex string
mutex system_error
mutex tuple
mutex type_traits
optional version
ostream atomic
ostream bitset
+ostream cerrno
ostream concepts
ostream cstddef
ostream cstdint
ostream new
ostream stdexcept
ostream streambuf
+ostream string
ostream type_traits
ostream typeinfo
ostream version
shared_mutex iosfwd
shared_mutex limits
shared_mutex ratio
+shared_mutex stdexcept
+shared_mutex string
shared_mutex system_error
shared_mutex type_traits
shared_mutex version
system_error type_traits
system_error version
thread array
+thread cerrno
thread compare
thread cstddef
thread cstdint
complex version
concepts cstddef
concepts version
+condition_variable cerrno
condition_variable cstddef
condition_variable ctime
condition_variable iosfwd
condition_variable new
condition_variable ratio
condition_variable stdexcept
-condition_variable system_error
+condition_variable string
condition_variable typeinfo
condition_variable version
coroutine compare
filesystem ratio
filesystem string
filesystem string_view
-filesystem system_error
filesystem version
format array
format cmath
functional unordered_map
functional vector
functional version
+future cerrno
future cstddef
future cstdint
future cstdlib
future new
future ratio
future stdexcept
-future system_error
+future string
future thread
future typeinfo
future version
ios iosfwd
ios mutex
ios string
-ios system_error
ios version
iosfwd version
iostream ios
list tuple
list version
locale cctype
+locale cerrno
locale cstddef
locale cstdint
locale cstdio
memory_resource stdexcept
memory_resource tuple
memory_resource version
+mutex cerrno
mutex cstddef
mutex cstdint
mutex ctime
mutex new
mutex ratio
mutex stdexcept
-mutex system_error
+mutex string
mutex tuple
mutex typeinfo
mutex version
optional stdexcept
optional version
ostream bitset
+ostream cerrno
ostream cstddef
ostream cstdint
ostream cstring
ostream new
ostream stdexcept
ostream streambuf
+ostream string
ostream typeinfo
ostream version
queue compare
shared_mutex iosfwd
shared_mutex limits
shared_mutex ratio
-shared_mutex system_error
+shared_mutex stdexcept
+shared_mutex string
shared_mutex version
source_location cstdint
source_location version
system_error cerrno
system_error compare
system_error cstddef
-system_error cstdint
-system_error cstring
-system_error limits
system_error stdexcept
system_error string
system_error version
thread array
+thread cerrno
thread compare
thread cstddef
thread cstdint
thread stdexcept
thread string
thread string_view
-thread system_error
thread tuple
thread vector
thread version
// template <class T> constexpr bool is_error_condition_enum_v;
+#include <string>
#include <system_error>
#include <type_traits>
#include "test_macros.h"
#include <system_error>
#include <cassert>
+#include <type_traits>
#include "test_macros.h"
#include <system_error>
#include <cassert>
+#include <type_traits>
#include "test_macros.h"
// throw.
#include <random>
+#include <string>
#include <system_error>
#include <cassert>
#include <random>
#include <cassert>
+#include <string>
#include <system_error>
#include "test_macros.h"
#include <future>
#include <cassert>
+#include <system_error>
#include "test_macros.h"
#include <cstdlib>
#include <mutex>
#include <shared_mutex>
+#include <system_error>
#include <thread>
#include <vector>
#include <shared_mutex>
#include <cassert>
+#include <cerrno>
#include <system_error>
#include "test_macros.h"
#include <chrono>
#include <cstdlib>
#include <mutex>
+#include <system_error>
#include <thread>
#include "make_test_thread.h"
libcxx/include/__support/solaris/xlocale.h
libcxx/include/__support/win32/locale_win32.h
libcxx/include/__support/xlocale/__nop_locale_mgmt.h
-libcxx/include/system_error
+libcxx/include/__system_error/error_category.h
+libcxx/include/__system_error/error_code.h
+libcxx/include/__system_error/error_condition.h
+libcxx/include/__system_error/system_error.h
libcxx/include/thread
libcxx/include/__threading_support
libcxx/include/__thread/poll_with_backoff.h
projects / platform / upstream / llvm.git / commitdiff