// class template array -*- C++ -*-// Copyright (C) 2007 Free Software Foundation, Inc.//// This file is part of the GNU ISO C++ Library. This library is free// software; you can redistribute it and/or modify it under the// terms of the GNU General Public License as published by the// Free Software Foundation; either version 2, or (at your option)// any later version.// This library is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the// GNU General Public License for more details.// You should have received a copy of the GNU General Public License along// with this library; see the file COPYING. If not, write to the Free// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,// USA.// As a special exception, you may use this file as part of a free software// library without restriction. Specifically, if other files instantiate// templates or use macros or inline functions from this file, or you compile// this file and link it with other files to produce an executable, this// file does not by itself cause the resulting executable to be covered by// the GNU General Public License. This exception does not however// invalidate any other reasons why the executable file might be covered by// the GNU General Public License./** @file tr1_impl/array* This is an internal header file, included by other library headers.* You should not attempt to use it directly.*/namespace std{_GLIBCXX_BEGIN_NAMESPACE_TR1/// array./// NB: Requires complete type _Tp.template<typename _Tp, std::size_t _Nm>struct array{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 std::size_t size_type;typedef std::ptrdiff_t difference_type;typedef std::reverse_iterator<iterator> reverse_iterator;typedef std::reverse_iterator<const_iterator> const_reverse_iterator;// Support for zero-sized arrays mandatory.value_type _M_instance[_Nm ? _Nm : 1];// No explicit construct/copy/destroy for aggregate type.voidassign(const value_type& __u){ std::fill_n(begin(), size(), __u); }voidswap(array& __other){ std::swap_ranges(begin(), end(), __other.begin()); }// Iterators.iteratorbegin(){ return iterator(&_M_instance[0]); }const_iteratorbegin() const{ return const_iterator(&_M_instance[0]); }iteratorend(){ return iterator(&_M_instance[_Nm]); }const_iteratorend() const{ return const_iterator(&_M_instance[_Nm]); }reverse_iteratorrbegin(){ return reverse_iterator(end()); }const_reverse_iteratorrbegin() const{ return const_reverse_iterator(end()); }reverse_iteratorrend(){ return reverse_iterator(begin()); }const_reverse_iteratorrend() const{ return const_reverse_iterator(begin()); }#ifdef _GLIBCXX_INCLUDE_AS_CXX0Xconst_iteratorcbegin() const{ return const_iterator(&_M_instance[0]); }const_iteratorcend() const{ return const_iterator(&_M_instance[_Nm]); }const_reverse_iteratorcrbegin() const{ return const_reverse_iterator(end()); }const_reverse_iteratorcrend() const{ return const_reverse_iterator(begin()); }#endif// Capacity.size_typesize() const { return _Nm; }size_typemax_size() const { return _Nm; }boolempty() const { return size() == 0; }// Element access.referenceoperator[](size_type __n){ return _M_instance[__n]; }const_referenceoperator[](size_type __n) const{ return _M_instance[__n]; }referenceat(size_type __n){if (__builtin_expect(__n >= _Nm, false))std::__throw_out_of_range(__N("array::at"));return _M_instance[__n];}const_referenceat(size_type __n) const{if (__builtin_expect(__n >= _Nm, false))std::__throw_out_of_range(__N("array::at"));return _M_instance[__n];}referencefront(){ return *begin(); }const_referencefront() const{ return *begin(); }referenceback(){ return _Nm ? *(end() - 1) : *end(); }const_referenceback() const{ return _Nm ? *(end() - 1) : *end(); }_Tp*data(){ return &_M_instance[0]; }const _Tp*data() const{ return &_M_instance[0]; }};// Array comparisons.template<typename _Tp, std::size_t _Nm>inline booloperator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two){ return std::equal(__one.begin(), __one.end(), __two.begin()); }template<typename _Tp, std::size_t _Nm>inline booloperator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two){ return !(__one == __two); }template<typename _Tp, std::size_t _Nm>inline booloperator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b){return std::lexicographical_compare(__a.begin(), __a.end(),__b.begin(), __b.end());}template<typename _Tp, std::size_t _Nm>inline booloperator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two){ return __two < __one; }template<typename _Tp, std::size_t _Nm>inline booloperator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two){ return !(__one > __two); }template<typename _Tp, std::size_t _Nm>inline booloperator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two){ return !(__one < __two); }// Specialized algorithms [6.2.2.2].template<typename _Tp, std::size_t _Nm>inline voidswap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two){ std::swap_ranges(__one.begin(), __one.end(), __two.begin()); }// Tuple interface to class template array [6.2.2.5]./// tuple_sizetemplate<typename _Tp>class tuple_size;/// tuple_elementtemplate<int _Int, typename _Tp>class tuple_element;template<typename _Tp, std::size_t _Nm>struct tuple_size<array<_Tp, _Nm> >{ static const int value = _Nm; };template<typename _Tp, std::size_t _Nm>const int tuple_size<array<_Tp, _Nm> >::value;template<int _Int, typename _Tp, std::size_t _Nm>struct tuple_element<_Int, array<_Tp, _Nm> >{ typedef _Tp type; };template<int _Int, typename _Tp, std::size_t _Nm>inline _Tp&get(array<_Tp, _Nm>& __arr){ return __arr[_Int]; }template<int _Int, typename _Tp, std::size_t _Nm>inline const _Tp&get(const array<_Tp, _Nm>& __arr){ return __arr[_Int]; }_GLIBCXX_END_NAMESPACE_TR1}