Main Page | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members | File Members

resiter.h

Go to the documentation of this file.
00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 /***********************************************************************
00010  Copyright (c) 1998 by Kevin Atkinson, (c) 1999, 2000 and 2001 by
00011  MySQL AB, and (c) 2004, 2005 by Educational Technology Resources, Inc.
00012  Others may also hold copyrights on code in this file.  See the CREDITS
00013  file in the top directory of the distribution for details.
00014 
00015  This file is part of MySQL++.
00016 
00017  MySQL++ is free software; you can redistribute it and/or modify it
00018  under the terms of the GNU Lesser General Public License as published
00019  by the Free Software Foundation; either version 2.1 of the License, or
00020  (at your option) any later version.
00021 
00022  MySQL++ is distributed in the hope that it will be useful, but WITHOUT
00023  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00024  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
00025  License for more details.
00026 
00027  You should have received a copy of the GNU Lesser General Public
00028  License along with MySQL++; if not, write to the Free Software
00029  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
00030  USA
00031 ***********************************************************************/
00032 
00033 #ifndef MYSQLPP_RESITER_H
00034 #define MYSQLPP_RESITER_H
00035 
00036 #include "common.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 // \c size() defined for it.
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 ~const_subscript_container() { }
00080 
00082         virtual size_type size() const = 0;     
00083 
00085         virtual ReturnType at(SizeType i) const = 0;
00086 
00089         size_type max_size() const { return size(); }
00090 
00092         bool empty() const { return size() == 0; }
00093 
00096         iterator begin() const { return iterator(this, 0); }
00097 
00100         iterator end() const { return iterator(this, size()); }
00101 
00104         reverse_iterator rbegin() const { return reverse_iterator(end()); }
00105 
00108         reverse_iterator rend() const { return reverse_iterator(begin()); }
00109 };
00110 
00111 
00116 
00117 template <class OnType, class ReturnType, class SizeType,
00118                 class DiffType>
00119 class subscript_iterator : public std::iterator<ReturnType, SizeType>
00120 {
00121 public:
00123         subscript_iterator() { }
00124 
00127         subscript_iterator(OnType* what, SizeType pos)
00128         {
00129                 d_ = what;
00130                 i_ = pos;
00131         }
00132 
00135         bool operator ==(const subscript_iterator& j) const
00136         {
00137                 return (d_ == j.d_ && i_ == j.i_);
00138         }
00139         
00142         bool operator !=(const subscript_iterator& j) const
00143         {
00144                 return (d_ == j.d_ && i_ != j.i_);
00145         }
00146         
00150         bool operator <(const subscript_iterator& j) const
00151         {
00152                 return (d_ == j.d_ && i_ < j.i_);
00153         }
00154         
00158         bool operator >(const subscript_iterator & j) const
00159         {
00160                 return (d_ == j.d_ && i_ > j.i_);
00161         }
00162         
00166         bool operator <=(const subscript_iterator & j) const
00167         {
00168                 return (d_ == j.d_ && i_ <= j.i_);
00169         }
00170         
00174         bool operator >=(const subscript_iterator & j) const
00175         {
00176                 return (d_ == j.d_ && i_ >= j.i_);
00177         }
00178         
00181         ReturnType operator *() const { return d_->at(i_); }
00182         
00185         ReturnType operator [](SizeType n) const { return d_->at(n); }
00186         
00189         subscript_iterator& operator ++() { ++i_; return *this; }
00190 
00193         subscript_iterator operator ++(int)
00194         {
00195                 subscript_iterator tmp = *this;
00196                 ++i_;
00197                 return tmp;
00198         }
00199 
00202         subscript_iterator& operator --()
00203         {
00204                 --i_;
00205                 return *this;
00206         }
00207 
00210         subscript_iterator operator --(int)
00211         {
00212                 subscript_iterator tmp = *this;
00213                 --i_;
00214                 return tmp;
00215         }
00216 
00218         subscript_iterator& operator +=(SizeType n)
00219         {
00220                 i_ += n;
00221                 return *this;
00222         }
00223 
00225         subscript_iterator operator +(SizeType n) const
00226         {
00227                 subscript_iterator tmp = *this;
00228                 tmp.i_ += n;
00229                 return tmp;
00230         }
00231         
00233         subscript_iterator& operator -=(SizeType n)
00234         {
00235                 i_ -= n;
00236                 return *this;
00237         }
00238 
00240         subscript_iterator operator -(SizeType n) const
00241         {
00242                 subscript_iterator tmp = *this;
00243                 tmp.i_ -= n;
00244                 return tmp;
00245         }
00246         
00248         DiffType operator -(const subscript_iterator& j) const
00249         {
00250                 if (d_ == j.d_) {
00251                         return static_cast<SizeType>(i_) - j.i_;
00252                 }
00253                 return 0;
00254         }
00255 
00256 private:
00257         SizeType i_;
00258         OnType* d_;
00259 };
00260 
00261 
00262 #if !defined(DOXYGEN_IGNORE)
00263 // Doxygen will not generate documentation for this section.
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 } // end namespace mysqlpp
00277 
00278 #endif

Generated on Wed Jul 11 15:34:34 2007 for MySQL++ by doxygen 1.3.5