remove post-increment implementation as it is awfully invalid

as per github issue #5

1 files changed, 0 insertions, 5 deletions

diff --git a/include/opkele/iterator.h b/include/opkele/iterator.h
index 94da7e4..9e5b196 100644
--- a/include/opkele/iterator.h
+++ b/include/opkele/iterator.h
@@ -114,101 +114,96 @@ namespace opkele {
                     return **I; }
                 TP operator->() const {
                     return I->operator->(); }
 
                 forward_iterator_proxy<T,TR,TP>& operator++() {
                     I->advance(); return *this; }
                 forward_iterator_proxy<T,TR,TP>& operator++(int) {
                     forward_iterator_proxy<T,TR,TP> rv(*this);
                     I->advance(); return rv; }
         };
 
         template<typename IT>
             class basic_filterator : public iterator<
                                           typename IT::iterator_category,
                                           typename IT::value_type,
                                           typename IT::difference_type,
                                           typename IT::pointer,
                                           typename IT::reference> {
                 public:
                     IT it;
                     IT ei;
                     bool empty;
 
                     basic_filterator() : empty(true) { }
                     basic_filterator(const IT& _bi,const IT& _ei)
                         : it(_bi), ei(_ei) { empty = (it==ei); }
                     basic_filterator(const basic_filterator<IT>& x)
                         : it(x.it), ei(x.ei), empty(x.empty) { }
                     virtual ~basic_filterator() { }
 
                     bool operator==(const basic_filterator<IT>& x) const {
                         return empty?x.empty:(it==x.it); }
                     bool operator!=(const basic_filterator<IT>& x) const {
                         return empty!=x.empty || it!=x.it; }
 
                     typename IT::reference operator*() const {
                         assert(!empty);
                         return *it; }
                     typename IT::pointer operator->() const {
                         assert(!empty);
                         return it.operator->(); }
 
                     basic_filterator<IT>& operator++() {
                         bool found = false;
                         for(++it;!(it==ei || (found=is_interesting()));++it) ;
                         if(!found) empty=true;
                         return *this;
                     }
-                    basic_filterator<IT> operator++(int) {
-                        basic_filterator<IT> rv(*this);
-                        ++(*this);
-                        return rv;
-                    }
 
                     void prepare() {
                         bool found = false;
                         for(;!(it==ei || (found=is_interesting()));++it) ;
                         if(!found) empty = true;
                     }
                     virtual bool is_interesting() const = 0;
             };
 
         template<typename IT,typename T=typename IT::value_type::first_type,typename TR=T&,typename TP=T*>
             class map_keys_iterator : public iterator<
                                       typename IT::iterator_category,
                                       T,void,TP,TR> {
                 public:
                     typedef map_keys_iterator<IT,T,TR,TP> self_type;
                     IT it;
                     IT ei;
                     bool empty;
 
                     map_keys_iterator() : empty(true) { }
                     map_keys_iterator(const IT& _bi,
                             const IT& _ei)
                         : it(_bi), ei(_ei) { empty = (it==ei); }
                     map_keys_iterator(const self_type& x)
                         : it(x.it), ei(x.ei), empty(x.empty) { }
 
                     bool operator==(const self_type& x) const {
                         return empty?x.empty:(it==x.it); }
                     bool operator!=(const self_type& x) const {
                         return empty!=x.empty || it!=x.it; }
 
                     TR operator*() const {
                         assert(!empty);
                         return it->first; }
                     TP operator->() const {
                         assert(!empty);
                         return &(it->first); }
 
                     self_type& operator++() {
                         assert(!empty);
                         empty=((++it)==ei); return *this; }
                     self_type operator++(int) {
                         self_type rv(*this);
                         ++(*this); return rv; }
             };
 
     }
 }