1 files changed, 9 insertions, 10 deletions

diff --git a/include/opkele/iterator.h b/include/opkele/iterator.h
index 812a786..28c1c83 100644
--- a/include/opkele/iterator.h
+++ b/include/opkele/iterator.h
@@ -21,22 +21,21 @@ namespace opkele {
 
         };
 
         template<typename IT,typename T=typename IT::value_type>
         class output_iterator_proxy_impl : public basic_output_iterator_proxy_impl<T> {
             public:
                 IT i;
 
-                output_iterator_proxy_impl(const IT& i) : i(i) { }
+                output_iterator_proxy_impl(const IT& _i) : i(_i) { }
                 basic_output_iterator_proxy_impl<T>* dup() const {
                     return new output_iterator_proxy_impl<IT,T>(i); }
                 basic_output_iterator_proxy_impl<T>& operator=(const T& x) {
-                    (*i) = x;
-                }
+                    (*i) = x; return *this; }
         };
 
         template<typename T>
         class output_iterator_proxy : public iterator<output_iterator_tag,T,void,T*,T&> {
             public:
                 basic_output_iterator_proxy_impl<T> *I;
 
                 template<typename IT>
@@ -46,17 +45,17 @@ namespace opkele {
                     : I(x.I->dup()) { }
                 ~output_iterator_proxy() { delete I; }
 
                 output_iterator_proxy& operator=(const output_iterator_proxy<T>& x) {
                     delete I; I = x.I->dup(); }
 
                 output_iterator_proxy& operator*() { return *this; }
                 output_iterator_proxy& operator=(const T& x) {
-                    (**I) = x; }
+                    (**I) = x; return *this; }
 
                 output_iterator_proxy& operator++() { return *this; }
                 output_iterator_proxy& operator++(int) { return *this; }
         };
 
         template <typename T,typename TR=T&,typename TP=T*>
         class basic_forward_iterator_proxy_impl : public iterator<forward_iterator_tag,T,void,TP,TR> {
             public:
@@ -72,17 +71,17 @@ namespace opkele {
                 virtual void advance() = 0;
         };
 
         template <typename IT>
         class forward_iterator_proxy_impl : public basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer> {
             public:
                 IT i;
 
-                forward_iterator_proxy_impl(const IT& i) : i(i) { }
+                forward_iterator_proxy_impl(const IT& _i) : i(_i) { }
 
                 virtual basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>* dup() const {
                     return new forward_iterator_proxy_impl<IT>(i); }
 
                 virtual bool operator==(const basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>& x) const {
                     return i==static_cast<const forward_iterator_proxy_impl<IT>*>(&x)->i; }
                 virtual bool operator!=(const basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>& x) const {
                     return i!=static_cast<const forward_iterator_proxy_impl<IT>*>(&x)->i; }
@@ -131,18 +130,18 @@ namespace opkele {
                                           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 = (bi==ei); }
+                    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; }
@@ -180,19 +179,19 @@ namespace opkele {
                                       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 = (bi==ei); }
+                    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; }