00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 namespace std
00031 {
00032 _GLIBCXX_BEGIN_NAMESPACE_TR1
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048 template<typename _Tp, std::size_t _Nm>
00049 struct array
00050 {
00051 typedef _Tp value_type;
00052 typedef value_type& reference;
00053 typedef const value_type& const_reference;
00054 typedef value_type* iterator;
00055 typedef const value_type* const_iterator;
00056 typedef std::size_t size_type;
00057 typedef std::ptrdiff_t difference_type;
00058 typedef std::reverse_iterator<iterator> reverse_iterator;
00059 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00060
00061
00062 value_type _M_instance[_Nm ? _Nm : 1];
00063
00064
00065
00066 void
00067 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00068
00069 fill(const value_type& __u)
00070 #else
00071 assign(const value_type& __u)
00072 #endif
00073 { std::fill_n(begin(), size(), __u); }
00074
00075 void
00076 swap(array& __other)
00077 { std::swap_ranges(begin(), end(), __other.begin()); }
00078
00079
00080 iterator
00081 begin()
00082 { return iterator(&_M_instance[0]); }
00083
00084 const_iterator
00085 begin() const
00086 { return const_iterator(&_M_instance[0]); }
00087
00088 iterator
00089 end()
00090 { return iterator(&_M_instance[_Nm]); }
00091
00092 const_iterator
00093 end() const
00094 { return const_iterator(&_M_instance[_Nm]); }
00095
00096 reverse_iterator
00097 rbegin()
00098 { return reverse_iterator(end()); }
00099
00100 const_reverse_iterator
00101 rbegin() const
00102 { return const_reverse_iterator(end()); }
00103
00104 reverse_iterator
00105 rend()
00106 { return reverse_iterator(begin()); }
00107
00108 const_reverse_iterator
00109 rend() const
00110 { return const_reverse_iterator(begin()); }
00111
00112 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00113 const_iterator
00114 cbegin() const
00115 { return const_iterator(&_M_instance[0]); }
00116
00117 const_iterator
00118 cend() const
00119 { return const_iterator(&_M_instance[_Nm]); }
00120
00121 const_reverse_iterator
00122 crbegin() const
00123 { return const_reverse_iterator(end()); }
00124
00125 const_reverse_iterator
00126 crend() const
00127 { return const_reverse_iterator(begin()); }
00128 #endif
00129
00130
00131 size_type
00132 size() const { return _Nm; }
00133
00134 size_type
00135 max_size() const { return _Nm; }
00136
00137 bool
00138 empty() const { return size() == 0; }
00139
00140
00141 reference
00142 operator[](size_type __n)
00143 { return _M_instance[__n]; }
00144
00145 const_reference
00146 operator[](size_type __n) const
00147 { return _M_instance[__n]; }
00148
00149 reference
00150 at(size_type __n)
00151 {
00152 if (__builtin_expect(__n >= _Nm, false))
00153 std::__throw_out_of_range(__N("array::at"));
00154 return _M_instance[__n];
00155 }
00156
00157 const_reference
00158 at(size_type __n) const
00159 {
00160 if (__builtin_expect(__n >= _Nm, false))
00161 std::__throw_out_of_range(__N("array::at"));
00162 return _M_instance[__n];
00163 }
00164
00165 reference
00166 front()
00167 { return *begin(); }
00168
00169 const_reference
00170 front() const
00171 { return *begin(); }
00172
00173 reference
00174 back()
00175 { return _Nm ? *(end() - 1) : *end(); }
00176
00177 const_reference
00178 back() const
00179 { return _Nm ? *(end() - 1) : *end(); }
00180
00181 _Tp*
00182 data()
00183 { return &_M_instance[0]; }
00184
00185 const _Tp*
00186 data() const
00187 { return &_M_instance[0]; }
00188 };
00189
00190
00191 template<typename _Tp, std::size_t _Nm>
00192 inline bool
00193 operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00194 { return std::equal(__one.begin(), __one.end(), __two.begin()); }
00195
00196 template<typename _Tp, std::size_t _Nm>
00197 inline bool
00198 operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00199 { return !(__one == __two); }
00200
00201 template<typename _Tp, std::size_t _Nm>
00202 inline bool
00203 operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
00204 {
00205 return std::lexicographical_compare(__a.begin(), __a.end(),
00206 __b.begin(), __b.end());
00207 }
00208
00209 template<typename _Tp, std::size_t _Nm>
00210 inline bool
00211 operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00212 { return __two < __one; }
00213
00214 template<typename _Tp, std::size_t _Nm>
00215 inline bool
00216 operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00217 { return !(__one > __two); }
00218
00219 template<typename _Tp, std::size_t _Nm>
00220 inline bool
00221 operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00222 { return !(__one < __two); }
00223
00224
00225 template<typename _Tp, std::size_t _Nm>
00226 inline void
00227 swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
00228 { std::swap_ranges(__one.begin(), __one.end(), __two.begin()); }
00229
00230
00231
00232
00233 template<typename _Tp>
00234 class tuple_size;
00235
00236
00237 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00238 template<std::size_t _Int, typename _Tp>
00239 #else
00240 template<int _Int, typename _Tp>
00241 #endif
00242 class tuple_element;
00243
00244 template<typename _Tp, std::size_t _Nm>
00245 struct tuple_size<array<_Tp, _Nm> >
00246 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00247 { static const std::size_t value = _Nm; };
00248 #else
00249 { static const int value = _Nm; };
00250 #endif
00251
00252 template<typename _Tp, std::size_t _Nm>
00253 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00254 const std::size_t
00255 #else
00256 const int
00257 #endif
00258 tuple_size<array<_Tp, _Nm> >::value;
00259
00260 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00261 template<std::size_t _Int, typename _Tp, std::size_t _Nm>
00262 #else
00263 template<int _Int, typename _Tp, std::size_t _Nm>
00264 #endif
00265 struct tuple_element<_Int, array<_Tp, _Nm> >
00266 { typedef _Tp type; };
00267
00268 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00269 template<std::size_t _Int, typename _Tp, std::size_t _Nm>
00270 #else
00271 template<int _Int, typename _Tp, std::size_t _Nm>
00272 #endif
00273 inline _Tp&
00274 get(array<_Tp, _Nm>& __arr)
00275 { return __arr[_Int]; }
00276
00277 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00278 template<std::size_t _Int, typename _Tp, std::size_t _Nm>
00279 #else
00280 template<int _Int, typename _Tp, std::size_t _Nm>
00281 #endif
00282 inline const _Tp&
00283 get(const array<_Tp, _Nm>& __arr)
00284 { return __arr[_Int]; }
00285
00286 _GLIBCXX_END_NAMESPACE_TR1
00287 }