Cider Isn't Darwin Emulation, Really
Something went wrong. Try again.
12 kB · 346 lines
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347// -*- 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 synopsisnamespace 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(is_nothrow_swappable_v<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; constexpr bool empty() const noexcept; // element access: reference operator[](size_type n); const_reference operator[](size_type n) const; // constexpr in C++14 const_reference at(size_type n) const; // constexpr in C++14 reference at(size_type n); reference front(); const_reference front() const; // constexpr in C++14 reference back(); const_reference back() const; // constexpr in C++14 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 <size_t I, class T> class tuple_element;template <class T, size_t N> struct tuple_size<array<T, N>>;template <size_t I, class T, size_t N> struct tuple_element<I, array<T, N>>;template <size_t I, class T, size_t N> T& get(array<T, N>&) noexcept; // constexpr in C++14template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept; // constexpr in C++14template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept; // constexpr in C++14template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexcept; // constexpr in C++14} // std*/#include <__config>#include <__tuple>#include <type_traits>#include <utility>#include <iterator>#include <algorithm>#include <stdexcept>#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)#pragma GCC system_header#endif_LIBCPP_BEGIN_NAMESPACE_STDtemplate <class _Tp, size_t _Size>struct _LIBCPP_TEMPLATE_VIS 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_(_Size == 0 || __is_nothrow_swappable<_Tp>::value) { __swap_dispatch((std::integral_constant<bool, _Size == 0>()), __a); } _LIBCPP_INLINE_VISIBILITY void __swap_dispatch(std::true_type, array&) {} _LIBCPP_INLINE_VISIBILITY void __swap_dispatch(std::false_type, array& __a) { _VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);} // iterators: _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 iterator begin() _NOEXCEPT {return iterator(__elems_);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 const_iterator begin() const _NOEXCEPT {return const_iterator(__elems_);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 iterator end() _NOEXCEPT {return iterator(__elems_ + _Size);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 const_iterator end() const _NOEXCEPT {return const_iterator(__elems_ + _Size);} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 const_iterator cbegin() const _NOEXCEPT {return begin();} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 const_iterator cend() const _NOEXCEPT {return end();} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 const_reverse_iterator crend() const _NOEXCEPT {return rend();} // capacity: _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return _Size;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return _Size == 0;} // element access: _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference operator[](size_type __n) {return __elems_[__n];} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference operator[](size_type __n) const {return __elems_[__n];} _LIBCPP_CONSTEXPR_AFTER_CXX14 reference at(size_type __n); _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference at(size_type __n) const; _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference front() {return __elems_[0];} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference front() const {return __elems_[0];} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference back() {return __elems_[_Size > 0 ? _Size-1 : 0];} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const {return __elems_[_Size > 0 ? _Size-1 : 0];} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 value_type* data() _NOEXCEPT {return __elems_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 const value_type* data() const _NOEXCEPT {return __elems_;}};template <class _Tp, size_t _Size>_LIBCPP_CONSTEXPR_AFTER_CXX14typename array<_Tp, _Size>::referencearray<_Tp, _Size>::at(size_type __n){ if (__n >= _Size) __throw_out_of_range("array::at"); return __elems_[__n];}template <class _Tp, size_t _Size>_LIBCPP_CONSTEXPR_AFTER_CXX11typename array<_Tp, _Size>::const_referencearray<_Tp, _Size>::at(size_type __n) const{ if (__n >= _Size) __throw_out_of_range("array::at"); return __elems_[__n];}template <class _Tp, size_t _Size>inline _LIBCPP_INLINE_VISIBILITYbooloperator==(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>inline _LIBCPP_INLINE_VISIBILITYbooloperator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y){ return !(__x == __y);}template <class _Tp, size_t _Size>inline _LIBCPP_INLINE_VISIBILITYbooloperator<(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>inline _LIBCPP_INLINE_VISIBILITYbooloperator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y){ return __y < __x;}template <class _Tp, size_t _Size>inline _LIBCPP_INLINE_VISIBILITYbooloperator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y){ return !(__y < __x);}template <class _Tp, size_t _Size>inline _LIBCPP_INLINE_VISIBILITYbooloperator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y){ return !(__x < __y);}template <class _Tp, size_t _Size>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< _Size == 0 || __is_swappable<_Tp>::value, void>::typeswap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y) _NOEXCEPT_(noexcept(__x.swap(__y))){ __x.swap(__y);}template <class _Tp, size_t _Size>class _LIBCPP_TEMPLATE_VIS tuple_size<array<_Tp, _Size> > : public integral_constant<size_t, _Size> {};template <size_t _Ip, class _Tp, size_t _Size>class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, array<_Tp, _Size> >{ static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::array)");public: typedef _Tp type;};template <size_t _Ip, class _Tp, size_t _Size>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11_Tp&get(array<_Tp, _Size>& __a) _NOEXCEPT{ static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array)"); return __a.__elems_[_Ip];}template <size_t _Ip, class _Tp, size_t _Size>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const _Tp&get(const array<_Tp, _Size>& __a) _NOEXCEPT{ static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array)"); return __a.__elems_[_Ip];}#ifndef _LIBCPP_CXX03_LANGtemplate <size_t _Ip, class _Tp, size_t _Size>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11_Tp&&get(array<_Tp, _Size>&& __a) _NOEXCEPT{ static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)"); return _VSTD::move(__a.__elems_[_Ip]);}template <size_t _Ip, class _Tp, size_t _Size>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const _Tp&&get(const array<_Tp, _Size>&& __a) _NOEXCEPT{ static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)"); return _VSTD::move(__a.__elems_[_Ip]);}#endif // !_LIBCPP_CXX03_LANG_LIBCPP_END_NAMESPACE_STD#endif // _LIBCPP_ARRAY