[thirdparty/gcc.git] / libstdc++-v3 / include / std / array

// <array> -*- C++ -*-

// Copyright (C) 2007-2022 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file include/array
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_ARRAY
#define _GLIBCXX_ARRAY 1

#pragma GCC system_header

#if __cplusplus < 201103L
# include <bits/c++0x_warning.h>
#else

#include <compare>
#include <initializer_list>

#include <type_traits>
#include <bits/functexcept.h>
#include <bits/stl_algobase.h>
#include <bits/range_access.h> // std::begin, std::end etc.
#include <bits/utility.h>      // std::index_sequence, std::tuple_size
#include <debug/assertions.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<typename _Tp, std::size_t _Nm>
    struct __array_traits
    {
      typedef _Tp _Type[_Nm];
      typedef __is_swappable<_Tp> _Is_swappable;
      typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;

      static constexpr _Tp&
      _S_ref(const _Type& __t, std::size_t __n) noexcept
      { return const_cast<_Tp&>(__t[__n]); }

      static constexpr _Tp*
      _S_ptr(const _Type& __t) noexcept
      { return const_cast<_Tp*>(__t); }
    };

 template<typename _Tp>
   struct __array_traits<_Tp, 0>
   {
     struct _Type { };
     typedef true_type _Is_swappable;
     typedef true_type _Is_nothrow_swappable;

     static constexpr _Tp&
     _S_ref(const _Type&, std::size_t) noexcept
     { return *static_cast<_Tp*>(nullptr); }

     static constexpr _Tp*
     _S_ptr(const _Type&) noexcept
     { return nullptr; }
   };

  /**
   *  @brief A standard container for storing a fixed size sequence of elements.
   *
   *  @ingroup sequences
   *
   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
   *  <a href="tables.html#66">reversible container</a>, and a
   *  <a href="tables.html#67">sequence</a>.
   *
   *  Sets support random access iterators.
   *
   *  @tparam  Tp  Type of element. Required to be a complete type.
   *  @tparam  Nm  Number of elements.
  */
  template<typename _Tp, std::size_t _Nm>
    struct array
    {
      typedef _Tp 	    			      value_type;
      typedef value_type*			      pointer;
      typedef const value_type*                       const_pointer;
      typedef value_type&                   	      reference;
      typedef const value_type&             	      const_reference;
      typedef value_type*          		      iterator;
      typedef const value_type*			      const_iterator;
      typedef std::size_t                    	      size_type;
      typedef std::ptrdiff_t                   	      difference_type;
      typedef std::reverse_iterator<iterator>	      reverse_iterator;
      typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;

      // Support for zero-sized arrays mandatory.
      typedef __array_traits<_Tp, _Nm> _AT_Type;
      typename _AT_Type::_Type                         _M_elems;

      // No explicit construct/copy/destroy for aggregate type.

      // DR 776.
      _GLIBCXX20_CONSTEXPR void
      fill(const value_type& __u)
      { std::fill_n(begin(), size(), __u); }

      _GLIBCXX20_CONSTEXPR void
      swap(array& __other)
      noexcept(_AT_Type::_Is_nothrow_swappable::value)
      { std::swap_ranges(begin(), end(), __other.begin()); }

      // Iterators.
      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR iterator
      begin() noexcept
      { return iterator(data()); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR const_iterator
      begin() const noexcept
      { return const_iterator(data()); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR iterator
      end() noexcept
      { return iterator(data() + _Nm); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR const_iterator
      end() const noexcept
      { return const_iterator(data() + _Nm); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR const_iterator
      cbegin() const noexcept
      { return const_iterator(data()); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR const_iterator
      cend() const noexcept
      { return const_iterator(data() + _Nm); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }

      // Capacity.
      [[__nodiscard__]]
      constexpr size_type
      size() const noexcept { return _Nm; }

      [[__nodiscard__]]
      constexpr size_type
      max_size() const noexcept { return _Nm; }

      [[__nodiscard__]]
      constexpr bool
      empty() const noexcept { return size() == 0; }

      // Element access.
      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR reference
      operator[](size_type __n) noexcept
      {
	__glibcxx_requires_subscript(__n);
	return _AT_Type::_S_ref(_M_elems, __n);
      }

      [[__nodiscard__]]
      constexpr const_reference
      operator[](size_type __n) const noexcept
      {
#if __cplusplus >= 201402L
	__glibcxx_requires_subscript(__n);
#endif
	return _AT_Type::_S_ref(_M_elems, __n);
      }

      _GLIBCXX17_CONSTEXPR reference
      at(size_type __n)
      {
	if (__n >= _Nm)
	  std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) "
					    ">= _Nm (which is %zu)"),
					__n, _Nm);
	return _AT_Type::_S_ref(_M_elems, __n);
      }

      constexpr const_reference
      at(size_type __n) const
      {
	// Result of conditional expression must be an lvalue so use
	// boolean ? lvalue : (throw-expr, lvalue)
	return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
	  : (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) "
					       ">= _Nm (which is %zu)"),
					   __n, _Nm),
	     _AT_Type::_S_ref(_M_elems, 0));
      }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR reference
      front() noexcept
      {
	__glibcxx_requires_nonempty();
	return *begin();
      }

      [[__nodiscard__]]
      constexpr const_reference
      front() const noexcept
      {
#if __cplusplus >= 201402L
	__glibcxx_requires_nonempty();
#endif
	return _AT_Type::_S_ref(_M_elems, 0);
      }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR reference
      back() noexcept
      {
	__glibcxx_requires_nonempty();
	return _Nm ? *(end() - 1) : *end();
      }

      [[__nodiscard__]]
      constexpr const_reference
      back() const noexcept
      {
#if __cplusplus >= 201402L
	__glibcxx_requires_nonempty();
#endif
	return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
 	           : _AT_Type::_S_ref(_M_elems, 0);
      }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR pointer
      data() noexcept
      { return _AT_Type::_S_ptr(_M_elems); }

      [[__nodiscard__]]
      _GLIBCXX17_CONSTEXPR const_pointer
      data() const noexcept
      { return _AT_Type::_S_ptr(_M_elems); }
    };

#if __cpp_deduction_guides >= 201606
  template<typename _Tp, typename... _Up>
    array(_Tp, _Up...)
      -> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>,
	       1 + sizeof...(_Up)>;
#endif

  // Array comparisons.
  template<typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    _GLIBCXX20_CONSTEXPR
    inline bool
    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return std::equal(__one.begin(), __one.end(), __two.begin()); }

#if __cpp_lib_three_way_comparison && __cpp_lib_concepts
  template<typename _Tp, size_t _Nm>
    [[nodiscard]]
    constexpr __detail::__synth3way_t<_Tp>
    operator<=>(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
    {
      if constexpr (_Nm && __is_memcmp_ordered<_Tp>::__value)
	if (!std::__is_constant_evaluated())
	  {
	    constexpr size_t __n = _Nm * sizeof(_Tp);
	    return __builtin_memcmp(__a.data(), __b.data(), __n) <=> 0;
	  }

      for (size_t __i = 0; __i < _Nm; ++__i)
	{
	  auto __c = __detail::__synth3way(__a[__i], __b[__i]);
	  if (__c != 0)
	    return __c;
	}
      return strong_ordering::equal;
    }
#else
  template<typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    _GLIBCXX20_CONSTEXPR
    inline bool
    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return !(__one == __two); }

  template<typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    _GLIBCXX20_CONSTEXPR
    inline bool
    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
    {
      return std::lexicographical_compare(__a.begin(), __a.end(),
					  __b.begin(), __b.end());
    }

  template<typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    _GLIBCXX20_CONSTEXPR
    inline bool
    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return __two < __one; }

  template<typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    _GLIBCXX20_CONSTEXPR
    inline bool
    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return !(__one > __two); }

  template<typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    _GLIBCXX20_CONSTEXPR
    inline bool
    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return !(__one < __two); }
#endif // three_way_comparison && concepts

  // Specialized algorithms.
  template<typename _Tp, std::size_t _Nm>
    _GLIBCXX20_CONSTEXPR
    inline
#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
    // Constrained free swap overload, see p0185r1
    typename enable_if<
      __array_traits<_Tp, _Nm>::_Is_swappable::value
    >::type
#else
    void
#endif
    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
    noexcept(noexcept(__one.swap(__two)))
    { __one.swap(__two); }

#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
  template<typename _Tp, std::size_t _Nm>
    typename enable_if<
      !__array_traits<_Tp, _Nm>::_Is_swappable::value>::type
    swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;
#endif

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr _Tp&
    get(array<_Tp, _Nm>& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return __array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr _Tp&&
    get(array<_Tp, _Nm>&& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::move(std::get<_Int>(__arr));
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr const _Tp&
    get(const array<_Tp, _Nm>& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return __array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr const _Tp&&
    get(const array<_Tp, _Nm>&& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::move(std::get<_Int>(__arr));
    }

#if __cplusplus > 201703L
#define __cpp_lib_to_array 201907L

  template<bool _Move = false, typename _Tp, size_t... _Idx>
    constexpr array<remove_cv_t<_Tp>, sizeof...(_Idx)>
    __to_array(_Tp (&__a)[sizeof...(_Idx)], index_sequence<_Idx...>)
    {
      if constexpr (_Move)
	return {{std::move(__a[_Idx])...}};
      else
	return {{__a[_Idx]...}};
    }

  template<typename _Tp, size_t _Nm>
    [[nodiscard]]
    constexpr array<remove_cv_t<_Tp>, _Nm>
    to_array(_Tp (&__a)[_Nm])
    noexcept(is_nothrow_constructible_v<_Tp, _Tp&>)
    {
      static_assert(!is_array_v<_Tp>);
      static_assert(is_constructible_v<_Tp, _Tp&>);
      if constexpr (is_constructible_v<_Tp, _Tp&>)
	return __to_array(__a, make_index_sequence<_Nm>{});
      __builtin_unreachable(); // FIXME: see PR c++/91388
    }

  template<typename _Tp, size_t _Nm>
    [[nodiscard]]
    constexpr array<remove_cv_t<_Tp>, _Nm>
    to_array(_Tp (&&__a)[_Nm])
    noexcept(is_nothrow_move_constructible_v<_Tp>)
    {
      static_assert(!is_array_v<_Tp>);
      static_assert(is_move_constructible_v<_Tp>);
      if constexpr (is_move_constructible_v<_Tp>)
	return __to_array<1>(__a, make_index_sequence<_Nm>{});
      __builtin_unreachable(); // FIXME: see PR c++/91388
    }
#endif // C++20

  // Tuple interface to class template array.

  /// Partial specialization for std::array
  template<typename _Tp, size_t _Nm>
    struct tuple_size<array<_Tp, _Nm>>
    : public integral_constant<size_t, _Nm> { };

  /// Partial specialization for std::array
  template<size_t _Ind, typename _Tp, size_t _Nm>
    struct tuple_element<_Ind, array<_Tp, _Nm>>
    {
      static_assert(_Ind < _Nm, "array index is in range");
      using type = _Tp;
    };

#if __cplusplus >= 201703L
  template<typename _Tp, size_t _Nm>
    inline constexpr size_t tuple_size_v<array<_Tp, _Nm>> = _Nm;

  template<typename _Tp, size_t _Nm>
    inline constexpr size_t tuple_size_v<const array<_Tp, _Nm>> = _Nm;
#endif

  template<typename _Tp, size_t _Nm>
    struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
    { };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++11

#endif // _GLIBCXX_ARRAY
Commit	Line	Data
af13a7a6 BK	1	// <array> -- C++ --
af13a7a6 BK	2
7adcbafe	3	// Copyright (C) 2007-2022 Free Software Foundation, Inc.
af13a7a6 BK	4	//
	5	// This file is part of the GNU ISO C++ Library. This library is free
	6	// software; you can redistribute it and/or modify it under the
	7	// terms of the GNU General Public License as published by the
748086b7	8	// Free Software Foundation; either version 3, or (at your option)
af13a7a6 BK	9	// any later version.
	10
	11	// This library is distributed in the hope that it will be useful,
	12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	// GNU General Public License for more details.
	15
748086b7 JJ	16	// Under Section 7 of GPL version 3, you are granted additional
	17	// permissions described in the GCC Runtime Library Exception, version
	18	// 3.1, as published by the Free Software Foundation.
af13a7a6	19
748086b7 JJ	20	// You should have received a copy of the GNU General Public License and
	21	// a copy of the GCC Runtime Library Exception along with this program;
	22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
	23	// <http://www.gnu.org/licenses/>.
af13a7a6 BK	24
	25	/** @file include/array
	26	* This is a Standard C++ Library header.
	27	*/
	28
4514bed6 BK	29	#ifndef _GLIBCXX_ARRAY
4514bed6 BK	30	#define _GLIBCXX_ARRAY 1
af13a7a6 BK	31
	32	#pragma GCC system_header
	33
734f5023	34	#if __cplusplus < 201103L
ab65a4c7	35	# include <bits/c++0x_warning.h>
57317d2a	36	#else
af13a7a6	37
261d5a4a JW	38	#include <compare>
	39	#include <initializer_list>
	40
	41	#include <type_traits>
beb0086f	42	#include <bits/functexcept.h>
e133ace8	43	#include <bits/stl_algobase.h>
261d5a4a JW	44	#include <bits/range_access.h> // std::begin, std::end etc.
261d5a4a JW	45	#include <bits/utility.h> // std::index_sequence, std::tuple_size
6db08247	46	#include <debug/assertions.h>
e133ace8	47
12ffa228 BK	48	namespace std _GLIBCXX_VISIBILITY(default)
12ffa228 BK	49	{
6db08247	50	_GLIBCXX_BEGIN_NAMESPACE_VERSION
53dc5044	51
90f9c94e PC	52	template<typename _Tp, std::size_t _Nm>
	53	struct __array_traits
	54	{
	55	typedef _Tp _Type[_Nm];
6b9539e2 DK	56	typedef __is_swappable<_Tp> _Is_swappable;
6b9539e2 DK	57	typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;
90f9c94e PC	58
	59	static constexpr _Tp&
	60	_S_ref(const _Type& __t, std::size_t __n) noexcept
	61	{ return const_cast<_Tp&>(__t[__n]); }
6a344b95 JW	62
	63	static constexpr _Tp*
	64	_S_ptr(const _Type& __t) noexcept
	65	{ return const_cast<_Tp*>(__t); }
90f9c94e PC	66	};
	67
	68	template<typename _Tp>
	69	struct __array_traits<_Tp, 0>
	70	{
	71	struct _Type { };
6b9539e2 DK	72	typedef true_type _Is_swappable;
6b9539e2 DK	73	typedef true_type _Is_nothrow_swappable;
90f9c94e PC	74
	75	static constexpr _Tp&
	76	_S_ref(const _Type&, std::size_t) noexcept
	77	{ return static_cast<_Tp>(nullptr); }
6a344b95 JW	78
	79	static constexpr _Tp*
	80	_S_ptr(const _Type&) noexcept
	81	{ return nullptr; }
90f9c94e PC	82	};
90f9c94e PC	83
53dc5044 PC	84	/**
	85	* @brief A standard container for storing a fixed size sequence of elements.
	86	*
	87	* @ingroup sequences
	88	*
	89	* Meets the requirements of a <a href="tables.html#65">container</a>, a
	90	* <a href="tables.html#66">reversible container</a>, and a
	91	* <a href="tables.html#67">sequence</a>.
	92	*
	93	* Sets support random access iterators.
	94	*
d632488a	95	* @tparam Tp Type of element. Required to be a complete type.
cb0de9b6	96	* @tparam Nm Number of elements.
53dc5044 PC	97	*/
	98	template<typename _Tp, std::size_t _Nm>
	99	struct array
	100	{
	101	typedef _Tp value_type;
a7d0c94e BK	102	typedef value_type* pointer;
a7d0c94e BK	103	typedef const value_type* const_pointer;
53dc5044 PC	104	typedef value_type& reference;
	105	typedef const value_type& const_reference;
	106	typedef value_type* iterator;
	107	typedef const value_type* const_iterator;
	108	typedef std::size_t size_type;
	109	typedef std::ptrdiff_t difference_type;
	110	typedef std::reverse_iterator<iterator> reverse_iterator;
	111	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
	112
	113	// Support for zero-sized arrays mandatory.
6db08247	114	typedef __array_traits<_Tp, _Nm> _AT_Type;
0611ce44	115	typename _AT_Type::_Type _M_elems;
53dc5044 PC	116
	117	// No explicit construct/copy/destroy for aggregate type.
	118
	119	// DR 776.
1c09b664	120	_GLIBCXX20_CONSTEXPR void
53dc5044 PC	121	fill(const value_type& __u)
	122	{ std::fill_n(begin(), size(), __u); }
	123
1c09b664	124	_GLIBCXX20_CONSTEXPR void
53dc5044	125	swap(array& __other)
6b9539e2	126	noexcept(_AT_Type::_Is_nothrow_swappable::value)
53dc5044 PC	127	{ std::swap_ranges(begin(), end(), __other.begin()); }
	128
	129	// Iterators.
0d04fe49	130	[[__nodiscard__]]
06db9920	131	_GLIBCXX17_CONSTEXPR iterator
18eeaec4	132	begin() noexcept
a7d0c94e	133	{ return iterator(data()); }
53dc5044	134
0d04fe49	135	[[__nodiscard__]]
06db9920	136	_GLIBCXX17_CONSTEXPR const_iterator
18eeaec4	137	begin() const noexcept
a7d0c94e	138	{ return const_iterator(data()); }
53dc5044	139
0d04fe49	140	[[__nodiscard__]]
06db9920	141	_GLIBCXX17_CONSTEXPR iterator
18eeaec4	142	end() noexcept
a7d0c94e	143	{ return iterator(data() + _Nm); }
53dc5044	144
0d04fe49	145	[[__nodiscard__]]
06db9920	146	_GLIBCXX17_CONSTEXPR const_iterator
18eeaec4	147	end() const noexcept
a7d0c94e	148	{ return const_iterator(data() + _Nm); }
53dc5044	149
0d04fe49	150	[[__nodiscard__]]
06db9920	151	_GLIBCXX17_CONSTEXPR reverse_iterator
18eeaec4	152	rbegin() noexcept
53dc5044 PC	153	{ return reverse_iterator(end()); }
53dc5044 PC	154
0d04fe49	155	[[__nodiscard__]]
06db9920	156	_GLIBCXX17_CONSTEXPR const_reverse_iterator
18eeaec4	157	rbegin() const noexcept
53dc5044 PC	158	{ return const_reverse_iterator(end()); }
53dc5044 PC	159
0d04fe49	160	[[__nodiscard__]]
06db9920	161	_GLIBCXX17_CONSTEXPR reverse_iterator
18eeaec4	162	rend() noexcept
53dc5044 PC	163	{ return reverse_iterator(begin()); }
53dc5044 PC	164
0d04fe49	165	[[__nodiscard__]]
06db9920	166	_GLIBCXX17_CONSTEXPR const_reverse_iterator
18eeaec4	167	rend() const noexcept
53dc5044 PC	168	{ return const_reverse_iterator(begin()); }
53dc5044 PC	169
0d04fe49	170	[[__nodiscard__]]
06db9920	171	_GLIBCXX17_CONSTEXPR const_iterator
18eeaec4	172	cbegin() const noexcept
90f9c94e	173	{ return const_iterator(data()); }
53dc5044	174
0d04fe49	175	[[__nodiscard__]]
06db9920	176	_GLIBCXX17_CONSTEXPR const_iterator
18eeaec4	177	cend() const noexcept
90f9c94e	178	{ return const_iterator(data() + _Nm); }
53dc5044	179
0d04fe49	180	[[__nodiscard__]]
06db9920	181	_GLIBCXX17_CONSTEXPR const_reverse_iterator
18eeaec4	182	crbegin() const noexcept
53dc5044 PC	183	{ return const_reverse_iterator(end()); }
53dc5044 PC	184
0d04fe49	185	[[__nodiscard__]]
06db9920	186	_GLIBCXX17_CONSTEXPR const_reverse_iterator
18eeaec4	187	crend() const noexcept
53dc5044 PC	188	{ return const_reverse_iterator(begin()); }
	189
	190	// Capacity.
0d04fe49	191	[[__nodiscard__]]
33ac58d5	192	constexpr size_type
18eeaec4	193	size() const noexcept { return _Nm; }
53dc5044	194
0d04fe49	195	[[__nodiscard__]]
33ac58d5	196	constexpr size_type
18eeaec4	197	max_size() const noexcept { return _Nm; }
53dc5044	198
0d04fe49 JW	199	[[__nodiscard__]]
0d04fe49 JW	200	constexpr bool
18eeaec4	201	empty() const noexcept { return size() == 0; }
53dc5044 PC	202
53dc5044 PC	203	// Element access.
0d04fe49	204	[[__nodiscard__]]
06db9920	205	_GLIBCXX17_CONSTEXPR reference
b4efa80e	206	operator[](size_type __n) noexcept
6db08247 FD	207	{
	208	__glibcxx_requires_subscript(__n);
	209	return _AT_Type::_S_ref(_M_elems, __n);
	210	}
53dc5044	211
0d04fe49	212	[[__nodiscard__]]
bfef3a71 BK	213	constexpr const_reference
bfef3a71 BK	214	operator[](size_type __n) const noexcept
6db08247	215	{
91cfacc4	216	#if __cplusplus >= 201402L
6db08247	217	__glibcxx_requires_subscript(__n);
91cfacc4	218	#endif
6db08247 FD	219	return _AT_Type::_S_ref(_M_elems, __n);
6db08247 FD	220	}
53dc5044	221
06db9920	222	_GLIBCXX17_CONSTEXPR reference
53dc5044 PC	223	at(size_type __n)
	224	{
	225	if (__n >= _Nm)
9779c871 PP	226	std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) "
	227	">= _Nm (which is %zu)"),
	228	__n, _Nm);
90f9c94e	229	return _AT_Type::_S_ref(_M_elems, __n);
53dc5044 PC	230	}
53dc5044 PC	231
bfef3a71	232	constexpr const_reference
53dc5044 PC	233	at(size_type __n) const
53dc5044 PC	234	{
885e8121 JW	235	// Result of conditional expression must be an lvalue so use
885e8121 JW	236	// boolean ? lvalue : (throw-expr, lvalue)
90f9c94e	237	return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
9779c871 PP	238	: (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) "
	239	">= _Nm (which is %zu)"),
	240	__n, _Nm),
90f9c94e	241	_AT_Type::_S_ref(_M_elems, 0));
9bc13c23	242	}
53dc5044	243
0d04fe49	244	[[__nodiscard__]]
06db9920	245	_GLIBCXX17_CONSTEXPR reference
b4efa80e	246	front() noexcept
6db08247 FD	247	{
	248	__glibcxx_requires_nonempty();
	249	return *begin();
	250	}
53dc5044	251
0d04fe49	252	[[__nodiscard__]]
33ac58d5	253	constexpr const_reference
b4efa80e	254	front() const noexcept
6db08247	255	{
91cfacc4	256	#if __cplusplus >= 201402L
6db08247	257	__glibcxx_requires_nonempty();
91cfacc4	258	#endif
6db08247 FD	259	return _AT_Type::_S_ref(_M_elems, 0);
6db08247 FD	260	}
53dc5044	261
0d04fe49	262	[[__nodiscard__]]
06db9920	263	_GLIBCXX17_CONSTEXPR reference
b4efa80e	264	back() noexcept
6db08247 FD	265	{
	266	__glibcxx_requires_nonempty();
	267	return _Nm ? (end() - 1) : end();
	268	}
53dc5044	269
0d04fe49	270	[[__nodiscard__]]
33ac58d5	271	constexpr const_reference
b4efa80e	272	back() const noexcept
33ac58d5	273	{
91cfacc4	274	#if __cplusplus >= 201402L
6db08247	275	__glibcxx_requires_nonempty();
91cfacc4	276	#endif
33ac58d5	277	return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
0611ce44	278	: _AT_Type::_S_ref(_M_elems, 0);
a9ba8ba5	279	}
53dc5044	280
0d04fe49	281	[[__nodiscard__]]
06db9920	282	_GLIBCXX17_CONSTEXPR pointer
18eeaec4	283	data() noexcept
6a344b95	284	{ return _AT_Type::_S_ptr(_M_elems); }
53dc5044	285
0d04fe49	286	[[__nodiscard__]]
06db9920	287	_GLIBCXX17_CONSTEXPR const_pointer
18eeaec4	288	data() const noexcept
6a344b95	289	{ return _AT_Type::_S_ptr(_M_elems); }
53dc5044 PC	290	};
53dc5044 PC	291
af181c91 JW	292	#if __cpp_deduction_guides >= 201606
	293	template<typename _Tp, typename... _Up>
	294	array(_Tp, _Up...)
	295	-> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>,
	296	1 + sizeof...(_Up)>;
	297	#endif
	298
53dc5044 PC	299	// Array comparisons.
53dc5044 PC	300	template<typename _Tp, std::size_t _Nm>
0d04fe49	301	[[__nodiscard__]]
3a66e68a	302	_GLIBCXX20_CONSTEXPR
33ac58d5	303	inline bool
53dc5044 PC	304	operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
	305	{ return std::equal(__one.begin(), __one.end(), __two.begin()); }
	306
3a4cc628 JW	307	#if __cpp_lib_three_way_comparison && __cpp_lib_concepts
3a4cc628 JW	308	template<typename _Tp, size_t _Nm>
0d04fe49	309	[[nodiscard]]
3a4cc628 JW	310	constexpr __detail::__synth3way_t<_Tp>
	311	operator<=>(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
	312	{
2f983fa6	313	if constexpr (_Nm && __is_memcmp_ordered<_Tp>::__value)
74d14778	314	if (!std::__is_constant_evaluated())
2f983fa6 JW	315	{
	316	constexpr size_t __n = _Nm * sizeof(_Tp);
	317	return __builtin_memcmp(__a.data(), __b.data(), __n) <=> 0;
	318	}
2f983fa6 JW	319
2f983fa6 JW	320	for (size_t __i = 0; __i < _Nm; ++__i)
3a4cc628	321	{
2f983fa6 JW	322	auto __c = __detail::__synth3way(__a[__i], __b[__i]);
	323	if (__c != 0)
	324	return __c;
3a4cc628 JW	325	}
	326	return strong_ordering::equal;
	327	}
	328	#else
53dc5044	329	template<typename _Tp, std::size_t _Nm>
0d04fe49	330	[[__nodiscard__]]
3a66e68a	331	_GLIBCXX20_CONSTEXPR
53dc5044 PC	332	inline bool
	333	operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
	334	{ return !(__one == __two); }
	335
	336	template<typename _Tp, std::size_t _Nm>
0d04fe49	337	[[__nodiscard__]]
3a66e68a	338	_GLIBCXX20_CONSTEXPR
53dc5044 PC	339	inline bool
53dc5044 PC	340	operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
33ac58d5	341	{
53dc5044	342	return std::lexicographical_compare(__a.begin(), __a.end(),
33ac58d5	343	__b.begin(), __b.end());
53dc5044 PC	344	}
	345
	346	template<typename _Tp, std::size_t _Nm>
0d04fe49	347	[[__nodiscard__]]
3a66e68a	348	_GLIBCXX20_CONSTEXPR
53dc5044 PC	349	inline bool
	350	operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
	351	{ return __two < __one; }
	352
	353	template<typename _Tp, std::size_t _Nm>
0d04fe49	354	[[__nodiscard__]]
3a66e68a	355	_GLIBCXX20_CONSTEXPR
53dc5044 PC	356	inline bool
	357	operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
	358	{ return !(__one > __two); }
	359
	360	template<typename _Tp, std::size_t _Nm>
0d04fe49	361	[[__nodiscard__]]
3a66e68a	362	_GLIBCXX20_CONSTEXPR
53dc5044 PC	363	inline bool
	364	operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
	365	{ return !(__one < __two); }
3a4cc628	366	#endif // three_way_comparison && concepts
53dc5044	367
18eeaec4	368	// Specialized algorithms.
53dc5044	369	template<typename _Tp, std::size_t _Nm>
1c09b664	370	_GLIBCXX20_CONSTEXPR
6b9539e2 DK	371	inline
	372	#if __cplusplus > 201402L \|\| !defined(__STRICT_ANSI__) // c++1z or gnu++11
	373	// Constrained free swap overload, see p0185r1
	374	typename enable_if<
6db08247	375	__array_traits<_Tp, _Nm>::_Is_swappable::value
6b9539e2 DK	376	>::type
	377	#else
	378	void
	379	#endif
53dc5044	380	swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
18eeaec4	381	noexcept(noexcept(__one.swap(__two)))
53dc5044 PC	382	{ __one.swap(__two); }
53dc5044 PC	383
a2863bde VV	384	#if __cplusplus > 201402L \|\| !defined(__STRICT_ANSI__) // c++1z or gnu++11
a2863bde VV	385	template<typename _Tp, std::size_t _Nm>
a2863bde	386	typename enable_if<
6db08247	387	!__array_traits<_Tp, _Nm>::_Is_swappable::value>::type
a2863bde VV	388	swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;
	389	#endif
	390
53dc5044	391	template<std::size_t _Int, typename _Tp, std::size_t _Nm>
0d04fe49	392	[[__nodiscard__]]
9480716c	393	constexpr _Tp&
18eeaec4	394	get(array<_Tp, _Nm>& __arr) noexcept
9771644a	395	{
3c040fa4	396	static_assert(_Int < _Nm, "array index is within bounds");
6db08247	397	return __array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
9771644a	398	}
53dc5044	399
18eeaec4	400	template<std::size_t _Int, typename _Tp, std::size_t _Nm>
0d04fe49	401	[[__nodiscard__]]
9480716c	402	constexpr _Tp&&
18eeaec4	403	get(array<_Tp, _Nm>&& __arr) noexcept
9771644a	404	{
3c040fa4	405	static_assert(_Int < _Nm, "array index is within bounds");
6db08247	406	return std::move(std::get<_Int>(__arr));
9771644a	407	}
18eeaec4	408
53dc5044	409	template<std::size_t _Int, typename _Tp, std::size_t _Nm>
0d04fe49	410	[[__nodiscard__]]
9480716c	411	constexpr const _Tp&
18eeaec4	412	get(const array<_Tp, _Nm>& __arr) noexcept
9771644a	413	{
3c040fa4	414	static_assert(_Int < _Nm, "array index is within bounds");
6db08247	415	return __array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
9771644a	416	}
53dc5044	417
ccbbf8df	418	template<std::size_t _Int, typename _Tp, std::size_t _Nm>
0d04fe49	419	[[__nodiscard__]]
ccbbf8df VV	420	constexpr const _Tp&&
	421	get(const array<_Tp, _Nm>&& __arr) noexcept
	422	{
	423	static_assert(_Int < _Nm, "array index is within bounds");
6db08247	424	return std::move(std::get<_Int>(__arr));
ccbbf8df VV	425	}
ccbbf8df VV	426
cb0de9b6 JW	427	#if __cplusplus > 201703L
	428	#define __cpp_lib_to_array 201907L
	429
	430	template<bool _Move = false, typename _Tp, size_t... _Idx>
	431	constexpr array<remove_cv_t<_Tp>, sizeof...(_Idx)>
	432	__to_array(_Tp (&__a)[sizeof...(_Idx)], index_sequence<_Idx...>)
	433	{
	434	if constexpr (_Move)
	435	return {{std::move(__a[_Idx])...}};
	436	else
	437	return {{__a[_Idx]...}};
	438	}
	439
	440	template<typename _Tp, size_t _Nm>
0d04fe49	441	[[nodiscard]]
cb0de9b6 JW	442	constexpr array<remove_cv_t<_Tp>, _Nm>
	443	to_array(_Tp (&__a)[_Nm])
	444	noexcept(is_nothrow_constructible_v<_Tp, _Tp&>)
	445	{
	446	static_assert(!is_array_v<_Tp>);
	447	static_assert(is_constructible_v<_Tp, _Tp&>);
	448	if constexpr (is_constructible_v<_Tp, _Tp&>)
6db08247	449	return __to_array(__a, make_index_sequence<_Nm>{});
cb0de9b6 JW	450	__builtin_unreachable(); // FIXME: see PR c++/91388
	451	}
	452
	453	template<typename _Tp, size_t _Nm>
0d04fe49	454	[[nodiscard]]
cb0de9b6 JW	455	constexpr array<remove_cv_t<_Tp>, _Nm>
	456	to_array(_Tp (&&__a)[_Nm])
	457	noexcept(is_nothrow_move_constructible_v<_Tp>)
	458	{
	459	static_assert(!is_array_v<_Tp>);
	460	static_assert(is_move_constructible_v<_Tp>);
	461	if constexpr (is_move_constructible_v<_Tp>)
6db08247	462	return __to_array<1>(__a, make_index_sequence<_Nm>{});
cb0de9b6 JW	463	__builtin_unreachable(); // FIXME: see PR c++/91388
	464	}
	465	#endif // C++20
	466
741aacaf PC	467	// Tuple interface to class template array.
741aacaf PC	468
3a004764	469	/// Partial specialization for std::array
261d5a4a	470	template<typename _Tp, size_t _Nm>
6db08247	471	struct tuple_size<array<_Tp, _Nm>>
261d5a4a	472	: public integral_constant<size_t, _Nm> { };
741aacaf	473
3a004764	474	/// Partial specialization for std::array
261d5a4a JW	475	template<size_t _Ind, typename _Tp, size_t _Nm>
261d5a4a JW	476	struct tuple_element<_Ind, array<_Tp, _Nm>>
741aacaf	477	{
261d5a4a JW	478	static_assert(_Ind < _Nm, "array index is in range");
261d5a4a JW	479	using type = _Tp;
741aacaf PC	480	};
741aacaf PC	481
09aab7e6 JW	482	#if __cplusplus >= 201703L
	483	template<typename _Tp, size_t _Nm>
	484	inline constexpr size_t tuple_size_v<array<_Tp, _Nm>> = _Nm;
	485
	486	template<typename _Tp, size_t _Nm>
	487	inline constexpr size_t tuple_size_v<const array<_Tp, _Nm>> = _Nm;
	488	#endif
	489
261d5a4a	490	template<typename _Tp, size_t _Nm>
6db08247	491	struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
7d17de7f FD	492	{ };
7d17de7f FD	493
741aacaf PC	494	_GLIBCXX_END_NAMESPACE_VERSION
	495	} // namespace std
	496
734f5023	497	#endif // C++11
57317d2a	498
4514bed6	499	#endif // _GLIBCXX_ARRAY