Changeset 1539


Ignore:
Timestamp:
Sep 30, 2008, 5:36:02 AM (13 years ago)
Author:
Peter
Message:

using boost in Container2DIterator

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/yat/utility/Container2DIterator.h

    r1487 r1539  
    2727#include "yat_assert.h"
    2828
     29#include <boost/iterator/iterator_facade.hpp>
     30
    2931#include <iterator>
    3032#include <stddef.h>
     
    4345           class Policy = IteratorPolicy<Container, reference, value> >
    4446  class Container2DIterator
    45     : public std::iterator<std::random_access_iterator_tag, value, size_t,
    46                            pointer, reference>
     47    : public boost::iterator_facade<
     48    Container2DIterator<Container, value, pointer, reference, Policy>
     49    , value
     50    , std::random_access_iterator_tag
     51    , reference>
    4752  {
    4853  public:
     
    9196    }
    9297
    93     /**
    94        \return element
    95      */
    96     reference operator*(void) const
     98  private:
     99    friend class boost::iterator_core_access;
     100
     101    Container* container_;
     102    size_t index_;
     103    Policy ip_;
     104
     105    void advance(int n) { index_+=n; }
     106
     107    void decrement(void) { --index_; }
     108
     109    int distance_to(const Container2DIterator& other) const
     110    { return other.index_ - index_; }
     111
     112    reference dereference(void) const
    97113    {
    98114      yat_assert<std::out_of_range>(index_ < this->size(),
    99                                     "Container2DIterator::operator*");
     115                                    "Container2DIterator::dereference");
    100116      return ip_.dereference(*container_, row(index_), column(index_));
    101117    }
    102118
    103     /**
    104        \return element \a n steps forward
    105      */
    106     reference operator[](size_t n) const
    107     {
    108       yat_assert<std::out_of_range>(index_+n < this->size(),
    109                                     "Container2DIterator::operator[]");
    110       return ip_.dereference(*container_, row(index_+n), column(index_+n));
    111     }
     119    bool equal(const Container2DIterator& other) const
     120    { return index_ == other.index_; }
    112121
    113     /**
    114        \brief pre-increment
    115 
    116        \return reference to *this
    117      */
    118     Container2DIterator& operator++(void) { ++index_; return *this; }
    119 
    120     /**
    121        \brief post-increment
    122 
    123        \return copy of iterator prior increment
    124      */
    125     Container2DIterator operator++(int)
    126     { self tmp(*this); ++index_; return tmp;}
    127 
    128     /**
    129        \brief iterate \f$ n \f$ steps forward
    130 
    131        \return reference to resulting iterator
    132      */
    133     Container2DIterator& operator+=(int n) { index_+=n; return *this; }
    134 
    135     /**
    136        \brief post-decrement
    137 
    138        \return copy of iterator prior decrement
    139      */
    140     Container2DIterator operator--(int)
    141     { self tmp(*this); --index_; return tmp;}
    142 
    143     /**
    144        \brief pre-decrement
    145 
    146        \return reference to resulting iterator
    147      */
    148     Container2DIterator& operator--(void) { --index_; return *this; }
    149 
    150     /**
    151        \brief iterate \f$ n \f$ steps backwards
    152 
    153        \return reference to resulting iterator
    154      */
    155     Container2DIterator& operator-=(int n) { index_-=n; return *this; }
    156 
    157     /**
    158        \brief addition operator
    159 
    160        \return copy of resulting iterator
    161      */
    162     friend Container2DIterator operator+(const Container2DIterator& lhs,
    163                                          size_t n)
    164     { return self(*lhs.container_, lhs.index_+n); }
    165 
    166     /**
    167        \brief subtraction operator
    168 
    169        \return copy of resulting iterator
    170      */
    171     friend Container2DIterator operator-(const Container2DIterator& lhs,
    172                                          size_t n)
    173     { return self(*lhs.container_, lhs.index_-n); }
    174 
    175     /**
    176        \brief difference operator
    177 
    178        \return distance between \a lhs and \a rhs
    179      */
    180     friend size_t operator-(const Container2DIterator& lhs, \
    181                             const Container2DIterator& rhs)
    182     {
    183       yat_assert<std::runtime_error>(lhs.container_==rhs.container_,
    184                                      "Container2DIterator::operator-");
    185       return lhs.index_-rhs.index_;
    186     }
    187 
    188    
    189     /**
    190        \brief Equality operator
    191 
    192        \return True if \a lhs and \a rhs are pointing to same element
    193      */
    194     friend bool operator==(const self& lhs, const self& rhs)
    195     {
    196       yat_assert<std::runtime_error>(lhs.container_==rhs.container_,
    197                                      "Container2DIterator::operator==");
    198       return lhs.index_==rhs.index_;
    199     }
    200    
    201     /**
    202        \brief Non-equality operator
    203 
    204        \return False if \a lhs and \a rhs are pointing to same element
    205      */
    206     friend bool operator!=(const Container2DIterator& lhs,
    207                            const Container2DIterator& rhs)
    208     {
    209       yat_assert<std::runtime_error>(lhs.container_==rhs.container_,
    210                                      "Container2DIterator::operator!=");
    211       return !(lhs==rhs);
    212     }
    213    
    214     /**
    215        \brief Less operator
    216      */
    217     friend bool operator<(const self& lhs, const self& rhs)
    218     {
    219       yat_assert<std::runtime_error>(lhs.container_==rhs.container_,
    220                                      "Container2DIterator::operator<");
    221       return lhs.index_<rhs.index_;
    222     }
    223    
    224     /**
    225        \brief Less equal operator
    226      */
    227     friend bool operator<=(const self& lhs, const self& rhs)
    228     {
    229       yat_assert<std::runtime_error>(lhs.container_==rhs.container_,
    230                                      "Container2DIterator::operator<=");
    231       return lhs.index_<=rhs.index_;
    232     }
    233    
    234     /**
    235        \brief Larger operator
    236      */
    237     friend bool operator>(const self& lhs, const self& rhs)
    238     {
    239       yat_assert<std::runtime_error>(lhs.container_==rhs.container_,
    240                                      "Container2DIterator::operator>");
    241       return lhs.index_>rhs.index_;
    242     }
    243    
    244     /**
    245        \brief Larger equal operator
    246      */
    247     friend bool operator>=(const self& lhs, const self& rhs)
    248     {
    249       yat_assert<std::runtime_error>(lhs.container_==rhs.container_,
    250                                      "Container2DIterator::operator>=");
    251       return lhs.index_>=rhs.index_;
    252     }
    253    
    254   private:
    255     Container* container_;
    256     size_t index_;
    257     Policy ip_;
     122    void increment(void) { ++index_; }
    258123
    259124    size_t column(size_t i) const
Note: See TracChangeset for help on using the changeset viewer.