Home | History | Annotate | Download | only in include 
      1 // -*- C++ -*-
      2 //===---------------------------- array -----------------------------------===//
      3 //
      4 //                     The LLVM Compiler Infrastructure
      5 //
      6 // This file is dual licensed under the MIT and the University of Illinois Open
      7 // Source Licenses. See LICENSE.TXT for details.
      8 //
      9 //===----------------------------------------------------------------------===//
     10 
     11 #ifndef _LIBCPP_ARRAY
     12 #define _LIBCPP_ARRAY
     13 
     14 /*
     15     array synopsis
     16 
     17 namespace std
     18 {
     19 template <class T, size_t N >
     20 struct array
     21 {
     22     // types:
     23     typedef T & reference;
     24     typedef const T & const_reference;
     25     typedef implementation defined iterator;
     26     typedef implementation defined const_iterator;
     27     typedef size_t size_type;
     28     typedef ptrdiff_t difference_type;
     29     typedef T value_type;
     30     typedef T* pointer;
     31     typedef const T* const_pointer;
     32     typedef std::reverse_iterator<iterator> reverse_iterator;
     33     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     34 
     35     // No explicit construct/copy/destroy for aggregate type
     36     void fill(const T& u);
     37     void swap(array& a) noexcept(noexcept(swap(declval<T&>(), declval<T&>())));
     38 
     39     // iterators:
     40     iterator begin() noexcept;
     41     const_iterator begin() const noexcept;
     42     iterator end() noexcept;
     43     const_iterator end() const noexcept;
     44 
     45     reverse_iterator rbegin() noexcept;
     46     const_reverse_iterator rbegin() const noexcept;
     47     reverse_iterator rend() noexcept;
     48     const_reverse_iterator rend() const noexcept;
     49 
     50     const_iterator cbegin() const noexcept;
     51     const_iterator cend() const noexcept;
     52     const_reverse_iterator crbegin() const noexcept;
     53     const_reverse_iterator crend() const noexcept;
     54 
     55     // capacity:
     56     constexpr size_type size() const noexcept;
     57     constexpr size_type max_size() const noexcept;
     58     constexpr bool empty() const noexcept;
     59 
     60     // element access:
     61     reference operator[](size_type n);
     62     const_reference operator[](size_type n) const; // constexpr in C++14
     63     const_reference at(size_type n) const; // constexpr in C++14
     64     reference at(size_type n);
     65 
     66     reference front();
     67     const_reference front() const; // constexpr in C++14
     68     reference back();
     69     const_reference back() const; // constexpr in C++14
     70 
     71     T* data() noexcept;
     72     const T* data() const noexcept;
     73 };
     74 
     75 template <class T, size_t N>
     76   bool operator==(const array<T,N>& x, const array<T,N>& y);
     77 template <class T, size_t N>
     78   bool operator!=(const array<T,N>& x, const array<T,N>& y);
     79 template <class T, size_t N>
     80   bool operator<(const array<T,N>& x, const array<T,N>& y);
     81 template <class T, size_t N>
     82   bool operator>(const array<T,N>& x, const array<T,N>& y);
     83 template <class T, size_t N>
     84   bool operator<=(const array<T,N>& x, const array<T,N>& y);
     85 template <class T, size_t N>
     86   bool operator>=(const array<T,N>& x, const array<T,N>& y);
     87 
     88 template <class T, size_t N >
     89   void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y)));
     90 
     91 template <class T> class tuple_size;
     92 template <int I, class T> class tuple_element;
     93 template <class T, size_t N> struct tuple_size<array<T, N>>;
     94 template <int I, class T, size_t N> struct tuple_element<I, array<T, N>>;
     95 template <int I, class T, size_t N> T& get(array<T, N>&) noexcept; // constexpr in C++14
     96 template <int I, class T, size_t N> const T& get(const array<T, N>&) noexcept; // constexpr in C++14
     97 template <int I, class T, size_t N> T&& get(array<T, N>&&) noexcept; // constexpr in C++14
     98 
     99 }  // std
    100 
    101 */
    102 
    103 #include <__config>
    104 #include <__tuple>
    105 #include <type_traits>
    106 #include <utility>
    107 #include <iterator>
    108 #include <algorithm>
    109 #include <stdexcept>
    110 #if defined(_LIBCPP_NO_EXCEPTIONS)
    111     #include <cassert>
    112 #endif
    113 
    114 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
    115 #pragma GCC system_header
    116 #endif
    117 
    118 _LIBCPP_BEGIN_NAMESPACE_STD
    119 
    120 template <class _Tp, size_t _Size>
    121 struct _LIBCPP_TYPE_VIS_ONLY array
    122 {
    123     // types:
    124     typedef array __self;
    125     typedef _Tp                                   value_type;
    126     typedef value_type&                           reference;
    127     typedef const value_type&                     const_reference;
    128     typedef value_type*                           iterator;
    129     typedef const value_type*                     const_iterator;
    130     typedef value_type*                           pointer;
    131     typedef const value_type*                     const_pointer;
    132     typedef size_t                                size_type;
    133     typedef ptrdiff_t                             difference_type;
    134     typedef std::reverse_iterator<iterator>       reverse_iterator;
    135     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    136 
    137     value_type __elems_[_Size > 0 ? _Size : 1];
    138 
    139     // No explicit construct/copy/destroy for aggregate type
    140     _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u)
    141         {_VSTD::fill_n(__elems_, _Size, __u);}
    142     _LIBCPP_INLINE_VISIBILITY
    143     void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
    144         {_VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
    145 
    146     // iterators:
    147     _LIBCPP_INLINE_VISIBILITY
    148     iterator begin() _NOEXCEPT {return iterator(__elems_);}
    149     _LIBCPP_INLINE_VISIBILITY
    150     const_iterator begin() const _NOEXCEPT {return const_iterator(__elems_);}
    151     _LIBCPP_INLINE_VISIBILITY
    152     iterator end() _NOEXCEPT {return iterator(__elems_ + _Size);}
    153     _LIBCPP_INLINE_VISIBILITY
    154     const_iterator end() const _NOEXCEPT {return const_iterator(__elems_ + _Size);}
    155 
    156     _LIBCPP_INLINE_VISIBILITY
    157     reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
    158     _LIBCPP_INLINE_VISIBILITY
    159     const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
    160     _LIBCPP_INLINE_VISIBILITY
    161     reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
    162     _LIBCPP_INLINE_VISIBILITY
    163     const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
    164 
    165     _LIBCPP_INLINE_VISIBILITY
    166     const_iterator cbegin() const _NOEXCEPT {return begin();}
    167     _LIBCPP_INLINE_VISIBILITY
    168     const_iterator cend() const _NOEXCEPT {return end();}
    169     _LIBCPP_INLINE_VISIBILITY
    170     const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
    171     _LIBCPP_INLINE_VISIBILITY
    172     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
    173 
    174     // capacity:
    175     _LIBCPP_INLINE_VISIBILITY
    176     _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return _Size;}
    177     _LIBCPP_INLINE_VISIBILITY
    178     _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;}
    179     _LIBCPP_INLINE_VISIBILITY
    180     _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return _Size == 0;}
    181 
    182     // element access:
    183     _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n)             {return __elems_[__n];}
    184     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference operator[](size_type __n) const {return __elems_[__n];}
    185     reference at(size_type __n);
    186     _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference at(size_type __n) const;
    187 
    188     _LIBCPP_INLINE_VISIBILITY reference front()             {return __elems_[0];}
    189     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference front() const {return __elems_[0];}
    190     _LIBCPP_INLINE_VISIBILITY reference back()              {return __elems_[_Size > 0 ? _Size-1 : 0];}
    191     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const  {return __elems_[_Size > 0 ? _Size-1 : 0];}
    192 
    193     _LIBCPP_INLINE_VISIBILITY
    194     value_type* data() _NOEXCEPT {return __elems_;}
    195     _LIBCPP_INLINE_VISIBILITY
    196     const value_type* data() const _NOEXCEPT {return __elems_;}
    197 };
    198 
    199 template <class _Tp, size_t _Size>
    200 typename array<_Tp, _Size>::reference
    201 array<_Tp, _Size>::at(size_type __n)
    202 {
    203     if (__n >= _Size)
    204 #ifndef _LIBCPP_NO_EXCEPTIONS
    205         throw out_of_range("array::at");
    206 #else
    207         assert(!"array::at out_of_range");
    208 #endif
    209     return __elems_[__n];
    210 }
    211 
    212 template <class _Tp, size_t _Size>
    213 _LIBCPP_CONSTEXPR_AFTER_CXX11
    214 typename array<_Tp, _Size>::const_reference
    215 array<_Tp, _Size>::at(size_type __n) const
    216 {
    217     if (__n >= _Size)
    218 #ifndef _LIBCPP_NO_EXCEPTIONS
    219         throw out_of_range("array::at");
    220 #else
    221         assert(!"array::at out_of_range");
    222 #endif
    223     return __elems_[__n];
    224 }
    225 
    226 template <class _Tp, size_t _Size>
    227 inline _LIBCPP_INLINE_VISIBILITY
    228 bool
    229 operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
    230 {
    231     return _VSTD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
    232 }
    233 
    234 template <class _Tp, size_t _Size>
    235 inline _LIBCPP_INLINE_VISIBILITY
    236 bool
    237 operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
    238 {
    239     return !(__x == __y);
    240 }
    241 
    242 template <class _Tp, size_t _Size>
    243 inline _LIBCPP_INLINE_VISIBILITY
    244 bool
    245 operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
    246 {
    247     return _VSTD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size);
    248 }
    249 
    250 template <class _Tp, size_t _Size>
    251 inline _LIBCPP_INLINE_VISIBILITY
    252 bool
    253 operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
    254 {
    255     return __y < __x;
    256 }
    257 
    258 template <class _Tp, size_t _Size>
    259 inline _LIBCPP_INLINE_VISIBILITY
    260 bool
    261 operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
    262 {
    263     return !(__y < __x);
    264 }
    265 
    266 template <class _Tp, size_t _Size>
    267 inline _LIBCPP_INLINE_VISIBILITY
    268 bool
    269 operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
    270 {
    271     return !(__x < __y);
    272 }
    273 
    274 template <class _Tp, size_t _Size>
    275 inline _LIBCPP_INLINE_VISIBILITY
    276 typename enable_if
    277 <
    278     __is_swappable<_Tp>::value,
    279     void
    280 >::type
    281 swap(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
    282                                   _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
    283 {
    284     __x.swap(__y);
    285 }
    286 
    287 template <class _Tp, size_t _Size>
    288 class _LIBCPP_TYPE_VIS_ONLY tuple_size<array<_Tp, _Size> >
    289     : public integral_constant<size_t, _Size> {};
    290 
    291 template <size_t _Ip, class _Tp, size_t _Size>
    292 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, array<_Tp, _Size> >
    293 {
    294 public:
    295     typedef _Tp type;
    296 };
    297 
    298 template <size_t _Ip, class _Tp, size_t _Size>
    299 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    300 _Tp&
    301 get(array<_Tp, _Size>& __a) _NOEXCEPT
    302 {
    303     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array)");
    304     return __a.__elems_[_Ip];
    305 }
    306 
    307 template <size_t _Ip, class _Tp, size_t _Size>
    308 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    309 const _Tp&
    310 get(const array<_Tp, _Size>& __a) _NOEXCEPT
    311 {
    312     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array)");
    313     return __a.__elems_[_Ip];
    314 }
    315 
    316 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    317 
    318 template <size_t _Ip, class _Tp, size_t _Size>
    319 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    320 _Tp&&
    321 get(array<_Tp, _Size>&& __a) _NOEXCEPT
    322 {
    323     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)");
    324     return _VSTD::move(__a.__elems_[_Ip]);
    325 }
    326 
    327 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    328 
    329 _LIBCPP_END_NAMESPACE_STD
    330 
    331 #endif  // _LIBCPP_ARRAY
    332