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