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
00031
00032
00033
00034 #ifndef _ARRAY
00035 #define _ARRAY 1
00036
00037 #include <new>
00038 #include <iterator>
00039 #include <algorithm>
00040 #include <bits/functexcept.h>
00041
00042
00043 namespace std
00044 {
00045 namespace tr1
00046 {
00047
00048
00049 template<typename _Tp, size_t _Nm = 1>
00050 struct array
00051 {
00052 typedef _Tp value_type;
00053 typedef value_type& reference;
00054 typedef const value_type& const_reference;
00055 typedef value_type* iterator;
00056 typedef const value_type* const_iterator;
00057 typedef size_t size_type;
00058 typedef ptrdiff_t difference_type;
00059 typedef std::reverse_iterator<iterator> reverse_iterator;
00060 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00061
00062
00063 enum { _S_index = _Nm };
00064
00065
00066 value_type _M_instance[_Nm ? _Nm : 1];
00067
00068
00069
00070 void
00071 assign(const value_type& u);
00072
00073 void
00074 swap(array&);
00075
00076
00077 iterator
00078 begin()
00079 { return reinterpret_cast<iterator>(&_M_instance[0]); }
00080
00081 const_iterator
00082 begin() const
00083 { return reinterpret_cast<const_iterator>(&_M_instance[0]); }
00084
00085 iterator
00086 end()
00087 { return reinterpret_cast<iterator>(&_M_instance[_Nm]); }
00088
00089 const_iterator
00090 end() const
00091 { return reinterpret_cast<const_iterator>(&_M_instance[_Nm]); }
00092
00093 reverse_iterator
00094 rbegin()
00095 { return reverse_iterator(this->end()); }
00096
00097 const_reverse_iterator
00098 rbegin() const
00099 { return const_reverse_iterator(this->end()); }
00100
00101 reverse_iterator
00102 rend()
00103 { return reverse_iterator(this->begin()); }
00104
00105 const_reverse_iterator
00106 rend() const
00107 { return const_reverse_iterator(this->begin()); }
00108
00109
00110 size_type
00111 size() const { return _Nm; }
00112
00113 size_type
00114 max_size() const { return _Nm; }
00115
00116 bool
00117 empty() const { return size() == 0; }
00118
00119
00120 reference
00121 operator[](size_type __n)
00122 { return reinterpret_cast<reference>(_M_instance[__n]); }
00123
00124 const_reference
00125 operator[](size_type __n) const
00126 { return reinterpret_cast<const_reference>(_M_instance[__n]); }
00127
00128 const_reference
00129 at(size_type __n) const
00130 {
00131 if (__builtin_expect(__n > _Nm, false))
00132 std::__throw_out_of_range("array::at");
00133 return reinterpret_cast<const_reference>(_M_instance[__n]);
00134 }
00135
00136 reference
00137 at(size_type __n)
00138 {
00139 if (__builtin_expect(__n > _Nm, false))
00140 std::__throw_out_of_range("array::at");
00141 return reinterpret_cast<reference>(_M_instance[__n]);
00142 }
00143
00144 reference
00145 front();
00146
00147 const_reference
00148 front() const;
00149
00150 reference
00151 back();
00152
00153 const_reference
00154 back() const;
00155
00156 _Tp*
00157 data();
00158
00159 const _Tp*
00160 data() const;
00161 };
00162
00163
00164 template<typename _Tp, size_t _Nm>
00165 bool
00166 operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00167 { return std::equal(__one.begin(), __one.end(), __two.begin()); }
00168
00169 template<typename _Tp, size_t _Nm>
00170 bool
00171 operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00172 { return !(__one == __two); }
00173
00174 template<typename _Tp, size_t _Nm>
00175 bool
00176 operator<(const array<_Tp, _Nm>& a, const array<_Tp, _Nm>& b)
00177 {
00178 return std::lexicographical_compare(a.begin(), a.end(),
00179 b.begin(), b.end());
00180 }
00181
00182 template<typename _Tp, size_t _Nm>
00183 bool
00184 operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00185 { return __two < __one; }
00186
00187 template<typename _Tp, size_t _Nm>
00188 bool
00189 operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00190 { return !(__one > __two); }
00191
00192 template<typename _Tp, size_t _Nm>
00193 bool
00194 operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
00195 { return !(__one < __two); }
00196
00197
00198 template<typename _Tp, size_t _Nm>
00199 void
00200 swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
00201 { swap_ranges(__one.begin(), __one.end(), __two.begin()); }
00202 }
00203 }
00204
00205 #endif