Line data    Source code

       1             : // <range_access.h> -*- C++ -*-
       2             : 
       3             : // Copyright (C) 2010-2018 Free Software Foundation, Inc.
       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
       8             : // Free Software Foundation; either version 3, or (at your option)
       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             : 
      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.
      19             : 
      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/>.
      24             : 
      25             : /** @file bits/range_access.h
      26             :  *  This is an internal header file, included by other library headers.
      27             :  *  Do not attempt to use it directly. @headername{iterator}
      28             :  */
      29             : 
      30             : #ifndef _GLIBCXX_RANGE_ACCESS_H
      31             : #define _GLIBCXX_RANGE_ACCESS_H 1
      32             : 
      33             : #pragma GCC system_header
      34             : 
      35             : #if __cplusplus >= 201103L
      36             : #include <initializer_list>
      37             : namespace std _GLIBCXX_VISIBILITY(default)
      38             : {
      39             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      40             : 
      41             :   /**
      42             :    *  @brief  Return an iterator pointing to the first element of
      43             :    *          the container.
      44             :    *  @param  __cont  Container.
      45             :    */
      46             :   template<typename _Container>
      47             :     inline _GLIBCXX17_CONSTEXPR auto
      48          32 :     begin(_Container& __cont) -> decltype(__cont.begin())
      49          32 :     { return __cont.begin(); }
      50             : 
      51             :   /**
      52             :    *  @brief  Return an iterator pointing to the first element of
      53             :    *          the const container.
      54             :    *  @param  __cont  Container.
      55             :    */
      56             :   template<typename _Container>
      57             :     inline _GLIBCXX17_CONSTEXPR auto
      58          14 :     begin(const _Container& __cont) -> decltype(__cont.begin())
      59          14 :     { return __cont.begin(); }
      60             : 
      61             :   /**
      62             :    *  @brief  Return an iterator pointing to one past the last element of
      63             :    *          the container.
      64             :    *  @param  __cont  Container.
      65             :    */
      66             :   template<typename _Container>
      67             :     inline _GLIBCXX17_CONSTEXPR auto
      68          46 :     end(_Container& __cont) -> decltype(__cont.end())
      69          46 :     { return __cont.end(); }
      70             : 
      71             :   /**
      72             :    *  @brief  Return an iterator pointing to one past the last element of
      73             :    *          the const container.
      74             :    *  @param  __cont  Container.
      75             :    */
      76             :   template<typename _Container>
      77             :     inline _GLIBCXX17_CONSTEXPR auto
      78          14 :     end(const _Container& __cont) -> decltype(__cont.end())
      79          14 :     { return __cont.end(); }
      80             : 
      81             :   /**
      82             :    *  @brief  Return an iterator pointing to the first element of the array.
      83             :    *  @param  __arr  Array.
      84             :    */
      85             :   template<typename _Tp, size_t _Nm>
      86             :     inline _GLIBCXX14_CONSTEXPR _Tp*
      87             :     begin(_Tp (&__arr)[_Nm])
      88             :     { return __arr; }
      89             : 
      90             :   /**
      91             :    *  @brief  Return an iterator pointing to one past the last element
      92             :    *          of the array.
      93             :    *  @param  __arr  Array.
      94             :    */
      95             :   template<typename _Tp, size_t _Nm>
      96             :     inline _GLIBCXX14_CONSTEXPR _Tp*
      97             :     end(_Tp (&__arr)[_Nm])
      98             :     { return __arr + _Nm; }
      99             : 
     100             : #if __cplusplus >= 201402L
     101             : 
     102             :   template<typename _Tp> class valarray;
     103             :   // These overloads must be declared for cbegin and cend to use them.
     104             :   template<typename _Tp> _Tp* begin(valarray<_Tp>&);
     105             :   template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
     106             :   template<typename _Tp> _Tp* end(valarray<_Tp>&);
     107             :   template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
     108             : 
     109             :   /**
     110             :    *  @brief  Return an iterator pointing to the first element of
     111             :    *          the const container.
     112             :    *  @param  __cont  Container.
     113             :    */
     114             :   template<typename _Container>
     115             :     inline constexpr auto
     116             :     cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
     117             :       -> decltype(std::begin(__cont))
     118             :     { return std::begin(__cont); }
     119             : 
     120             :   /**
     121             :    *  @brief  Return an iterator pointing to one past the last element of
     122             :    *          the const container.
     123             :    *  @param  __cont  Container.
     124             :    */
     125             :   template<typename _Container>
     126             :     inline constexpr auto
     127             :     cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
     128             :       -> decltype(std::end(__cont))
     129             :     { return std::end(__cont); }
     130             : 
     131             :   /**
     132             :    *  @brief  Return a reverse iterator pointing to the last element of
     133             :    *          the container.
     134             :    *  @param  __cont  Container.
     135             :    */
     136             :   template<typename _Container>
     137             :     inline _GLIBCXX17_CONSTEXPR auto
     138             :     rbegin(_Container& __cont) -> decltype(__cont.rbegin())
     139             :     { return __cont.rbegin(); }
     140             : 
     141             :   /**
     142             :    *  @brief  Return a reverse iterator pointing to the last element of
     143             :    *          the const container.
     144             :    *  @param  __cont  Container.
     145             :    */
     146             :   template<typename _Container>
     147             :     inline _GLIBCXX17_CONSTEXPR auto
     148             :     rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
     149             :     { return __cont.rbegin(); }
     150             : 
     151             :   /**
     152             :    *  @brief  Return a reverse iterator pointing one past the first element of
     153             :    *          the container.
     154             :    *  @param  __cont  Container.
     155             :    */
     156             :   template<typename _Container>
     157             :     inline _GLIBCXX17_CONSTEXPR auto
     158             :     rend(_Container& __cont) -> decltype(__cont.rend())
     159             :     { return __cont.rend(); }
     160             : 
     161             :   /**
     162             :    *  @brief  Return a reverse iterator pointing one past the first element of
     163             :    *          the const container.
     164             :    *  @param  __cont  Container.
     165             :    */
     166             :   template<typename _Container>
     167             :     inline _GLIBCXX17_CONSTEXPR auto
     168             :     rend(const _Container& __cont) -> decltype(__cont.rend())
     169             :     { return __cont.rend(); }
     170             : 
     171             :   /**
     172             :    *  @brief  Return a reverse iterator pointing to the last element of
     173             :    *          the array.
     174             :    *  @param  __arr  Array.
     175             :    */
     176             :   template<typename _Tp, size_t _Nm>
     177             :     inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Tp*>
     178             :     rbegin(_Tp (&__arr)[_Nm])
     179             :     { return reverse_iterator<_Tp*>(__arr + _Nm); }
     180             : 
     181             :   /**
     182             :    *  @brief  Return a reverse iterator pointing one past the first element of
     183             :    *          the array.
     184             :    *  @param  __arr  Array.
     185             :    */
     186             :   template<typename _Tp, size_t _Nm>
     187             :     inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Tp*>
     188             :     rend(_Tp (&__arr)[_Nm])
     189             :     { return reverse_iterator<_Tp*>(__arr); }
     190             : 
     191             :   /**
     192             :    *  @brief  Return a reverse iterator pointing to the last element of
     193             :    *          the initializer_list.
     194             :    *  @param  __il  initializer_list.
     195             :    */
     196             :   template<typename _Tp>
     197             :     inline _GLIBCXX17_CONSTEXPR reverse_iterator<const _Tp*>
     198             :     rbegin(initializer_list<_Tp> __il)
     199             :     { return reverse_iterator<const _Tp*>(__il.end()); }
     200             : 
     201             :   /**
     202             :    *  @brief  Return a reverse iterator pointing one past the first element of
     203             :    *          the initializer_list.
     204             :    *  @param  __il  initializer_list.
     205             :    */
     206             :   template<typename _Tp>
     207             :     inline _GLIBCXX17_CONSTEXPR reverse_iterator<const _Tp*>
     208             :     rend(initializer_list<_Tp> __il)
     209             :     { return reverse_iterator<const _Tp*>(__il.begin()); }
     210             : 
     211             :   /**
     212             :    *  @brief  Return a reverse iterator pointing to the last element of
     213             :    *          the const container.
     214             :    *  @param  __cont  Container.
     215             :    */
     216             :   template<typename _Container>
     217             :     inline _GLIBCXX17_CONSTEXPR auto
     218             :     crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
     219             :     { return std::rbegin(__cont); }
     220             : 
     221             :   /**
     222             :    *  @brief  Return a reverse iterator pointing one past the first element of
     223             :    *          the const container.
     224             :    *  @param  __cont  Container.
     225             :    */
     226             :   template<typename _Container>
     227             :     inline _GLIBCXX17_CONSTEXPR auto
     228             :     crend(const _Container& __cont) -> decltype(std::rend(__cont))
     229             :     { return std::rend(__cont); }
     230             : 
     231             : #endif // C++14
     232             : 
     233             : #if __cplusplus >= 201703L
     234             : #define __cpp_lib_nonmember_container_access 201411
     235             : 
     236             :   /**
     237             :    *  @brief  Return the size of a container.
     238             :    *  @param  __cont  Container.
     239             :    */
     240             :   template <typename _Container>
     241             :     constexpr auto
     242        3386 :     size(const _Container& __cont) noexcept(noexcept(__cont.size()))
     243             :     -> decltype(__cont.size())
     244        3386 :     { return __cont.size(); }
     245             : 
     246             :   /**
     247             :    *  @brief  Return the size of an array.
     248             :    *  @param  __array  Array.
     249             :    */
     250             :   template <typename _Tp, size_t _Nm>
     251             :     constexpr size_t
     252             :     size(const _Tp (&/*__array*/)[_Nm]) noexcept
     253             :     { return _Nm; }
     254             : 
     255             :   /**
     256             :    *  @brief  Return whether a container is empty.
     257             :    *  @param  __cont  Container.
     258             :    */
     259             :   template <typename _Container>
     260             :     [[nodiscard]] constexpr auto
     261             :     empty(const _Container& __cont) noexcept(noexcept(__cont.empty()))
     262             :     -> decltype(__cont.empty())
     263             :     { return __cont.empty(); }
     264             : 
     265             :   /**
     266             :    *  @brief  Return whether an array is empty (always false).
     267             :    *  @param  __array  Container.
     268             :    */
     269             :   template <typename _Tp, size_t _Nm>
     270             :     [[nodiscard]] constexpr bool
     271             :     empty(const _Tp (&/*__array*/)[_Nm]) noexcept
     272             :     { return false; }
     273             : 
     274             :   /**
     275             :    *  @brief  Return whether an initializer_list is empty.
     276             :    *  @param  __il  Initializer list.
     277             :    */
     278             :   template <typename _Tp>
     279             :     [[nodiscard]] constexpr bool
     280             :     empty(initializer_list<_Tp> __il) noexcept
     281             :     { return __il.size() == 0;}
     282             : 
     283             :   /**
     284             :    *  @brief  Return the data pointer of a container.
     285             :    *  @param  __cont  Container.
     286             :    */
     287             :   template <typename _Container>
     288             :     constexpr auto
     289             :     data(_Container& __cont) noexcept(noexcept(__cont.data()))
     290             :     -> decltype(__cont.data())
     291             :     { return __cont.data(); }
     292             : 
     293             :   /**
     294             :    *  @brief  Return the data pointer of a const container.
     295             :    *  @param  __cont  Container.
     296             :    */
     297             :   template <typename _Container>
     298             :     constexpr auto
     299             :     data(const _Container& __cont) noexcept(noexcept(__cont.data()))
     300             :     -> decltype(__cont.data())
     301             :     { return __cont.data(); }
     302             : 
     303             :   /**
     304             :    *  @brief  Return the data pointer of an array.
     305             :    *  @param  __array  Array.
     306             :    */
     307             :   template <typename _Tp, size_t _Nm>
     308             :     constexpr _Tp*
     309             :     data(_Tp (&__array)[_Nm]) noexcept
     310             :     { return __array; }
     311             : 
     312             :   /**
     313             :    *  @brief  Return the data pointer of an initializer list.
     314             :    *  @param  __il  Initializer list.
     315             :    */
     316             :   template <typename _Tp>
     317             :     constexpr const _Tp*
     318             :     data(initializer_list<_Tp> __il) noexcept
     319             :     { return __il.begin(); }
     320             : 
     321             : #endif // C++17
     322             : 
     323             : _GLIBCXX_END_NAMESPACE_VERSION
     324             : } // namespace
     325             : 
     326             : #endif // C++11
     327             : 
     328             : #endif // _GLIBCXX_RANGE_ACCESS_H