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 #ifndef MYSQLPP_RESITER_H
00034 #define MYSQLPP_RESITER_H
00035
00036 #include "defs.h"
00037
00038 #include <iterator>
00039
00040 namespace mysqlpp {
00041
00042 template <class OnType, class ReturnType, class SizeType,
00043 class DiffType> class subscript_iterator;
00044
00049
00050
00051 template <class OnType,
00052 class ValueType,
00053 class ReturnType = const ValueType&,
00054 class SizeType = unsigned int,
00055 class DiffType = int>
00056 class const_subscript_container
00057 {
00058 public:
00059 typedef const_subscript_container<OnType, ValueType, ReturnType,
00060 SizeType, DiffType> this_type;
00061 typedef subscript_iterator<const this_type, ReturnType, SizeType,
00062 DiffType> iterator;
00063 typedef iterator const_iterator;
00064 typedef const std::reverse_iterator<iterator>
00065 reverse_iterator;
00066 typedef const std::reverse_iterator<const_iterator>
00067 const_reverse_iterator;
00068
00069 typedef ValueType value_type;
00070 typedef value_type& reference;
00071 typedef value_type& const_reference;
00072 typedef value_type* pointer;
00073 typedef value_type* const_pointer;
00074
00075 typedef DiffType difference_type;
00076 typedef SizeType size_type;
00077
00079 virtual size_type size() const = 0;
00080
00082 virtual ReturnType operator [](SizeType i) const = 0;
00083
00086 size_type max_size() const { return size(); }
00087
00089 bool empty() const { return size() == 0; }
00090
00093 iterator begin() const { return iterator(this, 0); }
00094
00097 iterator end() const { return iterator(this, size()); }
00098
00101 reverse_iterator rbegin() const { return reverse_iterator(end()); }
00102
00105 reverse_iterator rend() const { return reverse_iterator(begin()); }
00106 };
00107
00108
00113
00114 template <class OnType, class ReturnType, class SizeType,
00115 class DiffType>
00116 class subscript_iterator : public std::iterator<ReturnType, SizeType>
00117 {
00118 private:
00119 SizeType i;
00120 OnType* d;
00121
00122 public:
00124 subscript_iterator() { }
00125
00128 subscript_iterator(OnType* what, SizeType pos)
00129 {
00130 d = what;
00131 i = pos;
00132 }
00133
00136 bool operator ==(const subscript_iterator& j) const
00137 {
00138 return (d == j.d && i == j.i);
00139 }
00140
00143 bool operator !=(const subscript_iterator& j) const
00144 {
00145 return (d == j.d && i != j.i);
00146 }
00147
00151 bool operator <(const subscript_iterator& j) const
00152 {
00153 return (d == j.d && i < j.i);
00154 }
00155
00159 bool operator >(const subscript_iterator & j) const
00160 {
00161 return (d == j.d && i > j.i);
00162 }
00163
00167 bool operator <=(const subscript_iterator & j) const
00168 {
00169 return (d == j.d && i <= j.i);
00170 }
00171
00175 bool operator >=(const subscript_iterator & j) const
00176 {
00177 return (d == j.d && i >= j.i);
00178 }
00179
00182 ReturnType* operator ->() const { return &((*d)[i]); }
00183
00186 ReturnType operator *() const { return (*d)[i]; }
00187
00189 ReturnType operator [](SizeType n) const { return (*d)[n]; }
00190
00193 subscript_iterator& operator ++() { ++i; return *this; }
00194
00197 subscript_iterator operator ++(int)
00198 {
00199 subscript_iterator tmp = *this;
00200 ++i;
00201 return tmp;
00202 }
00203
00206 subscript_iterator& operator --()
00207 {
00208 --i;
00209 return *this;
00210 }
00211
00214 subscript_iterator operator --(int)
00215 {
00216 subscript_iterator tmp = *this;
00217 --i;
00218 return tmp;
00219 }
00220
00222 subscript_iterator& operator +=(SizeType n)
00223 {
00224 i += n;
00225 return *this;
00226 }
00227
00229 subscript_iterator operator +(SizeType n) const
00230 {
00231 subscript_iterator tmp = *this;
00232 tmp.i += n;
00233 return tmp;
00234 }
00235
00237 subscript_iterator& operator -=(SizeType n)
00238 {
00239 i -= n;
00240 return *this;
00241 }
00242
00244 subscript_iterator operator -(SizeType n) const
00245 {
00246 subscript_iterator tmp = *this;
00247 tmp.i -= n;
00248 return tmp;
00249 }
00250
00252 DiffType operator -(const subscript_iterator& j) const
00253 {
00254 if (d == j.d) {
00255 return static_cast<SizeType>(i) - j.i;
00256 }
00257 return 0;
00258 }
00259 };
00260
00261
00262 #if !defined(DOXYGEN_IGNORE)
00263
00264
00265 template <class OnType, class ReturnType, class SizeType,
00266 class DiffType>
00267 inline subscript_iterator<OnType, ReturnType, SizeType, DiffType>
00268 operator +(SizeType x,
00269 const subscript_iterator <OnType, ReturnType, SizeType, DiffType>& y)
00270 {
00271 return y + x;
00272 }
00273
00274 #endif // !defined(DOXYGEN_IGNORE)
00275
00276 }
00277
00278 #endif