[python] fix std unordered containers

Lib/python/pycontainer.swg

@@ -654,7 +654,7 @@ namespace swig
 }
 }
 
-%define %swig_sequence_iterator(Sequence...)
+%define %swig_sequence_iterator(Make_output_iterator_func,Sequence...)
 #if defined(SWIG_EXPORT_ITERATOR_METHODS)
   class iterator;
   class reverse_iterator;
@@ -663,15 +663,15 @@ namespace swig
 
   %typemap(out,noblock=1,fragment="SwigPySequence_Cont")
     iterator, reverse_iterator, const_iterator, const_reverse_iterator {
-    $result = SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &)),
+    $result = SWIG_NewPointerObj(Make_output_iterator_func(%static_cast($1,const $type &)),
 				 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
   }
   %typemap(out,noblock=1,fragment="SwigPySequence_Cont")
     std::pair<iterator, iterator>, std::pair<const_iterator, const_iterator> {
     $result = PyTuple_New(2);
-    PyTuple_SetItem($result,0,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
+    PyTuple_SetItem($result,0,SWIG_NewPointerObj(Make_output_iterator_func(%static_cast($1,const $type &).first),
 						 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
-    PyTuple_SetItem($result,1,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).second),
+    PyTuple_SetItem($result,1,SWIG_NewPointerObj(Make_output_iterator_func(%static_cast($1,const $type &).second),
 						 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));    
   }
 
@@ -680,7 +680,7 @@ namespace swig
   %typemap(out,noblock=1,fragment="SwigPyPairBoolOutputIterator")
     std::pair<iterator, bool>, std::pair<const_iterator, bool> {
     $result = PyTuple_New(2);
-    PyTuple_SetItem($result,0,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
+    PyTuple_SetItem($result,0,SWIG_NewPointerObj(Make_output_iterator_func(%static_cast($1,const $type &).first),
 					       swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));    
     PyTuple_SetItem($result,1,SWIG_From(bool)(%static_cast($1,const $type &).second));
   }
@@ -715,7 +715,7 @@ namespace swig
   %newobject iterator(PyObject **PYTHON_SELF);
   %extend  {
     swig::SwigPyIterator* iterator(PyObject **PYTHON_SELF) {
-      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+      return Make_output_iterator_func(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
 
 #if defined(SWIGPYTHON_BUILTIN)
@@ -764,7 +764,7 @@ namespace swig
 
 
 %define %swig_sequence_methods_common(Sequence...)
-  %swig_sequence_iterator(%arg(Sequence))
+%swig_sequence_iterator(swig::make_output_iterator,%arg(Sequence))
   %swig_container_methods(%arg(Sequence))
 
   %fragment("SwigPySequence_Base");

Lib/python/pyiterators.swg

@@ -195,6 +195,42 @@ namespace swig {
     }
   };
 
+  template<typename OutIterator, 
+	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
+	   typename FromOper = from_oper<ValueType> >
+  class SwigPyForwardIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
+  {
+  public:
+    FromOper from;
+    typedef OutIterator out_iterator;
+    typedef ValueType value_type;
+    typedef SwigPyIterator_T<out_iterator>  base;
+    typedef SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
+    
+    SwigPyForwardIteratorOpen_T(out_iterator curr, PyObject *seq)
+      : SwigPyIterator_T<OutIterator>(curr, seq)
+    {
+    }
+    
+    PyObject *value() const {
+      return from(static_cast<const value_type&>(*(base::current)));
+    }
+    
+    SwigPyIterator *copy() const
+    {
+      return new self_type(*this);
+    }
+
+    SwigPyIterator *incr(size_t n = 1)
+    {
+      while (n--) {
+	++base::current;
+      }
+      return this;
+    }
+
+  };
+
   template<typename OutIterator, 
 	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
 	   typename FromOper = from_oper<ValueType> >
@@ -237,6 +273,52 @@ namespace swig {
       return this;
     }
   };
+  template<typename OutIterator, 
+	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
+	   typename FromOper = from_oper<ValueType> >
+  class SwigPyForwardIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
+  {
+  public:
+    FromOper from;
+    typedef OutIterator out_iterator;
+    typedef ValueType value_type;
+    typedef SwigPyIterator_T<out_iterator>  base;    
+    typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
+    
+    SwigPyForwardIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
+      : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
+    {
+    }
+    
+    PyObject *value() const {
+      if (base::current == end) {
+	throw stop_iteration();
+      } else {
+	return from(static_cast<const value_type&>(*(base::current)));
+      }
+    }
+    
+    SwigPyIterator *copy() const
+    {
+      return new self_type(*this);
+    }
+
+    SwigPyIterator *incr(size_t n = 1)
+    {
+      while (n--) {
+	if (base::current == end) {
+	  throw stop_iteration();
+	} else {
+	  ++base::current;
+	}
+      }
+      return this;
+    }
+
+  private:
+    out_iterator begin;
+    out_iterator end;
+  };
 
   template<typename OutIterator, 
 	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
@@ -297,6 +379,14 @@ namespace swig {
     out_iterator end;
   };
 
+
+  template<typename OutIter>
+  inline SwigPyIterator*
+  make_output_forward_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
+  {
+    return new SwigPyForwardIteratorClosed_T<OutIter>(current, begin, end, seq);
+  }
+
   template<typename OutIter>
   inline SwigPyIterator*
   make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
@@ -304,6 +394,13 @@ namespace swig {
     return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
   }
 
+  template<typename OutIter>
+  inline SwigPyIterator*
+  make_output_forward_iterator(const OutIter& current, PyObject *seq = 0)
+  {
+    return new SwigPyForwardIteratorOpen_T<OutIter>(current, seq);
+  }
+
   template<typename OutIter>
   inline SwigPyIterator*
   make_output_iterator(const OutIter& current, PyObject *seq = 0)

Lib/python/std_map.i

@@ -149,7 +149,7 @@
 }
 
 %define %swig_map_common(Map...)
-  %swig_sequence_iterator(Map);
+  %swig_sequence_iterator(swig::make_output_iterator,Map);
   %swig_container_methods(Map)
 
 #if defined(SWIGPYTHON_BUILTIN)

Lib/python/std_set.i

@@ -33,7 +33,7 @@
 %}
 
 %define %swig_set_methods(set...)
-  %swig_sequence_iterator(set);
+  %swig_sequence_iterator(swig::make_output_iterator,set);
   %swig_container_methods(set);
 
   %extend  {

Lib/python/std_unordered_map.i

@@ -2,7 +2,7 @@
   Unordered Maps
 */
 
-%fragment("StdMapTraits","header",fragment="StdSequenceTraits")
+%fragment("StdUnorderedMapTraits","header",fragment="StdSequenceTraits")
 {
   namespace swig {
     template <class SwigPySeq, class K, class T >
@@ -74,33 +74,11 @@
       }
     };
 
-    template <class ValueType>
-    struct from_key_oper 
-    {
-      typedef const ValueType& argument_type;
-      typedef  PyObject *result_type;
-      result_type operator()(argument_type v) const
-      {
-	return swig::from(v.first);
-      }
-    };
-
-    template <class ValueType>
-    struct from_value_oper 
-    {
-      typedef const ValueType& argument_type;
-      typedef  PyObject *result_type;
-      result_type operator()(argument_type v) const
-      {
-	return swig::from(v.second);
-      }
-    };
-
     template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
-    struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
+    struct SwigPyMapForwardIterator_T : SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper>
     {
-      SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
+      SwigPyMapForwardIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
-	: SwigPyIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
+	: SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
       {
       }
     };
@@ -108,27 +86,27 @@
 
     template<class OutIterator,
 	     class FromOper = from_key_oper<typename OutIterator::value_type> >
-    struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
+    struct SwigPyMapKeyForwardIterator_T : SwigPyMapForwardIterator_T<OutIterator, FromOper>
     {
-      SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
+      SwigPyMapKeyForwardIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
-	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+	: SwigPyMapForwardIterator_T<OutIterator, FromOper>(curr, first, last, seq)
       {
       }
     };
 
     template<typename OutIter>
     inline SwigPyIterator*
-    make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
+    make_output_key_forward_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
     {
-      return new SwigPyMapKeyIterator_T<OutIter>(current, begin, end, seq);
+      return new SwigPyMapKeyForwardIterator_T<OutIter>(current, begin, end, seq);
     }
 
     template<class OutIterator,
 	     class FromOper = from_value_oper<typename OutIterator::value_type> >
-    struct SwigPyMapValueITerator_T : SwigPyMapIterator_T<OutIterator, FromOper>
+    struct SwigPyMapValueForwardIterator_T : SwigPyMapForwardIterator_T<OutIterator, FromOper>
     {
-      SwigPyMapValueITerator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
+      SwigPyMapValueForwardIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
-	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+	: SwigPyMapForwardIterator_T<OutIterator, FromOper>(curr, first, last, seq)
       {
       }
     };
@@ -136,15 +114,15 @@
 
     template<typename OutIter>
     inline SwigPyIterator*
-    make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
+    make_output_value_forward_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
     {
-      return new SwigPyMapValueITerator_T<OutIter>(current, begin, end, seq);
+      return new SwigPyMapValueForwardIterator_T<OutIter>(current, begin, end, seq);
     }
   }
 }
 
 %define %swig_unordered_map_common(Map...)
-  %swig_sequence_iterator(Map);
+  %swig_sequence_iterator(swig::make_output_forward_iterator,Map);
   %swig_container_methods(Map)
 
   %extend {
@@ -227,12 +205,12 @@
 
     %newobject key_iterator(PyObject **PYTHON_SELF);
     swig::SwigPyIterator* key_iterator(PyObject **PYTHON_SELF) {
-      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+      return swig::make_output_key_forward_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
 
     %newobject value_iterator(PyObject **PYTHON_SELF);
     swig::SwigPyIterator* value_iterator(PyObject **PYTHON_SELF) {
-      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+      return swig::make_output_value_forward_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
 
     %pythoncode %{def __iter__(self):

Lib/python/std_unordered_multimap.i

@@ -74,7 +74,7 @@
 }
 
 %define %swig_unordered_multimap_methods(Type...) 
-  %swig_map_common(Type);
+  %swig_unordered_map_common(Type);
   %extend {
     void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
       self->insert(Type::value_type(key,x));

Lib/python/std_unordered_multiset.i

@@ -41,7 +41,7 @@
   }
 %}
 
-#define %swig_unordered_multiset_methods(Set...) %swig_set_methods(Set)
+#define %swig_unordered_multiset_methods(Set...) %swig_unordered_set_methods(Set)
 
 
 

Lib/python/std_unordered_set.i

@@ -40,7 +40,7 @@
 %}
 
 %define %swig_unordered_set_methods(unordered_set...)
-  %swig_sequence_iterator(unordered_set);
+  %swig_sequence_iterator(swig::make_output_forward_iterator,unordered_set);
   %swig_container_methods(unordered_set);
 
   %extend  {