// -*- C++ -*- //===---------------------------- array -----------------------------------===// // // 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_ARRAY #define _LIBCPP_ARRAY /* array synopsis namespace std { template <class T, size_t N > struct array { // types: typedef T & reference; typedef const T & const_reference; typedef implementation defined iterator; typedef implementation defined const_iterator; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef std::reverse_iterator<iterator> reverse_iterator; typedef std::reverse_iterator<const_iterator> const_reverse_iterator; // No explicit construct/copy/destroy for aggregate type void fill(const T& u); void swap(array& a) noexcept(noexcept(swap(declval<T&>(), declval<T&>()))); // iterators: iterator begin() noexcept; const_iterator begin() const noexcept; iterator end() noexcept; const_iterator end() const noexcept; reverse_iterator rbegin() noexcept; const_reverse_iterator rbegin() const noexcept; reverse_iterator rend() noexcept; const_reverse_iterator rend() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept; const_reverse_iterator crbegin() const noexcept; const_reverse_iterator crend() const noexcept; // capacity: constexpr size_type size() const noexcept; constexpr size_type max_size() const noexcept; bool empty() const noexcept; // element access: reference operator[](size_type n); const_reference operator[](size_type n) const; const_reference at(size_type n) const; reference at(size_type n); reference front(); const_reference front() const; reference back(); const_reference back() const; T* data() noexcept; const T* data() const noexcept; }; template <class T, size_t N> bool operator==(const array<T,N>& x, const array<T,N>& y); template <class T, size_t N> bool operator!=(const array<T,N>& x, const array<T,N>& y); template <class T, size_t N> bool operator<(const array<T,N>& x, const array<T,N>& y); template <class T, size_t N> bool operator>(const array<T,N>& x, const array<T,N>& y); template <class T, size_t N> bool operator<=(const array<T,N>& x, const array<T,N>& y); template <class T, size_t N> bool operator>=(const array<T,N>& x, const array<T,N>& y); template <class T, size_t N > void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y))); template <class T> class tuple_size; template <int I, class T> class tuple_element; template <class T, size_t N> struct tuple_size<array<T, N>>; template <int I, class T, size_t N> struct tuple_element<I, array<T, N>>; template <int I, class T, size_t N> T& get(array<T, N>&) noexcept; template <int I, class T, size_t N> const T& get(const array<T, N>&) noexcept; template <int I, class T, size_t N> T&& get(array<T, N>&&) noexcept; } // std */ #include <__config> #include <__tuple> #include <type_traits> #include <utility> #include <iterator> #include <algorithm> #include <stdexcept> #if defined(_LIBCPP_NO_EXCEPTIONS) #include <cassert> #endif #pragma GCC system_header _LIBCPP_BEGIN_NAMESPACE_STD template <class _Tp, size_t _Size> struct _LIBCPP_VISIBLE array { // types: typedef array __self; typedef _Tp value_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type* pointer; typedef const value_type* const_pointer; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef std::reverse_iterator<iterator> reverse_iterator; typedef std::reverse_iterator<const_iterator> const_reverse_iterator; value_type __elems_[_Size > 0 ? _Size : 1]; // No explicit construct/copy/destroy for aggregate type _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u) {_VSTD::fill_n(__elems_, _Size, __u);} _LIBCPP_INLINE_VISIBILITY void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {_VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);} // iterators: _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT {return iterator(__elems_);} _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return const_iterator(__elems_);} _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT {return iterator(__elems_ + _Size);} _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT {return const_iterator(__elems_ + _Size);} _LIBCPP_INLINE_VISIBILITY reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());} _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());} _LIBCPP_INLINE_VISIBILITY reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());} _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());} _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const _NOEXCEPT {return begin();} _LIBCPP_INLINE_VISIBILITY const_iterator cend() const _NOEXCEPT {return end();} _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();} _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend() const _NOEXCEPT {return rend();} // capacity: _LIBCPP_INLINE_VISIBILITY /*constexpr*/ size_type size() const _NOEXCEPT {return _Size;} _LIBCPP_INLINE_VISIBILITY /*constexpr*/ size_type max_size() const _NOEXCEPT {return _Size;} _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT {return _Size == 0;} // element access: _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) {return __elems_[__n];} _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const {return __elems_[__n];} reference at(size_type __n); const_reference at(size_type __n) const; _LIBCPP_INLINE_VISIBILITY reference front() {return __elems_[0];} _LIBCPP_INLINE_VISIBILITY const_reference front() const {return __elems_[0];} _LIBCPP_INLINE_VISIBILITY reference back() {return __elems_[_Size > 0 ? _Size-1 : 0];} _LIBCPP_INLINE_VISIBILITY const_reference back() const {return __elems_[_Size > 0 ? _Size-1 : 0];} _LIBCPP_INLINE_VISIBILITY value_type* data() _NOEXCEPT {return __elems_;} _LIBCPP_INLINE_VISIBILITY const value_type* data() const _NOEXCEPT {return __elems_;} }; template <class _Tp, size_t _Size> typename array<_Tp, _Size>::reference array<_Tp, _Size>::at(size_type __n) { if (__n >= _Size) #ifndef _LIBCPP_NO_EXCEPTIONS throw out_of_range("array::at"); #else assert(!"array::at out_of_range"); #endif return __elems_[__n]; } template <class _Tp, size_t _Size> typename array<_Tp, _Size>::const_reference array<_Tp, _Size>::at(size_type __n) const { if (__n >= _Size) #ifndef _LIBCPP_NO_EXCEPTIONS throw out_of_range("array::at"); #else assert(!"array::at out_of_range"); #endif return __elems_[__n]; } template <class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline bool operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) { return _VSTD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_); } template <class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline bool operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) { return !(__x == __y); } template <class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline bool operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) { return _VSTD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size); } template <class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline bool operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) { return __y < __x; } template <class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline bool operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) { return !(__y < __x); } template <class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline bool operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) { return !(__x < __y); } template <class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline typename enable_if < __is_swappable<_Tp>::value, void >::type swap(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) { __x.swap(__y); } template <class _Tp, size_t _Size> class _LIBCPP_VISIBLE tuple_size<array<_Tp, _Size> > : public integral_constant<size_t, _Size> {}; template <class _Tp, size_t _Size> class _LIBCPP_VISIBLE tuple_size<const array<_Tp, _Size> > : public integral_constant<size_t, _Size> {}; template <size_t _Ip, class _Tp, size_t _Size> class _LIBCPP_VISIBLE tuple_element<_Ip, array<_Tp, _Size> > { public: typedef _Tp type; }; template <size_t _Ip, class _Tp, size_t _Size> class _LIBCPP_VISIBLE tuple_element<_Ip, const array<_Tp, _Size> > { public: typedef const _Tp type; }; template <size_t _Ip, class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline _Tp& get(array<_Tp, _Size>& __a) _NOEXCEPT { return __a[_Ip]; } template <size_t _Ip, class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline const _Tp& get(const array<_Tp, _Size>& __a) _NOEXCEPT { return __a[_Ip]; } #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template <size_t _Ip, class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY inline _Tp&& get(array<_Tp, _Size>&& __a) _NOEXCEPT { return _VSTD::move(__a[_Ip]); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_ARRAY