• Main Page
  • Related Pages
  • Namespaces
  • Classes
  • Files
  • Directories
  • File List
  • File Members

iterator.hpp

Go to the documentation of this file.
00001 /*
00002   CLAW - a C++ Library Absolutely Wonderful
00003 
00004   CLAW is a free library without any particular aim but being useful to 
00005   anyone.
00006 
00007   Copyright (C) 2005-2010 Julien Jorge
00008 
00009   This library is free software; you can redistribute it and/or
00010   modify it under the terms of the GNU Lesser General Public
00011   License as published by the Free Software Foundation; either
00012   version 2.1 of the License, or (at your option) any later version.
00013 
00014   This library is distributed in the hope that it will be useful,
00015   but WITHOUT ANY WARRANTY; without even the implied warranty of
00016   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017   Lesser General Public License for more details.
00018 
00019   You should have received a copy of the GNU Lesser General Public
00020   License along with this library; if not, write to the Free Software
00021   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
00022 
00023   contact: julien_jorge@yahoo.fr
00024 */
00031 #ifndef __CLAW_ITERATOR_HPP__
00032 #define __CLAW_ITERATOR_HPP__
00033 
00034 #include <iterator>
00035 
00036 namespace claw
00037 {
00038   /*-------------------------------------------------------------------------*/
00043   template< typename Category, typename Value, typename Iterator,
00044       typename Function >
00045   class wrapped_iterator_by_category
00046   {
00047 
00048   }; // class wrapped_iterator_by_category
00049 
00050   /*-------------------------------------------------------------------------*/
00055   template<typename Value, typename Iterator, typename Function>
00056   class wrapped_iterator_by_category
00057   <std::forward_iterator_tag, Value, Iterator, Function>
00058   {
00059   public:
00060     typedef typename std::iterator_traits<Iterator>::difference_type
00061     difference_type;
00062     typedef Value value_type;
00063     typedef value_type* pointer;
00064     typedef value_type& reference;
00065     typedef typename std::iterator_traits<Iterator>::iterator_category
00066     iterator_category;
00067 
00068     typedef
00069     wrapped_iterator_by_category
00070     <std::forward_iterator_tag, Value, Iterator, Function>
00071     self_type;
00072 
00073   public:
00074     wrapped_iterator_by_category() {}
00075     wrapped_iterator_by_category( const Iterator& it )
00076       : m_it(it)
00077     { }
00078     wrapped_iterator_by_category( const Iterator& it, const Function& f )
00079       : m_it(it), m_fun(f)
00080     { }
00081     template<typename C, typename V, typename I, typename F>
00082     wrapped_iterator_by_category
00083     ( const wrapped_iterator_by_category<C, V, I, F>& that )
00084       : m_it(that.get_iterator()), m_fun(that.get_function())
00085     { }
00086 
00087     const Iterator& get_iterator() const { return m_it; }
00088     const Function& get_function() const { return m_fun; }
00089 
00090     self_type& operator++()
00091     {
00092       ++m_it;
00093       return *this;
00094     }
00095 
00096     self_type operator++(int)
00097     {
00098       self_type tmp(*this);
00099       ++m_it;
00100       return tmp;
00101     }
00102 
00103     reference operator*() const { return m_fun(*m_it); }
00104     pointer operator->() const { return &m_fun(*m_it); }
00105 
00106     bool operator==( const self_type& that ) const { return m_it == that.m_it; }
00107     bool operator!=( const self_type& that ) const { return m_it != that.m_it; }
00108     bool operator==( const Iterator& it ) const { return m_it == it; }
00109     bool operator!=( const Iterator& it ) const { return m_it != it; }
00110 
00111   private:
00113     Iterator m_it;
00114 
00116     Function m_fun;
00117 
00118   }; // class wrapped_iterator_by_category [forward_iterator_tag]
00119 
00120   /*-------------------------------------------------------------------------*/
00126   template<typename Value, typename Iterator, typename Function>
00127   class wrapped_iterator_by_category
00128   <std::bidirectional_iterator_tag, Value, Iterator, Function>
00129   {
00130   public:
00131     typedef typename std::iterator_traits<Iterator>::difference_type
00132     difference_type;
00133     typedef Value value_type;
00134     typedef value_type* pointer;
00135     typedef value_type& reference;
00136     typedef typename std::iterator_traits<Iterator>::iterator_category
00137     iterator_category;
00138 
00139     typedef
00140     wrapped_iterator_by_category
00141     <std::bidirectional_iterator_tag, Value, Iterator, Function> self_type;
00142 
00143   public:
00144     wrapped_iterator_by_category() {}
00145     wrapped_iterator_by_category( const Iterator& it )
00146       : m_it(it)
00147     { }
00148     wrapped_iterator_by_category( const Iterator& it, const Function& f )
00149       : m_it(it), m_fun(f)
00150     { }
00151     template<typename C, typename V, typename I, typename F>
00152     wrapped_iterator_by_category
00153     ( const wrapped_iterator_by_category<C, V, I, F>& that )
00154       : m_it(that.get_iterator()), m_fun(that.get_function())
00155     { }
00156 
00157     const Iterator& get_iterator() const { return m_it; }
00158     const Function& get_function() const { return m_fun; }
00159 
00160     self_type& operator++()
00161     {
00162       ++m_it;
00163       return *this;
00164     }
00165 
00166     self_type operator++(int)
00167     {
00168       self_type tmp(*this);
00169       ++m_it;
00170       return tmp;
00171     }
00172 
00173     self_type& operator--()
00174     {
00175       --m_it;
00176       return *this;
00177     }
00178 
00179     self_type operator--(int)
00180     {
00181       self_type tmp(*this);
00182       --m_it;
00183       return tmp;
00184     }
00185 
00186     reference operator*() const { return m_fun(*m_it); }
00187     pointer operator->() const { return &m_fun(*m_it); }
00188     
00189     bool operator==( const self_type& that ) const { return m_it == that.m_it; }
00190     bool operator!=( const self_type& that ) const { return m_it != that.m_it; }
00191     bool operator==( const Iterator& it ) const { return m_it == it; }
00192     bool operator!=( const Iterator& it ) const { return m_it != it; }
00193 
00194  private:
00196     Iterator m_it;
00197 
00199     Function m_fun;
00200 
00201   }; // class wrapped_iterator_by_category [bidirectional_iterator_tag]
00202 
00203   /*-------------------------------------------------------------------------*/
00208   template<typename Value, typename Iterator, typename Function>
00209   class wrapped_iterator_by_category
00210   <std::random_access_iterator_tag, Value, Iterator, Function>
00211   {
00212   public:
00213     typedef typename std::iterator_traits<Iterator>::difference_type
00214     difference_type;
00215     typedef Value value_type;
00216     typedef value_type* pointer;
00217     typedef value_type& reference;
00218     typedef typename std::iterator_traits<Iterator>::iterator_category
00219     iterator_category;
00220 
00221     typedef
00222     wrapped_iterator_by_category
00223     <std::random_access_iterator_tag, Value, Iterator, Function>
00224     self_type;
00225 
00226   public:
00227     wrapped_iterator_by_category() {}
00228     wrapped_iterator_by_category( const Iterator& it )
00229       : m_it(it)
00230     { }
00231     wrapped_iterator_by_category( const Iterator& it, const Function& f )
00232       : m_it(it), m_fun(f)
00233     { }
00234     template<typename V, typename I>
00235     wrapped_iterator_by_category
00236     ( const wrapped_iterator_by_category
00237       <std::random_access_iterator_tag, V, I, Function>& that )
00238       : m_it(that.m_it), m_fun(that.m_fun)
00239     { }
00240     template<typename C, typename V, typename I, typename F>
00241     wrapped_iterator_by_category
00242     ( const wrapped_iterator_by_category<C, V, I, F>& that )
00243       : m_it(that.get_iterator()), m_fun(that.get_function())
00244     { }
00245 
00246     const Iterator& get_iterator() const { return m_it; }
00247     const Function& get_function() const { return m_fun; }
00248 
00249     self_type& operator++()
00250     {
00251       ++m_it;
00252       return *this;
00253     }
00254 
00255     self_type operator++(int)
00256     {
00257       self_type tmp(*this);
00258       ++m_it;
00259       return tmp;
00260     }
00261 
00262     self_type& operator--()
00263     {
00264       --m_it;
00265       return *this;
00266     }
00267 
00268     self_type operator--(int)
00269     {
00270       self_type tmp(*this);
00271       --m_it;
00272       return tmp;
00273     }
00274 
00275     reference operator*() const { return m_fun(*m_it); }
00276     pointer operator->() const { return &m_fun(*m_it); }
00277 
00278     bool operator==( const self_type& that ) const { return m_it == that.m_it; }
00279     bool operator!=( const self_type& that ) const { return m_it != that.m_it; }
00280     bool operator==( const Iterator& it ) const { return m_it == it; }
00281     bool operator!=( const Iterator& it ) const { return m_it != it; }
00282     bool operator<( const self_type& that ) const { return m_it < that.m_it; }
00283     bool operator<=( const self_type& that ) const { return m_it <= that.m_it; }
00284     bool operator>( const self_type& that ) const { return m_it > that.m_it; }
00285     bool operator>=( const self_type& that ) const { return m_it >= that.m_it; }
00286 
00287     self_type& operator+=(int n)
00288     {
00289       m_it += n;
00290       return *this;
00291     }
00292 
00293     self_type operator+(int n) const
00294     {
00295       self_type result(*this);
00296       result += n;
00297       return result;
00298     }
00299 
00300     self_type& operator-=(int n) { return *this += -n; }
00301 
00302     self_type operator-(int n) const
00303     {
00304       self_type result(*this);
00305       result -= n;
00306       return result;
00307     }
00308 
00309     reference operator[](int n) { return m_fun(m_it[n]); }
00310 
00311   private:
00313     Iterator m_it;
00314 
00316     Function m_fun;
00317 
00318   }; // class wrapped_iterator_by_category [random_access_iterator_tag]
00319 
00320   template<typename Value, typename Iterator, typename Function>
00321   wrapped_iterator_by_category
00322   <std::random_access_iterator_tag, Value, Iterator, Function>
00323   operator+
00324   ( int n,
00325     const wrapped_iterator_by_category
00326     < std::random_access_iterator_tag, Value, Iterator, Function >& it )
00327   {
00328     return it + n;
00329   }
00330 
00331   template<typename Value, typename Iterator, typename Function>
00332   wrapped_iterator_by_category
00333   <std::random_access_iterator_tag, Value, Iterator, Function>
00334   operator-
00335   ( int n,
00336     const wrapped_iterator_by_category
00337     < std::random_access_iterator_tag, Value, Iterator, Function >& it )
00338   {
00339     return it - n;
00340   }
00341 
00342   /*-------------------------------------------------------------------------*/
00355   template <typename Value, typename Iterator, typename Function>
00356   class wrapped_iterator
00357   {
00358   public:
00360     typedef wrapped_iterator_by_category
00361     < typename std::iterator_traits<Iterator>::iterator_category,
00362       Value, Iterator, Function >
00363     iterator_type;
00364 
00365   }; // class wrapped_iterator
00366 } // namespace claw
00367 
00368 #endif // __CLAW_ITERATOR_HPP__

Generated on Fri Dec 24 2010 13:18:32 for CLAW Library (a C++ Library Absolutely Wonderful) by  doxygen 1.7.2