Index: third_party/libcxx/include/optional |
=================================================================== |
--- third_party/libcxx/include/optional (revision 0) |
+++ third_party/libcxx/include/optional (revision 0) |
@@ -0,0 +1,697 @@ |
+// -*- C++ -*- |
+//===-------------------------- optional ----------------------------------===// |
+// |
+// The LLVM Compiler Infrastructure |
+// |
+// This file is dual licensed under the MIT and the University of Illinois Open |
+// Source Licenses. See LICENSE.TXT for details. |
+// |
+//===----------------------------------------------------------------------===// |
+ |
+#ifndef _LIBCPP_OPTIONAL |
+#define _LIBCPP_OPTIONAL |
+ |
+/* |
+ optional synopsis |
+ |
+// C++1y |
+ |
+#include <initializer_list> |
+ |
+namespace std |
+{ |
+ |
+// optional for object types |
+template <class T> |
+class optional |
+{ |
+public: |
+ typedef T value_type; |
+ |
+ // constructors |
+ constexpr optional() noexcept; |
+ constexpr optional(nullopt_t) noexcept; |
+ optional(const optional&); |
+ optional(optional&&) noexcept(is_nothrow_move_constructible<T>::value); |
+ constexpr optional(const T&); |
+ constexpr optional(T&&); |
+ template <class... Args> constexpr explicit optional(in_place_t, Args&&...); |
+ template <class U, class... Args> |
+ constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...); |
+ |
+ // destructor |
+ ~optional(); |
+ |
+ // assignment |
+ optional& operator=(nullopt_t) noexcept; |
+ optional& operator=(const optional&); |
+ optional& operator=(optional&&) |
+ noexcept(is_nothrow_move_assignable<T>::value && |
+ is_nothrow_move_constructible<T>::value); |
+ template <class U> optional& operator=(U&&); |
+ template <class... Args> void emplace(Args&&...); |
+ template <class U, class... Args> void emplace(initializer_list<U>, Args&&...); |
+ |
+ // swap |
+ void swap(optional&) |
+ noexcept(is_nothrow_move_constructible<T>::value && |
+ noexcept(swap(declval<T&>(), declval<T&>()))); |
+ |
+ // observers |
+ constexpr T const* operator->() const; |
+ T* operator->(); |
+ constexpr T const& operator*() const; |
+ T& operator*(); |
+ constexpr explicit operator bool() const noexcept; |
+ constexpr T const& value() const; |
+ T& value(); |
+ template <class U> constexpr T value_or(U&&) const&; |
+ template <class U> T value_or(U&&) &&; |
+}; |
+ |
+// In-place construction |
+struct in_place_t{}; |
+constexpr in_place_t in_place{}; |
+ |
+// Disengaged state indicator |
+struct nullopt_t{see below}; |
+constexpr nullopt_t nullopt(unspecified); |
+ |
+// class bad_optional_access |
+class bad_optional_access |
+ : public logic_error |
+{ |
+public: |
+ explicit bad_optional_access(const string& what_arg); |
+ explicit bad_optional_access(const char* what_arg); |
+}; |
+ |
+// Relational operators |
+template <class T> constexpr bool operator==(const optional<T>&, const optional<T>&); |
+template <class T> constexpr bool operator< (const optional<T>&, const optional<T>&); |
+ |
+// Comparison with nullopt |
+template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept; |
+template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept; |
+template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept; |
+template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept; |
+ |
+// Comparison with T |
+template <class T> constexpr bool operator==(const optional<T>&, const T&); |
+template <class T> constexpr bool operator==(const T&, const optional<T>&); |
+template <class T> constexpr bool operator<(const optional<T>&, const T&); |
+template <class T> constexpr bool operator<(const T&, const optional<T>&); |
+ |
+// Specialized algorithms |
+template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below); |
+template <class T> constexpr optional<typename decay<T>::type> make_optional(T&&); |
+ |
+// hash support |
+template <class T> struct hash; |
+template <class T> struct hash<optional<T>>; |
+ |
+} // std |
+ |
+*/ |
+ |
+#include <__config> |
+#include <functional> |
+#include <stdexcept> |
+ |
+namespace std // purposefully not using versioning namespace |
+{ |
+ |
+class _LIBCPP_EXCEPTION_ABI bad_optional_access |
+ : public logic_error |
+{ |
+public: |
+#if _LIBCPP_STD_VER > 11 |
+ _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const string& __arg) |
+ : logic_error(__arg) {} |
+ _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const char* __arg) |
+ : logic_error(__arg) {} |
+ _LIBCPP_INLINE_VISIBILITY bad_optional_access(const bad_optional_access&) noexcept = default; |
+ _LIBCPP_INLINE_VISIBILITY bad_optional_access& operator=(const bad_optional_access&) noexcept = default; |
+#else |
+private: |
+ bad_optional_access(const bad_optional_access&); |
+ bad_optional_access& operator=(const bad_optional_access&); |
+public: |
+#endif // _LIBCPP_STD_VER > 11 |
+ // Get the key function ~bad_optional_access() into the dylib even if not compiling for C++1y |
+ virtual ~bad_optional_access() _NOEXCEPT; |
+}; |
+ |
+} // std |
+ |
+#if _LIBCPP_STD_VER > 11 |
+ |
+#include <initializer_list> |
+#include <type_traits> |
+#include <new> |
+#include <__functional_base> |
+ |
+#include <__undef_min_max> |
+ |
+#ifdef _LIBCPP_DEBUG |
+# include <__debug> |
+#else |
+# define _LIBCPP_ASSERT(x, m) ((void)0) |
+#endif |
+ |
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
+#pragma GCC system_header |
+#endif |
+ |
+_LIBCPP_BEGIN_NAMESPACE_STD |
+ |
+struct in_place_t {}; |
+constexpr in_place_t in_place{}; |
+ |
+struct nullopt_t |
+{ |
+ explicit constexpr nullopt_t(int) noexcept {} |
+}; |
+ |
+constexpr nullopt_t nullopt{0}; |
+ |
+template <class _Tp, bool = is_trivially_destructible<_Tp>::value> |
+class __optional_storage |
+{ |
+protected: |
+ typedef _Tp value_type; |
+ union |
+ { |
+ char __null_state_; |
+ value_type __val_; |
+ }; |
+ bool __engaged_ = false; |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ ~__optional_storage() |
+ { |
+ if (__engaged_) |
+ __val_.~value_type(); |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr __optional_storage() noexcept |
+ : __null_state_('\0') {} |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ __optional_storage(const __optional_storage& __x) |
+ : __engaged_(__x.__engaged_) |
+ { |
+ if (__engaged_) |
+ ::new(_VSTD::addressof(__val_)) value_type(__x.__val_); |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ __optional_storage(__optional_storage&& __x) |
+ noexcept(is_nothrow_move_constructible<value_type>::value) |
+ : __engaged_(__x.__engaged_) |
+ { |
+ if (__engaged_) |
+ ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_)); |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr __optional_storage(const value_type& __v) |
+ : __val_(__v), |
+ __engaged_(true) {} |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr __optional_storage(value_type&& __v) |
+ : __val_(_VSTD::move(__v)), |
+ __engaged_(true) {} |
+ |
+ template <class... _Args> |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr |
+ explicit __optional_storage(in_place_t, _Args&&... __args) |
+ : __val_(_VSTD::forward<_Args>(__args)...), |
+ __engaged_(true) {} |
+}; |
+ |
+template <class _Tp> |
+class __optional_storage<_Tp, true> |
+{ |
+protected: |
+ typedef _Tp value_type; |
+ union |
+ { |
+ char __null_state_; |
+ value_type __val_; |
+ }; |
+ bool __engaged_ = false; |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr __optional_storage() noexcept |
+ : __null_state_('\0') {} |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ __optional_storage(const __optional_storage& __x) |
+ : __engaged_(__x.__engaged_) |
+ { |
+ if (__engaged_) |
+ ::new(_VSTD::addressof(__val_)) value_type(__x.__val_); |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ __optional_storage(__optional_storage&& __x) |
+ noexcept(is_nothrow_move_constructible<value_type>::value) |
+ : __engaged_(__x.__engaged_) |
+ { |
+ if (__engaged_) |
+ ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_)); |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr __optional_storage(const value_type& __v) |
+ : __val_(__v), |
+ __engaged_(true) {} |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr __optional_storage(value_type&& __v) |
+ : __val_(_VSTD::move(__v)), |
+ __engaged_(true) {} |
+ |
+ template <class... _Args> |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr |
+ explicit __optional_storage(in_place_t, _Args&&... __args) |
+ : __val_(_VSTD::forward<_Args>(__args)...), |
+ __engaged_(true) {} |
+}; |
+ |
+template <class _Tp> |
+class optional |
+ : private __optional_storage<_Tp> |
+{ |
+ typedef __optional_storage<_Tp> __base; |
+public: |
+ typedef _Tp value_type; |
+ |
+ static_assert(!is_reference<value_type>::value, |
+ "Instantiation of optional with a reference type is ill-formed."); |
+ static_assert(!is_same<typename remove_cv<value_type>::type, in_place_t>::value, |
+ "Instantiation of optional with a in_place_t type is ill-formed."); |
+ static_assert(!is_same<typename remove_cv<value_type>::type, nullopt_t>::value, |
+ "Instantiation of optional with a nullopt_t type is ill-formed."); |
+ static_assert(is_object<value_type>::value, |
+ "Instantiation of optional with a non-object type is undefined behavior."); |
+ static_assert(is_nothrow_destructible<value_type>::value, |
+ "Instantiation of optional with an object type that is not noexcept destructible is undefined behavior."); |
+ |
+ _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {} |
+ _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default; |
+ _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default; |
+ _LIBCPP_INLINE_VISIBILITY ~optional() = default; |
+ _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {} |
+ _LIBCPP_INLINE_VISIBILITY constexpr optional(const value_type& __v) |
+ : __base(__v) {} |
+ _LIBCPP_INLINE_VISIBILITY constexpr optional(value_type&& __v) |
+ : __base(_VSTD::move(__v)) {} |
+ |
+ template <class... _Args, |
+ class = typename enable_if |
+ < |
+ is_constructible<value_type, _Args...>::value |
+ >::type |
+ > |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr |
+ explicit optional(in_place_t, _Args&&... __args) |
+ : __base(in_place, _VSTD::forward<_Args>(__args)...) {} |
+ |
+ template <class _Up, class... _Args, |
+ class = typename enable_if |
+ < |
+ is_constructible<value_type, initializer_list<_Up>&, _Args...>::value |
+ >::type |
+ > |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr |
+ explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) |
+ : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ optional& operator=(nullopt_t) noexcept |
+ { |
+ if (this->__engaged_) |
+ { |
+ this->__val_.~value_type(); |
+ this->__engaged_ = false; |
+ } |
+ return *this; |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ optional& |
+ operator=(const optional& __opt) |
+ { |
+ if (this->__engaged_ == __opt.__engaged_) |
+ { |
+ if (this->__engaged_) |
+ this->__val_ = __opt.__val_; |
+ } |
+ else |
+ { |
+ if (this->__engaged_) |
+ this->__val_.~value_type(); |
+ else |
+ ::new(_VSTD::addressof(this->__val_)) value_type(__opt.__val_); |
+ this->__engaged_ = __opt.__engaged_; |
+ } |
+ return *this; |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ optional& |
+ operator=(optional&& __opt) |
+ noexcept(is_nothrow_move_assignable<value_type>::value && |
+ is_nothrow_move_constructible<value_type>::value) |
+ { |
+ if (this->__engaged_ == __opt.__engaged_) |
+ { |
+ if (this->__engaged_) |
+ this->__val_ = _VSTD::move(__opt.__val_); |
+ } |
+ else |
+ { |
+ if (this->__engaged_) |
+ this->__val_.~value_type(); |
+ else |
+ ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_)); |
+ this->__engaged_ = __opt.__engaged_; |
+ } |
+ return *this; |
+ } |
+ |
+ template <class _Up, |
+ class = typename enable_if |
+ < |
+ is_same<typename remove_reference<_Up>::type, value_type>::value && |
+ is_constructible<value_type, _Up>::value && |
+ is_assignable<value_type&, _Up>::value |
+ >::type |
+ > |
+ _LIBCPP_INLINE_VISIBILITY |
+ optional& |
+ operator=(_Up&& __v) |
+ { |
+ if (this->__engaged_) |
+ this->__val_ = _VSTD::forward<_Up>(__v); |
+ else |
+ { |
+ ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v)); |
+ this->__engaged_ = true; |
+ } |
+ return *this; |
+ } |
+ |
+ template <class... _Args, |
+ class = typename enable_if |
+ < |
+ is_constructible<value_type, _Args...>::value |
+ >::type |
+ > |
+ _LIBCPP_INLINE_VISIBILITY |
+ void |
+ emplace(_Args&&... __args) |
+ { |
+ *this = nullopt; |
+ ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); |
+ this->__engaged_ = true; |
+ } |
+ |
+ template <class _Up, class... _Args, |
+ class = typename enable_if |
+ < |
+ is_constructible<value_type, initializer_list<_Up>&, _Args...>::value |
+ >::type |
+ > |
+ _LIBCPP_INLINE_VISIBILITY |
+ void |
+ emplace(initializer_list<_Up> __il, _Args&&... __args) |
+ { |
+ *this = nullopt; |
+ ::new(_VSTD::addressof(this->__val_)) value_type(__il, _VSTD::forward<_Args>(__args)...); |
+ this->__engaged_ = true; |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ void |
+ swap(optional& __opt) |
+ noexcept(is_nothrow_move_constructible<value_type>::value && |
+ __is_nothrow_swappable<value_type>::value) |
+ { |
+ using _VSTD::swap; |
+ if (this->__engaged_ == __opt.__engaged_) |
+ { |
+ if (this->__engaged_) |
+ swap(this->__val_, __opt.__val_); |
+ } |
+ else |
+ { |
+ if (this->__engaged_) |
+ { |
+ ::new(_VSTD::addressof(__opt.__val_)) value_type(_VSTD::move(this->__val_)); |
+ this->__val_.~value_type(); |
+ } |
+ else |
+ { |
+ ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_)); |
+ __opt.__val_.~value_type(); |
+ } |
+ swap(this->__engaged_, __opt.__engaged_); |
+ } |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr |
+ value_type const* |
+ operator->() const |
+ { |
+ _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value"); |
+ return __operator_arrow(__has_operator_addressof<value_type>{}); |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ value_type* |
+ operator->() |
+ { |
+ _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value"); |
+ return _VSTD::addressof(this->__val_); |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr |
+ const value_type& |
+ operator*() const |
+ { |
+ _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value"); |
+ return this->__val_; |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ value_type& |
+ operator*() |
+ { |
+ _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value"); |
+ return this->__val_; |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr explicit operator bool() const noexcept {return this->__engaged_;} |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr value_type const& value() const |
+ { |
+ if (!this->__engaged_) |
+ throw bad_optional_access("optional<T>::value: not engaged"); |
+ return this->__val_; |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ value_type& value() |
+ { |
+ if (!this->__engaged_) |
+ throw bad_optional_access("optional<T>::value: not engaged"); |
+ return this->__val_; |
+ } |
+ |
+ template <class _Up> |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr value_type value_or(_Up&& __v) const& |
+ { |
+ static_assert(is_copy_constructible<value_type>::value, |
+ "optional<T>::value_or: T must be copy constructible"); |
+ static_assert(is_convertible<_Up, value_type>::value, |
+ "optional<T>::value_or: U must be convertible to T"); |
+ return this->__engaged_ ? this->__val_ : |
+ static_cast<value_type>(_VSTD::forward<_Up>(__v)); |
+ } |
+ |
+ template <class _Up> |
+ _LIBCPP_INLINE_VISIBILITY |
+ value_type value_or(_Up&& __v) && |
+ { |
+ static_assert(is_move_constructible<value_type>::value, |
+ "optional<T>::value_or: T must be move constructible"); |
+ static_assert(is_convertible<_Up, value_type>::value, |
+ "optional<T>::value_or: U must be convertible to T"); |
+ return this->__engaged_ ? _VSTD::move(this->__val_) : |
+ static_cast<value_type>(_VSTD::forward<_Up>(__v)); |
+ } |
+ |
+private: |
+ _LIBCPP_INLINE_VISIBILITY |
+ value_type const* |
+ __operator_arrow(true_type) const |
+ { |
+ return _VSTD::addressof(this->__val_); |
+ } |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ constexpr |
+ value_type const* |
+ __operator_arrow(false_type) const |
+ { |
+ return &this->__val_; |
+ } |
+}; |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator==(const optional<_Tp>& __x, const optional<_Tp>& __y) |
+{ |
+ if (static_cast<bool>(__x) != static_cast<bool>(__y)) |
+ return false; |
+ if (!static_cast<bool>(__x)) |
+ return true; |
+ return *__x == *__y; |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator<(const optional<_Tp>& __x, const optional<_Tp>& __y) |
+{ |
+ if (!static_cast<bool>(__y)) |
+ return false; |
+ if (!static_cast<bool>(__x)) |
+ return true; |
+ return less<_Tp>{}(*__x, *__y); |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator==(const optional<_Tp>& __x, nullopt_t) noexcept |
+{ |
+ return !static_cast<bool>(__x); |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator==(nullopt_t, const optional<_Tp>& __x) noexcept |
+{ |
+ return !static_cast<bool>(__x); |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator<(const optional<_Tp>&, nullopt_t) noexcept |
+{ |
+ return false; |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator<(nullopt_t, const optional<_Tp>& __x) noexcept |
+{ |
+ return static_cast<bool>(__x); |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator==(const optional<_Tp>& __x, const _Tp& __v) |
+{ |
+ return static_cast<bool>(__x) ? *__x == __v : false; |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator==(const _Tp& __v, const optional<_Tp>& __x) |
+{ |
+ return static_cast<bool>(__x) ? *__x == __v : false; |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator<(const optional<_Tp>& __x, const _Tp& __v) |
+{ |
+ return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true; |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+bool |
+operator<(const _Tp& __v, const optional<_Tp>& __x) |
+{ |
+ return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false; |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+void |
+swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) |
+{ |
+ __x.swap(__y); |
+} |
+ |
+template <class _Tp> |
+inline _LIBCPP_INLINE_VISIBILITY |
+constexpr |
+optional<typename decay<_Tp>::type> |
+make_optional(_Tp&& __v) |
+{ |
+ return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v)); |
+} |
+ |
+template <class _Tp> |
+struct _LIBCPP_TYPE_VIS_ONLY hash<optional<_Tp> > |
+{ |
+ typedef optional<_Tp> argument_type; |
+ typedef size_t result_type; |
+ |
+ _LIBCPP_INLINE_VISIBILITY |
+ result_type operator()(const argument_type& __opt) const _NOEXCEPT |
+ { |
+ return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0; |
+ } |
+}; |
+ |
+_LIBCPP_END_NAMESPACE_STD |
+ |
+#endif // _LIBCPP_STD_VER > 11 |
+ |
+#endif // _LIBCPP_ARRAY |