summaryrefslogtreecommitdiffstats
path: root/contrib/tools/swig/Lib/python
diff options
context:
space:
mode:
authorrobot-piglet <[email protected]>2023-12-02 01:45:21 +0300
committerrobot-piglet <[email protected]>2023-12-02 02:42:50 +0300
commit9c43d58f75cf086b744cf4fe2ae180e8f37e4a0c (patch)
tree9f88a486917d371d099cd712efd91b4c122d209d /contrib/tools/swig/Lib/python
parent32fb6dda1feb24f9ab69ece5df0cb9ec238ca5e6 (diff)
Intermediate changes
Diffstat (limited to 'contrib/tools/swig/Lib/python')
-rw-r--r--contrib/tools/swig/Lib/python/exception.i6
-rw-r--r--contrib/tools/swig/Lib/python/pycontainer.swg1082
-rw-r--r--contrib/tools/swig/Lib/python/pyiterators.swg458
-rw-r--r--contrib/tools/swig/Lib/python/pystdcommon.swg265
-rw-r--r--contrib/tools/swig/Lib/python/pywstrings.swg85
-rw-r--r--contrib/tools/swig/Lib/python/std_alloc.i1
-rw-r--r--contrib/tools/swig/Lib/python/std_char_traits.i1
-rw-r--r--contrib/tools/swig/Lib/python/std_common.i74
-rw-r--r--contrib/tools/swig/Lib/python/std_container.i2
-rw-r--r--contrib/tools/swig/Lib/python/std_except.i1
-rw-r--r--contrib/tools/swig/Lib/python/std_string.i1
-rw-r--r--contrib/tools/swig/Lib/python/std_vector.i34
-rw-r--r--contrib/tools/swig/Lib/python/wchar.i21
13 files changed, 2031 insertions, 0 deletions
diff --git a/contrib/tools/swig/Lib/python/exception.i b/contrib/tools/swig/Lib/python/exception.i
new file mode 100644
index 00000000000..bb0b15c9dde
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/exception.i
@@ -0,0 +1,6 @@
+%include <typemaps/exception.swg>
+
+
+%insert("runtime") {
+ %define_as(SWIG_exception(code, msg), %block(%error(code, msg); SWIG_fail; ))
+}
diff --git a/contrib/tools/swig/Lib/python/pycontainer.swg b/contrib/tools/swig/Lib/python/pycontainer.swg
new file mode 100644
index 00000000000..d6fdff08711
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/pycontainer.swg
@@ -0,0 +1,1082 @@
+/* -----------------------------------------------------------------------------
+ * pycontainer.swg
+ *
+ * Python sequence <-> C++ container wrapper
+ *
+ * This wrapper, and its iterator, allows a general use (and reuse) of
+ * the mapping between C++ and Python, thanks to the C++ templates.
+ *
+ * Of course, it needs the C++ compiler to support templates, but
+ * since we will use this wrapper with the STL containers, that should
+ * be the case.
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <iostream>
+
+#if PY_VERSION_HEX >= 0x03020000
+# define SWIGPY_SLICEOBJECT PyObject
+#else
+# define SWIGPY_SLICEOBJECT PySliceObject
+#endif
+%}
+
+
+#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
+# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
+# define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
+# endif
+#endif
+
+%include <pyiterators.swg>
+
+/**** The PySequence C++ Wrap ***/
+
+%fragment("<stdexcept>");
+
+%include <std_except.i>
+
+%fragment("container_owner_attribute_init", "init") {
+ // thread safe initialization
+ swig::container_owner_attribute();
+}
+
+%fragment("reference_container_owner", "header", fragment="container_owner_attribute_init") {
+namespace swig {
+ static PyObject* container_owner_attribute() {
+ static PyObject* attr = SWIG_Python_str_FromChar("__swig_container");
+ return attr;
+ }
+
+ template <typename T>
+ struct container_owner {
+ // By default, do not add the back-reference (for value types)
+ // Specialization below will check the reference for pointer types.
+ static bool back_reference(PyObject* /*child*/, PyObject* /*owner*/) {
+ return false;
+ }
+ };
+
+ template <>
+ struct container_owner<swig::pointer_category> {
+ /*
+ * Call to add a back-reference to the owning object when returning a
+ * reference from a container. Will only set the reference if child
+ * is a SWIG wrapper object that does not own the pointer.
+ *
+ * returns whether the reference was set or not
+ */
+ static bool back_reference(PyObject* child, PyObject* owner) {
+ SwigPyObject* swigThis = SWIG_Python_GetSwigThis(child);
+ if (swigThis && (swigThis->own & SWIG_POINTER_OWN) != SWIG_POINTER_OWN) {
+ return PyObject_SetAttr(child, container_owner_attribute(), owner) != -1;
+ }
+ return false;
+ }
+ };
+}
+}
+
+%fragment(SWIG_Traits_frag(swig::SwigPtr_PyObject),"header",fragment="StdTraits") {
+namespace swig {
+ template <> struct traits<SwigPtr_PyObject > {
+ typedef value_category category;
+ static const char* type_name() { return "SwigPtr_PyObject"; }
+ };
+
+ template <> struct traits_from<SwigPtr_PyObject> {
+ typedef SwigPtr_PyObject value_type;
+ static PyObject *from(const value_type& val) {
+ PyObject *obj = static_cast<PyObject *>(val);
+ Py_XINCREF(obj);
+ return obj;
+ }
+ };
+
+ template <>
+ struct traits_check<SwigPtr_PyObject, value_category> {
+ static bool check(SwigPtr_PyObject) {
+ return true;
+ }
+ };
+
+ template <> struct traits_asval<SwigPtr_PyObject > {
+ typedef SwigPtr_PyObject value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ if (val) *val = obj;
+ return SWIG_OK;
+ }
+ };
+}
+}
+
+%fragment(SWIG_Traits_frag(swig::SwigVar_PyObject),"header",fragment="StdTraits") {
+namespace swig {
+ template <> struct traits<SwigVar_PyObject > {
+ typedef value_category category;
+ static const char* type_name() { return "SwigVar_PyObject"; }
+ };
+
+ template <> struct traits_from<SwigVar_PyObject> {
+ typedef SwigVar_PyObject value_type;
+ static PyObject *from(const value_type& val) {
+ PyObject *obj = static_cast<PyObject *>(val);
+ Py_XINCREF(obj);
+ return obj;
+ }
+ };
+
+ template <>
+ struct traits_check<SwigVar_PyObject, value_category> {
+ static bool check(SwigVar_PyObject) {
+ return true;
+ }
+ };
+
+ template <> struct traits_asval<SwigVar_PyObject > {
+ typedef SwigVar_PyObject value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ if (val) *val = obj;
+ return SWIG_OK;
+ }
+ };
+}
+}
+
+%fragment("SwigPySequence_Base","header",fragment="<stddef.h>",fragment="StdTraits")
+{
+%#include <functional>
+
+namespace std {
+ template <>
+ struct less <PyObject *>
+ {
+ bool
+ operator()(PyObject * v, PyObject *w) const
+ {
+ bool res;
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+ res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
+ /* This may fall into a case of inconsistent
+ eg. ObjA > ObjX > ObjB
+ but ObjA < ObjB
+ */
+ if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
+ {
+ /* Objects can't be compared, this mostly occurred in Python 3.0 */
+ /* Compare their ptr directly for a workaround */
+ res = (v < w);
+ PyErr_Clear();
+ }
+ SWIG_PYTHON_THREAD_END_BLOCK;
+ return res;
+ }
+ };
+
+ template <>
+ struct less <swig::SwigPtr_PyObject>
+ {
+ bool
+ operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
+ {
+ return std::less<PyObject *>()(v, w);
+ }
+ };
+
+ template <>
+ struct less <swig::SwigVar_PyObject>
+ {
+ bool
+ operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
+ {
+ return std::less<PyObject *>()(v, w);
+ }
+ };
+
+}
+
+namespace swig {
+ template <> struct traits<PyObject *> {
+ typedef value_category category;
+ static const char* type_name() { return "PyObject *"; }
+ };
+
+ template <> struct traits_asval<PyObject * > {
+ typedef PyObject * value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ if (val) *val = obj;
+ return SWIG_OK;
+ }
+ };
+
+ template <>
+ struct traits_check<PyObject *, value_category> {
+ static bool check(PyObject *) {
+ return true;
+ }
+ };
+
+ template <> struct traits_from<PyObject *> {
+ typedef PyObject * value_type;
+ static PyObject *from(const value_type& val) {
+ Py_XINCREF(val);
+ return val;
+ }
+ };
+
+}
+
+namespace swig {
+ template <class Difference>
+ inline size_t
+ check_index(Difference i, size_t size, bool insert = false) {
+ if ( i < 0 ) {
+ if ((size_t) (-i) <= size)
+ return (size_t) (i + size);
+ } else if ( (size_t) i < size ) {
+ return (size_t) i;
+ } else if (insert && ((size_t) i == size)) {
+ return size;
+ }
+ throw std::out_of_range("index out of range");
+ }
+
+ template <class Difference>
+ void
+ slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
+ if (step == 0) {
+ throw std::invalid_argument("slice step cannot be zero");
+ } else if (step > 0) {
+ // Required range: 0 <= i < size, 0 <= j < size, i <= j
+ if (i < 0) {
+ ii = 0;
+ } else if (i < (Difference)size) {
+ ii = i;
+ } else if (insert && (i >= (Difference)size)) {
+ ii = (Difference)size;
+ }
+ if (j < 0) {
+ jj = 0;
+ } else {
+ jj = (j < (Difference)size) ? j : (Difference)size;
+ }
+ if (jj < ii)
+ jj = ii;
+ } else {
+ // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
+ if (i < -1) {
+ ii = -1;
+ } else if (i < (Difference) size) {
+ ii = i;
+ } else if (i >= (Difference)(size-1)) {
+ ii = (Difference)(size-1);
+ }
+ if (j < -1) {
+ jj = -1;
+ } else {
+ jj = (j < (Difference)size ) ? j : (Difference)(size-1);
+ }
+ if (ii < jj)
+ ii = jj;
+ }
+ }
+
+ template <class Sequence, class Difference>
+ inline typename Sequence::iterator
+ getpos(Sequence* self, Difference i) {
+ typename Sequence::iterator pos = self->begin();
+ std::advance(pos, check_index(i,self->size()));
+ return pos;
+ }
+
+ template <class Sequence, class Difference>
+ inline typename Sequence::const_iterator
+ cgetpos(const Sequence* self, Difference i) {
+ typename Sequence::const_iterator pos = self->begin();
+ std::advance(pos, check_index(i,self->size()));
+ return pos;
+ }
+
+ template <class Sequence>
+ inline void
+ erase(Sequence* seq, const typename Sequence::iterator& position) {
+ seq->erase(position);
+ }
+
+ template <class Sequence>
+ struct traits_reserve {
+ static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
+ // This should be specialized for types that support reserve
+ }
+ };
+
+ template <class Sequence, class Difference>
+ inline Sequence*
+ getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj);
+
+ if (step > 0) {
+ typename Sequence::const_iterator sb = self->begin();
+ typename Sequence::const_iterator se = self->begin();
+ std::advance(sb,ii);
+ std::advance(se,jj);
+ if (step == 1) {
+ return new Sequence(sb, se);
+ } else {
+ Sequence *sequence = new Sequence();
+ swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
+ typename Sequence::const_iterator it = sb;
+ while (it!=se) {
+ sequence->push_back(*it);
+ for (Py_ssize_t c=0; c<step && it!=se; ++c)
+ it++;
+ }
+ return sequence;
+ }
+ } else {
+ Sequence *sequence = new Sequence();
+ swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
+ typename Sequence::const_reverse_iterator sb = self->rbegin();
+ typename Sequence::const_reverse_iterator se = self->rbegin();
+ std::advance(sb,size-ii-1);
+ std::advance(se,size-jj-1);
+ typename Sequence::const_reverse_iterator it = sb;
+ while (it!=se) {
+ sequence->push_back(*it);
+ for (Py_ssize_t c=0; c<-step && it!=se; ++c)
+ it++;
+ }
+ return sequence;
+ }
+ }
+
+ template <class Sequence, class Difference, class InputSeq>
+ inline void
+ setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj, true);
+ if (step > 0) {
+ if (step == 1) {
+ size_t ssize = jj - ii;
+ if (ssize <= is.size()) {
+ // expanding/staying the same size
+ swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.size());
+ typename Sequence::iterator sb = self->begin();
+ typename InputSeq::const_iterator isit = is.begin();
+ std::advance(sb,ii);
+ std::advance(isit, jj - ii);
+ self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
+ } else {
+ // shrinking
+ typename Sequence::iterator sb = self->begin();
+ typename Sequence::iterator se = self->begin();
+ std::advance(sb,ii);
+ std::advance(se,jj);
+ self->erase(sb,se);
+ sb = self->begin();
+ std::advance(sb,ii);
+ self->insert(sb, is.begin(), is.end());
+ }
+ } else {
+ size_t replacecount = (jj - ii + step - 1) / step;
+ if (is.size() != replacecount) {
+ char msg[1024];
+ sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
+ throw std::invalid_argument(msg);
+ }
+ typename Sequence::const_iterator isit = is.begin();
+ typename Sequence::iterator it = self->begin();
+ std::advance(it,ii);
+ for (size_t rc=0; rc<replacecount && it != self->end(); ++rc) {
+ *it++ = *isit++;
+ for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
+ it++;
+ }
+ }
+ } else {
+ size_t replacecount = (ii - jj - step - 1) / -step;
+ if (is.size() != replacecount) {
+ char msg[1024];
+ sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
+ throw std::invalid_argument(msg);
+ }
+ typename Sequence::const_iterator isit = is.begin();
+ typename Sequence::reverse_iterator it = self->rbegin();
+ std::advance(it,size-ii-1);
+ for (size_t rc=0; rc<replacecount && it != self->rend(); ++rc) {
+ *it++ = *isit++;
+ for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
+ it++;
+ }
+ }
+ }
+
+ template <class Sequence, class Difference>
+ inline void
+ delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj, true);
+ if (step > 0) {
+ typename Sequence::iterator sb = self->begin();
+ std::advance(sb,ii);
+ if (step == 1) {
+ typename Sequence::iterator se = self->begin();
+ std::advance(se,jj);
+ self->erase(sb,se);
+ } else {
+ typename Sequence::iterator it = sb;
+ size_t delcount = (jj - ii + step - 1) / step;
+ while (delcount) {
+ it = self->erase(it);
+ for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
+ it++;
+ delcount--;
+ }
+ }
+ } else {
+ typename Sequence::reverse_iterator sb = self->rbegin();
+ std::advance(sb,size-ii-1);
+ typename Sequence::reverse_iterator it = sb;
+ size_t delcount = (ii - jj - step - 1) / -step;
+ while (delcount) {
+ it = typename Sequence::reverse_iterator(self->erase((++it).base()));
+ for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
+ it++;
+ delcount--;
+ }
+ }
+ }
+}
+}
+
+%fragment("SwigPySequence_Cont","header",
+ fragment="StdTraits",
+ fragment="SwigPySequence_Base",
+ fragment="SwigPyIterator_T")
+{
+namespace swig
+{
+ template <class T>
+ struct SwigPySequence_Ref
+ {
+ SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
+ : _seq(seq), _index(index)
+ {
+ }
+
+ operator T () const
+ {
+ swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
+ try {
+ return swig::as<T>(item);
+ } catch (const std::invalid_argument& e) {
+ char msg[1024];
+ sprintf(msg, "in sequence element %d ", (int)_index);
+ if (!PyErr_Occurred()) {
+ ::%type_error(swig::type_name<T>());
+ }
+ SWIG_Python_AddErrorMsg(msg);
+ SWIG_Python_AddErrorMsg(e.what());
+ throw;
+ }
+ }
+
+ SwigPySequence_Ref& operator=(const T& v)
+ {
+ PySequence_SetItem(_seq, _index, swig::from<T>(v));
+ return *this;
+ }
+
+ private:
+ PyObject* _seq;
+ Py_ssize_t _index;
+ };
+
+ template <class T>
+ struct SwigPySequence_ArrowProxy
+ {
+ SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
+ const T* operator->() const { return &m_value; }
+ operator const T*() const { return &m_value; }
+ T m_value;
+ };
+
+ template <class T, class Reference >
+ struct SwigPySequence_InputIterator
+ {
+ typedef SwigPySequence_InputIterator<T, Reference > self;
+
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef Reference reference;
+ typedef T value_type;
+ typedef T* pointer;
+ typedef Py_ssize_t difference_type;
+
+ SwigPySequence_InputIterator()
+ {
+ }
+
+ SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
+ : _seq(seq), _index(index)
+ {
+ }
+
+ reference operator*() const
+ {
+ return reference(_seq, _index);
+ }
+
+ SwigPySequence_ArrowProxy<T>
+ operator->() const {
+ return SwigPySequence_ArrowProxy<T>(operator*());
+ }
+
+ bool operator==(const self& ri) const
+ {
+ return (_index == ri._index) && (_seq == ri._seq);
+ }
+
+ bool operator!=(const self& ri) const
+ {
+ return !(operator==(ri));
+ }
+
+ self& operator ++ ()
+ {
+ ++_index;
+ return *this;
+ }
+
+ self& operator -- ()
+ {
+ --_index;
+ return *this;
+ }
+
+ self& operator += (difference_type n)
+ {
+ _index += n;
+ return *this;
+ }
+
+ self operator +(difference_type n) const
+ {
+ return self(_seq, _index + n);
+ }
+
+ self& operator -= (difference_type n)
+ {
+ _index -= n;
+ return *this;
+ }
+
+ self operator -(difference_type n) const
+ {
+ return self(_seq, _index - n);
+ }
+
+ difference_type operator - (const self& ri) const
+ {
+ return _index - ri._index;
+ }
+
+ bool operator < (const self& ri) const
+ {
+ return _index < ri._index;
+ }
+
+ reference
+ operator[](difference_type n) const
+ {
+ return reference(_seq, _index + n);
+ }
+
+ private:
+ PyObject* _seq;
+ difference_type _index;
+ };
+
+ // STL container wrapper around a Python sequence
+ template <class T>
+ struct SwigPySequence_Cont
+ {
+ typedef SwigPySequence_Ref<T> reference;
+ typedef const SwigPySequence_Ref<T> const_reference;
+ typedef T value_type;
+ typedef T* pointer;
+ typedef Py_ssize_t difference_type;
+ typedef size_t size_type;
+ typedef const pointer const_pointer;
+ typedef SwigPySequence_InputIterator<T, reference> iterator;
+ typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
+
+ SwigPySequence_Cont(PyObject* seq) : _seq(0)
+ {
+ if (!PySequence_Check(seq)) {
+ throw std::invalid_argument("a sequence is expected");
+ }
+ _seq = seq;
+ Py_INCREF(_seq);
+ }
+
+ ~SwigPySequence_Cont()
+ {
+ Py_XDECREF(_seq);
+ }
+
+ size_type size() const
+ {
+ return static_cast<size_type>(PySequence_Size(_seq));
+ }
+
+ bool empty() const
+ {
+ return size() == 0;
+ }
+
+ iterator begin()
+ {
+ return iterator(_seq, 0);
+ }
+
+ const_iterator begin() const
+ {
+ return const_iterator(_seq, 0);
+ }
+
+ iterator end()
+ {
+ return iterator(_seq, size());
+ }
+
+ const_iterator end() const
+ {
+ return const_iterator(_seq, size());
+ }
+
+ reference operator[](difference_type n)
+ {
+ return reference(_seq, n);
+ }
+
+ const_reference operator[](difference_type n) const
+ {
+ return const_reference(_seq, n);
+ }
+
+ bool check() const
+ {
+ Py_ssize_t s = size();
+ for (Py_ssize_t i = 0; i < s; ++i) {
+ swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
+ if (!swig::check<value_type>(item))
+ return false;
+ }
+ return true;
+ }
+
+ private:
+ PyObject* _seq;
+ };
+
+}
+}
+
+%define %swig_sequence_iterator(Sequence...)
+ %swig_sequence_iterator_with_making_function(swig::make_output_iterator,Sequence...)
+%enddef
+
+%define %swig_sequence_forward_iterator(Sequence...)
+ %swig_sequence_iterator_with_making_function(swig::make_output_forward_iterator,Sequence...)
+%enddef
+
+%define %swig_sequence_iterator_with_making_function(Make_output_iterator,Sequence...)
+#if defined(SWIG_EXPORT_ITERATOR_METHODS)
+ class iterator;
+ class reverse_iterator;
+ class const_iterator;
+ class const_reverse_iterator;
+
+ %typemap(out,noblock=1,fragment="SwigPySequence_Cont")
+ iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+ $result = SWIG_NewPointerObj(Make_output_iterator(%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(Make_output_iterator(%static_cast($1,const $type &).first),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
+ PyTuple_SetItem($result,1,SWIG_NewPointerObj(Make_output_iterator(%static_cast($1,const $type &).second),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
+ }
+
+ %fragment("SwigPyPairBoolOutputIterator","header",fragment=SWIG_From_frag(bool),fragment="SwigPySequence_Cont") {}
+
+ %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(Make_output_iterator(%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));
+ }
+
+ %typemap(in,noblock=1,fragment="SwigPySequence_Cont")
+ iterator(swig::SwigPyIterator *iter = 0, int res),
+ reverse_iterator(swig::SwigPyIterator *iter = 0, int res),
+ const_iterator(swig::SwigPyIterator *iter = 0, int res),
+ const_reverse_iterator(swig::SwigPyIterator *iter = 0, int res) {
+ res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ if (!SWIG_IsOK(res) || !iter) {
+ %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+ } else {
+ swig::SwigPyIterator_T<$type > *iter_t = dynamic_cast<swig::SwigPyIterator_T<$type > *>(iter);
+ if (iter_t) {
+ $1 = iter_t->get_current();
+ } else {
+ %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+ }
+ }
+ }
+
+ %typecheck(%checkcode(ITERATOR),noblock=1,fragment="SwigPySequence_Cont")
+ iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<$type > *>(iter) != 0));
+ }
+
+ %fragment("SwigPySequence_Cont");
+
+ %newobject iterator(PyObject **PYTHON_SELF);
+ %extend {
+ swig::SwigPyIterator* iterator(PyObject **PYTHON_SELF) {
+ return Make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+
+#if defined(SWIGPYTHON_BUILTIN)
+ %feature("python:slot", "tp_iter", functype="getiterfunc") iterator;
+#else
+ %pythoncode %{def __iter__(self):
+ return self.iterator()%}
+#endif
+ }
+
+#endif //SWIG_EXPORT_ITERATOR_METHODS
+%enddef
+
+
+/**** The python container methods ****/
+
+%define %swig_container_methods(Container...)
+
+/* deprecated in Python 2 */
+#if 1
+ %newobject __getslice__;
+#endif
+ %newobject __getitem__(SWIGPY_SLICEOBJECT *slice);
+
+#if defined(SWIGPYTHON_BUILTIN)
+ %feature("python:slot", "nb_nonzero", functype="inquiry") __nonzero__;
+ %feature("python:slot", "sq_length", functype="lenfunc") __len__;
+#endif // SWIGPYTHON_BUILTIN
+
+ %extend {
+ bool __nonzero__() const {
+ return !(self->empty());
+ }
+
+ /* Alias for Python 3 compatibility */
+ bool __bool__() const {
+ return !(self->empty());
+ }
+
+ size_type __len__() const {
+ return self->size();
+ }
+
+ // Although __getitem__, front, back actually use a const value_type& return type, the typemaps below
+ // use non-const so that they can be easily overridden by users if necessary.
+ %typemap(ret, fragment="reference_container_owner", noblock=1) value_type& __getitem__, value_type& front, value_type& back {
+ (void)swig::container_owner<swig::traits<$*1_ltype>::category>::back_reference($result, $self);
+ }
+ }
+%enddef
+
+
+
+%define %swig_sequence_methods_common(Sequence...)
+ %swig_sequence_iterator(%arg(Sequence))
+ %swig_container_methods(%arg(Sequence))
+
+ %fragment("SwigPySequence_Base");
+
+#if defined(SWIGPYTHON_BUILTIN)
+ //%feature("python:slot", "sq_item", functype="ssizeargfunc") __getitem__;
+ //%feature("python:slot", "sq_slice", functype="ssizessizeargfunc") __getslice__;
+ //%feature("python:slot", "sq_ass_item", functype="ssizeobjargproc") __setitem__;
+ //%feature("python:slot", "sq_ass_slice", functype="ssizessizeobjargproc") __setslice__;
+ %feature("python:slot", "mp_subscript", functype="binaryfunc") __getitem__;
+ %feature("python:slot", "mp_ass_subscript", functype="objobjargproc") __setitem__;
+#endif // SWIGPYTHON_BUILTIN
+
+ %extend {
+ /* typemap for slice object support */
+ %typemap(in) SWIGPY_SLICEOBJECT* {
+ if (!PySlice_Check($input)) {
+ %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+ }
+ $1 = (SWIGPY_SLICEOBJECT *) $input;
+ }
+ %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) SWIGPY_SLICEOBJECT* {
+ $1 = PySlice_Check($input);
+ }
+
+/* deprecated in Python 2 */
+#if 1
+ Sequence* __getslice__(difference_type i, difference_type j) throw (std::out_of_range, std::invalid_argument) {
+ return swig::getslice(self, i, j, 1);
+ }
+
+ void __setslice__(difference_type i, difference_type j) throw (std::out_of_range, std::invalid_argument) {
+ swig::setslice(self, i, j, 1, Sequence());
+ }
+
+ void __setslice__(difference_type i, difference_type j, const Sequence& v) throw (std::out_of_range, std::invalid_argument) {
+ swig::setslice(self, i, j, 1, v);
+ }
+
+ void __delslice__(difference_type i, difference_type j) throw (std::out_of_range, std::invalid_argument) {
+ swig::delslice(self, i, j, 1);
+ }
+#endif
+
+ void __delitem__(difference_type i) throw (std::out_of_range, std::invalid_argument) {
+ swig::erase(self, swig::getpos(self, i));
+ }
+
+ /* Overloaded methods for Python 3 compatibility
+ * (Also useful in Python 2.x)
+ */
+ Sequence* __getitem__(SWIGPY_SLICEOBJECT *slice) throw (std::out_of_range, std::invalid_argument) {
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ Sequence::difference_type id = i;
+ Sequence::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+
+ void __setitem__(SWIGPY_SLICEOBJECT *slice, const Sequence& v) throw (std::out_of_range, std::invalid_argument) {
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ Sequence::difference_type id = i;
+ Sequence::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+
+ void __setitem__(SWIGPY_SLICEOBJECT *slice) throw (std::out_of_range, std::invalid_argument) {
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ Sequence::difference_type id = i;
+ Sequence::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+
+ void __delitem__(SWIGPY_SLICEOBJECT *slice) throw (std::out_of_range, std::invalid_argument) {
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ Sequence::difference_type id = i;
+ Sequence::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+
+ }
+%enddef
+
+%define %swig_sequence_methods_non_resizable(Sequence...)
+ %swig_sequence_methods_common(%arg(Sequence))
+ %extend {
+ const value_type& __getitem__(difference_type i) const throw (std::out_of_range) {
+ return *(swig::cgetpos(self, i));
+ }
+
+ void __setitem__(difference_type i, const value_type& x) throw (std::out_of_range) {
+ *(swig::getpos(self,i)) = x;
+ }
+
+#if defined(SWIGPYTHON_BUILTIN)
+ // This will be called through the mp_ass_subscript slot to delete an entry.
+ void __setitem__(difference_type i) throw (std::out_of_range, std::invalid_argument) {
+ swig::erase(self, swig::getpos(self, i));
+ }
+#endif
+
+ }
+%enddef
+
+%define %swig_sequence_methods(Sequence...)
+ %swig_sequence_methods_non_resizable(%arg(Sequence))
+ %extend {
+ value_type pop() throw (std::out_of_range) {
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty container");
+ Sequence::value_type x = self->back();
+ self->pop_back();
+ return x;
+ }
+
+ void append(const value_type& x) {
+ self->push_back(x);
+ }
+ }
+%enddef
+
+%define %swig_sequence_methods_non_resizable_val(Sequence...)
+ %swig_sequence_methods_common(%arg(Sequence))
+ %extend {
+ value_type __getitem__(difference_type i) throw (std::out_of_range) {
+ return *(swig::cgetpos(self, i));
+ }
+
+ void __setitem__(difference_type i, value_type x) throw (std::out_of_range) {
+ *(swig::getpos(self,i)) = x;
+ }
+
+#if defined(SWIGPYTHON_BUILTIN)
+ // This will be called through the mp_ass_subscript slot to delete an entry.
+ void __setitem__(difference_type i) throw (std::out_of_range, std::invalid_argument) {
+ swig::erase(self, swig::getpos(self, i));
+ }
+#endif
+ }
+%enddef
+
+%define %swig_sequence_methods_val(Sequence...)
+ %swig_sequence_methods_non_resizable_val(%arg(Sequence))
+ %extend {
+ value_type pop() throw (std::out_of_range) {
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty container");
+ Sequence::value_type x = self->back();
+ self->pop_back();
+ return x;
+ }
+
+ void append(value_type x) {
+ self->push_back(x);
+ }
+ }
+%enddef
+
+
+
+//
+// Common fragments
+//
+
+%fragment("StdSequenceTraits","header",
+ fragment="StdTraits",
+ fragment="SwigPySequence_Cont")
+{
+namespace swig {
+ template <class SwigPySeq, class Seq>
+ inline void
+ assign(const SwigPySeq& swigpyseq, Seq* seq) {
+ // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
+ typedef typename SwigPySeq::value_type value_type;
+ typename SwigPySeq::const_iterator it = swigpyseq.begin();
+ for (;it != swigpyseq.end(); ++it) {
+ seq->insert(seq->end(),(value_type)(*it));
+ }
+ }
+
+ template <class Seq, class T = typename Seq::value_type >
+ struct traits_asptr_stdseq {
+ typedef Seq sequence;
+ typedef T value_type;
+
+ static int asptr(PyObject *obj, sequence **seq) {
+ if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
+ sequence *p;
+ swig_type_info *descriptor = swig::type_info<sequence>();
+ if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
+ if (seq) *seq = p;
+ return SWIG_OLDOBJ;
+ }
+ } else if (PySequence_Check(obj)) {
+ try {
+ SwigPySequence_Cont<value_type> swigpyseq(obj);
+ if (seq) {
+ sequence *pseq = new sequence();
+ assign(swigpyseq, pseq);
+ *seq = pseq;
+ return SWIG_NEWOBJ;
+ } else {
+ return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
+ }
+ } catch (std::exception& e) {
+ if (seq) {
+ if (!PyErr_Occurred()) {
+ PyErr_SetString(PyExc_TypeError, e.what());
+ }
+ }
+ return SWIG_ERROR;
+ }
+ }
+ return SWIG_ERROR;
+ }
+ };
+
+ template <class Seq, class T = typename Seq::value_type >
+ struct traits_from_stdseq {
+ typedef Seq sequence;
+ typedef T value_type;
+ typedef typename Seq::size_type size_type;
+ typedef typename sequence::const_iterator const_iterator;
+
+ static PyObject *from(const sequence& seq) {
+%#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
+ swig_type_info *desc = swig::type_info<sequence>();
+ if (desc && desc->clientdata) {
+ return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
+ }
+%#endif
+ size_type size = seq.size();
+ if (size <= (size_type)INT_MAX) {
+ PyObject *obj = PyTuple_New((Py_ssize_t)size);
+ Py_ssize_t i = 0;
+ for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
+ PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
+ }
+ return obj;
+ } else {
+ PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
+ return NULL;
+ }
+ }
+ };
+}
+}
diff --git a/contrib/tools/swig/Lib/python/pyiterators.swg b/contrib/tools/swig/Lib/python/pyiterators.swg
new file mode 100644
index 00000000000..cb15e35cda4
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/pyiterators.swg
@@ -0,0 +1,458 @@
+/* -----------------------------------------------------------------------------
+ * pyiterators.swg
+ *
+ * Implement a python 'output' iterator for Python 2.2 or higher.
+ *
+ * Users can derive form the SwigPyIterator to implement their
+ * own iterators. As an example (real one since we use it for STL/STD
+ * containers), the template SwigPyIterator_T does the
+ * implementation for generic C++ iterators.
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+%fragment("SwigPyIterator","header",fragment="<stddef.h>") {
+namespace swig {
+ struct stop_iteration {
+ };
+
+ struct SwigPyIterator {
+ private:
+ SwigPtr_PyObject _seq;
+
+ protected:
+ SwigPyIterator(PyObject *seq) : _seq(seq)
+ {
+ }
+
+ public:
+ virtual ~SwigPyIterator() {}
+
+ // Access iterator method, required by Python
+ virtual PyObject *value() const = 0;
+
+ // Forward iterator method, required by Python
+ virtual SwigPyIterator *incr(size_t n = 1) = 0;
+
+ // Backward iterator method, very common in C++, but not required in Python
+ virtual SwigPyIterator *decr(size_t /*n*/ = 1)
+ {
+ throw stop_iteration();
+ }
+
+ // Random access iterator methods, but not required in Python
+ virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
+ {
+ throw std::invalid_argument("operation not supported");
+ }
+
+ virtual bool equal (const SwigPyIterator &/*x*/) const
+ {
+ throw std::invalid_argument("operation not supported");
+ }
+
+ // C++ common/needed methods
+ virtual SwigPyIterator *copy() const = 0;
+
+ PyObject *next()
+ {
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
+ PyObject *obj = value();
+ incr();
+ SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
+ return obj;
+ }
+
+ /* Make an alias for Python 3.x */
+ PyObject *__next__()
+ {
+ return next();
+ }
+
+ PyObject *previous()
+ {
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
+ decr();
+ PyObject *obj = value();
+ SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
+ return obj;
+ }
+
+ SwigPyIterator *advance(ptrdiff_t n)
+ {
+ return (n > 0) ? incr(n) : decr(-n);
+ }
+
+ bool operator == (const SwigPyIterator& x) const
+ {
+ return equal(x);
+ }
+
+ bool operator != (const SwigPyIterator& x) const
+ {
+ return ! operator==(x);
+ }
+
+ SwigPyIterator& operator += (ptrdiff_t n)
+ {
+ return *advance(n);
+ }
+
+ SwigPyIterator& operator -= (ptrdiff_t n)
+ {
+ return *advance(-n);
+ }
+
+ SwigPyIterator* operator + (ptrdiff_t n) const
+ {
+ return copy()->advance(n);
+ }
+
+ SwigPyIterator* operator - (ptrdiff_t n) const
+ {
+ return copy()->advance(-n);
+ }
+
+ ptrdiff_t operator - (const SwigPyIterator& x) const
+ {
+ return x.distance(*this);
+ }
+
+ static swig_type_info* descriptor() {
+ static int init = 0;
+ static swig_type_info* desc = 0;
+ if (!init) {
+ desc = SWIG_TypeQuery("swig::SwigPyIterator *");
+ init = 1;
+ }
+ return desc;
+ }
+ };
+
+%#if defined(SWIGPYTHON_BUILTIN)
+ inline PyObject* make_output_iterator_builtin (PyObject *pyself)
+ {
+ Py_INCREF(pyself);
+ return pyself;
+ }
+%#endif
+}
+}
+
+%fragment("SwigPyIterator_T","header",fragment="<stddef.h>",fragment="SwigPyIterator",fragment="StdTraits",fragment="StdIteratorTraits") {
+namespace swig {
+ template<typename OutIterator>
+ class SwigPyIterator_T : public SwigPyIterator
+ {
+ public:
+ typedef OutIterator out_iterator;
+ typedef typename std::iterator_traits<out_iterator>::value_type value_type;
+ typedef SwigPyIterator_T<out_iterator> self_type;
+
+ SwigPyIterator_T(out_iterator curr, PyObject *seq)
+ : SwigPyIterator(seq), current(curr)
+ {
+ }
+
+ const out_iterator& get_current() const
+ {
+ return current;
+ }
+
+
+ bool equal (const SwigPyIterator &iter) const
+ {
+ const self_type *iters = dynamic_cast<const self_type *>(&iter);
+ if (iters) {
+ return (current == iters->get_current());
+ } else {
+ throw std::invalid_argument("bad iterator type");
+ }
+ }
+
+ ptrdiff_t distance(const SwigPyIterator &iter) const
+ {
+ const self_type *iters = dynamic_cast<const self_type *>(&iter);
+ if (iters) {
+ return std::distance(current, iters->get_current());
+ } else {
+ throw std::invalid_argument("bad iterator type");
+ }
+ }
+
+ protected:
+ out_iterator current;
+ };
+
+ template <class ValueType>
+ struct from_oper
+ {
+ typedef const ValueType& argument_type;
+ typedef PyObject *result_type;
+ result_type operator()(argument_type v) const
+ {
+ return swig::from(v);
+ }
+ };
+
+ 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> >
+ class SwigPyIteratorOpen_T : public SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper>
+ {
+ public:
+ FromOper from;
+ typedef OutIterator out_iterator;
+ typedef ValueType value_type;
+ typedef SwigPyIterator_T<out_iterator> base;
+ typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
+
+ SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
+ : SwigPyForwardIteratorOpen_T<OutIterator>(curr, seq)
+ {
+ }
+
+ SwigPyIterator *decr(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> >
+ 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;
+ }
+
+ protected:
+ out_iterator begin;
+ out_iterator end;
+ };
+
+ template<typename OutIterator,
+ typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
+ typename FromOper = from_oper<ValueType> >
+ class SwigPyIteratorClosed_T : public SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>
+ {
+ public:
+ FromOper from;
+ typedef OutIterator out_iterator;
+ typedef ValueType value_type;
+ typedef SwigPyIterator_T<out_iterator> base;
+ typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> base0;
+ typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
+
+ SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
+ : SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
+ {
+ }
+
+ SwigPyIterator *decr(size_t n = 1)
+ {
+ while (n--) {
+ if (base::current == base0::begin) {
+ throw stop_iteration();
+ } else {
+ --base::current;
+ }
+ }
+ return this;
+ }
+ };
+
+
+ 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)
+ {
+ 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)
+ {
+ return new SwigPyIteratorOpen_T<OutIter>(current, seq);
+ }
+
+}
+}
+
+
+%fragment("SwigPyIterator");
+namespace swig
+{
+ /*
+ Throw a StopIteration exception
+ */
+ %ignore stop_iteration;
+ struct stop_iteration {};
+
+ %typemap(throws) stop_iteration {
+ (void)$1;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+
+ /*
+ Mark methods that return new objects
+ */
+ %newobject SwigPyIterator::copy;
+ %newobject SwigPyIterator::operator + (ptrdiff_t n) const;
+ %newobject SwigPyIterator::operator - (ptrdiff_t n) const;
+
+ %nodirector SwigPyIterator;
+
+#if defined(SWIGPYTHON_BUILTIN)
+ %feature("python:tp_iter") SwigPyIterator "&swig::make_output_iterator_builtin";
+ %feature("python:slot", "tp_iternext", functype="iternextfunc") SwigPyIterator::__next__;
+#else
+ %extend SwigPyIterator {
+ %pythoncode %{def __iter__(self):
+ return self%}
+ }
+#endif
+
+ %catches(swig::stop_iteration) SwigPyIterator::value() const;
+ %catches(swig::stop_iteration) SwigPyIterator::incr(size_t n = 1);
+ %catches(swig::stop_iteration) SwigPyIterator::decr(size_t n = 1);
+ %catches(std::invalid_argument) SwigPyIterator::distance(const SwigPyIterator &x) const;
+ %catches(std::invalid_argument) SwigPyIterator::equal (const SwigPyIterator &x) const;
+ %catches(swig::stop_iteration) SwigPyIterator::__next__();
+ %catches(swig::stop_iteration) SwigPyIterator::next();
+ %catches(swig::stop_iteration) SwigPyIterator::previous();
+ %catches(swig::stop_iteration) SwigPyIterator::advance(ptrdiff_t n);
+ %catches(swig::stop_iteration) SwigPyIterator::operator += (ptrdiff_t n);
+ %catches(swig::stop_iteration) SwigPyIterator::operator -= (ptrdiff_t n);
+ %catches(swig::stop_iteration) SwigPyIterator::operator + (ptrdiff_t n) const;
+ %catches(swig::stop_iteration) SwigPyIterator::operator - (ptrdiff_t n) const;
+
+ struct SwigPyIterator
+ {
+ protected:
+ SwigPyIterator(PyObject *seq);
+
+ public:
+ virtual ~SwigPyIterator();
+
+ // Access iterator method, required by Python
+ virtual PyObject *value() const = 0;
+
+ // Forward iterator method, required by Python
+ virtual SwigPyIterator *incr(size_t n = 1) = 0;
+
+ // Backward iterator method, very common in C++, but not required in Python
+ virtual SwigPyIterator *decr(size_t n = 1);
+
+ // Random access iterator methods, but not required in Python
+ virtual ptrdiff_t distance(const SwigPyIterator &x) const;
+
+ virtual bool equal (const SwigPyIterator &x) const;
+
+ // C++ common/needed methods
+ virtual SwigPyIterator *copy() const = 0;
+
+ PyObject *next();
+ PyObject *__next__();
+ PyObject *previous();
+ SwigPyIterator *advance(ptrdiff_t n);
+
+ bool operator == (const SwigPyIterator& x) const;
+ bool operator != (const SwigPyIterator& x) const;
+ SwigPyIterator& operator += (ptrdiff_t n);
+ SwigPyIterator& operator -= (ptrdiff_t n);
+ SwigPyIterator* operator + (ptrdiff_t n) const;
+ SwigPyIterator* operator - (ptrdiff_t n) const;
+ ptrdiff_t operator - (const SwigPyIterator& x) const;
+ };
+}
+
diff --git a/contrib/tools/swig/Lib/python/pystdcommon.swg b/contrib/tools/swig/Lib/python/pystdcommon.swg
new file mode 100644
index 00000000000..afa71350a91
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/pystdcommon.swg
@@ -0,0 +1,265 @@
+%fragment("StdTraits","header",fragment="StdTraitsCommon")
+{
+namespace swig {
+ /*
+ Traits that provides the from method
+ */
+ template <class Type> struct traits_from_ptr {
+ static PyObject *from(Type *val, int owner = 0) {
+ return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
+ }
+ };
+
+ template <class Type> struct traits_from {
+ static PyObject *from(const Type& val) {
+ return traits_from_ptr<Type>::from(new Type(val), 1);
+ }
+ };
+
+ template <class Type> struct traits_from<Type *> {
+ static PyObject *from(Type* val) {
+ return traits_from_ptr<Type>::from(val, 0);
+ }
+ };
+
+ template <class Type> struct traits_from<const Type *> {
+ static PyObject *from(const Type* val) {
+ return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
+ }
+ };
+
+
+ template <class Type>
+ inline PyObject *from(const Type& val) {
+ return traits_from<Type>::from(val);
+ }
+
+ template <class Type>
+ inline PyObject *from_ptr(Type* val, int owner) {
+ return traits_from_ptr<Type>::from(val, owner);
+ }
+
+ /*
+ Traits that provides the asval/as/check method
+ */
+ template <class Type>
+ struct traits_asptr {
+ static int asptr(PyObject *obj, Type **val) {
+ int res = SWIG_ERROR;
+ swig_type_info *descriptor = type_info<Type>();
+ if (val) {
+ Type *p = 0;
+ int newmem = 0;
+ res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR;
+ if (SWIG_IsOK(res)) {
+ if (newmem & SWIG_CAST_NEW_MEMORY) {
+ res |= SWIG_NEWOBJMASK;
+ }
+ *val = p;
+ }
+ } else {
+ res = descriptor ? SWIG_ConvertPtr(obj, 0, descriptor, 0) : SWIG_ERROR;
+ }
+ return res;
+ }
+ };
+
+ template <class Type>
+ inline int asptr(PyObject *obj, Type **vptr) {
+ return traits_asptr<Type>::asptr(obj, vptr);
+ }
+
+ template <class Type>
+ struct traits_asval {
+ static int asval(PyObject *obj, Type *val) {
+ if (val) {
+ Type *p = 0;
+ int res = traits_asptr<Type>::asptr(obj, &p);
+ if (!SWIG_IsOK(res)) return res;
+ if (p) {
+ typedef typename noconst_traits<Type>::noconst_type noconst_type;
+ *(const_cast<noconst_type*>(val)) = *p;
+ if (SWIG_IsNewObj(res)){
+ %delete(p);
+ res = SWIG_DelNewMask(res);
+ }
+ return res;
+ } else {
+ return SWIG_ERROR;
+ }
+ } else {
+ return traits_asptr<Type>::asptr(obj, (Type **)(0));
+ }
+ }
+ };
+
+ template <class Type> struct traits_asval<Type*> {
+ static int asval(PyObject *obj, Type **val) {
+ if (val) {
+ typedef typename noconst_traits<Type>::noconst_type noconst_type;
+ noconst_type *p = 0;
+ int res = traits_asptr<noconst_type>::asptr(obj, &p);
+ if (SWIG_IsOK(res)) {
+ *(const_cast<noconst_type**>(val)) = p;
+ }
+ return res;
+ } else {
+ return traits_asptr<Type>::asptr(obj, (Type **)(0));
+ }
+ }
+ };
+
+ template <class Type>
+ inline int asval(PyObject *obj, Type *val) {
+ return traits_asval<Type>::asval(obj, val);
+ }
+
+ template <class Type>
+ struct traits_as<Type, value_category> {
+ static Type as(PyObject *obj) {
+ Type v;
+ int res = asval(obj, &v);
+ if (!obj || !SWIG_IsOK(res)) {
+ if (!PyErr_Occurred()) {
+ ::%type_error(swig::type_name<Type>());
+ }
+ throw std::invalid_argument("bad type");
+ }
+ return v;
+ }
+ };
+
+ template <class Type>
+ struct traits_as<Type, pointer_category> {
+ static Type as(PyObject *obj) {
+ Type *v = 0;
+ int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+ if (SWIG_IsOK(res) && v) {
+ if (SWIG_IsNewObj(res)) {
+ Type r(*v);
+ %delete(v);
+ return r;
+ } else {
+ return *v;
+ }
+ } else {
+ if (!PyErr_Occurred()) {
+ %type_error(swig::type_name<Type>());
+ }
+ throw std::invalid_argument("bad type");
+ }
+ }
+ };
+
+ template <class Type>
+ struct traits_as<Type*, pointer_category> {
+ static Type* as(PyObject *obj) {
+ Type *v = 0;
+ int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+ if (SWIG_IsOK(res)) {
+ return v;
+ } else {
+ if (!PyErr_Occurred()) {
+ %type_error(swig::type_name<Type>());
+ }
+ throw std::invalid_argument("bad type");
+ }
+ }
+ };
+
+ template <class Type>
+ inline Type as(PyObject *obj) {
+ return traits_as<Type, typename traits<Type>::category>::as(obj);
+ }
+
+ template <class Type>
+ struct traits_check<Type, value_category> {
+ static bool check(PyObject *obj) {
+ int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
+ return SWIG_IsOK(res) ? true : false;
+ }
+ };
+
+ template <class Type>
+ struct traits_check<Type, pointer_category> {
+ static bool check(PyObject *obj) {
+ int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
+ return SWIG_IsOK(res) ? true : false;
+ }
+ };
+
+ template <class Type>
+ inline bool check(PyObject *obj) {
+ return traits_check<Type, typename traits<Type>::category>::check(obj);
+ }
+}
+}
+
+//
+// Backward compatibility
+//
+
+#ifdef SWIG_PYTHON_BACKWARD_COMP
+%fragment("<string>");
+%{
+PyObject* SwigInt_FromBool(bool b) {
+ return PyInt_FromLong(b ? 1L : 0L);
+}
+double SwigNumber_Check(PyObject* o) {
+ return PyFloat_Check(o) || PyInt_Check(o) || PyLong_Check(o);
+}
+double SwigNumber_AsDouble(PyObject* o) {
+ return PyFloat_Check(o) ? PyFloat_AsDouble(o)
+ : (PyInt_Check(o) ? double(PyInt_AsLong(o))
+ : double(PyLong_AsLong(o)));
+}
+PyObject* SwigString_FromString(const std::string& s) {
+ return PyString_FromStringAndSize(s.data(),s.size());
+}
+std::string SwigString_AsString(PyObject* o) {
+ return std::string(PyString_AsString(o));
+}
+%}
+
+#endif
+
+
+%define %specialize_std_container(Type,Check,As,From)
+%{
+namespace swig {
+ template <> struct traits_asval<Type > {
+ typedef Type value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ if (Check(obj)) {
+ if (val) *val = As(obj);
+ return SWIG_OK;
+ }
+ return SWIG_ERROR;
+ }
+ };
+ template <> struct traits_from<Type > {
+ typedef Type value_type;
+ static PyObject *from(const value_type& val) {
+ return From(val);
+ }
+ };
+
+ template <>
+ struct traits_check<Type, value_category> {
+ static int check(PyObject *obj) {
+ int res = Check(obj);
+ return obj && res ? res : 0;
+ }
+ };
+}
+%}
+%enddef
+
+
+#define specialize_std_vector(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_list(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_deque(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_set(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_multiset(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_unordered_set(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_unordered_multiset(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
diff --git a/contrib/tools/swig/Lib/python/pywstrings.swg b/contrib/tools/swig/Lib/python/pywstrings.swg
new file mode 100644
index 00000000000..0e5a78df5ee
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/pywstrings.swg
@@ -0,0 +1,85 @@
+/* ------------------------------------------------------------
+ * utility methods for wchar_t strings
+ * ------------------------------------------------------------ */
+
+%{
+#if PY_VERSION_HEX >= 0x03020000
+# define SWIGPY_UNICODE_ARG(obj) ((PyObject*) (obj))
+#else
+# define SWIGPY_UNICODE_ARG(obj) ((PyUnicodeObject*) (obj))
+#endif
+%}
+
+%fragment("SWIG_AsWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
+SWIGINTERN int
+SWIG_AsWCharPtrAndSize(PyObject *obj, wchar_t **cptr, size_t *psize, int *alloc)
+{
+ PyObject *tmp = 0;
+ int isunicode = PyUnicode_Check(obj);
+%#if PY_VERSION_HEX < 0x03000000 && !defined(SWIG_PYTHON_STRICT_UNICODE_WCHAR)
+ if (!isunicode && PyString_Check(obj)) {
+ tmp = PyUnicode_FromObject(obj);
+ if (tmp) {
+ isunicode = 1;
+ obj = tmp;
+ } else {
+ PyErr_Clear();
+ return SWIG_TypeError;
+ }
+ }
+%#endif
+ if (isunicode) {
+%#if PY_VERSION_HEX >= 0x03030000
+ Py_ssize_t len = PyUnicode_GetLength(obj);
+%#else
+ Py_ssize_t len = PyUnicode_GetSize(obj);
+%#endif
+ if (cptr) {
+ Py_ssize_t length;
+ *cptr = %new_array(len + 1, wchar_t);
+ length = PyUnicode_AsWideChar(SWIGPY_UNICODE_ARG(obj), *cptr, len);
+ if (length == -1) {
+ PyErr_Clear();
+ Py_XDECREF(tmp);
+ return SWIG_TypeError;
+ }
+ (*cptr)[length] = 0;
+ }
+ if (psize) *psize = (size_t) len + 1;
+ if (alloc) *alloc = cptr ? SWIG_NEWOBJ : 0;
+ Py_XDECREF(tmp);
+ return SWIG_OK;
+ } else {
+ swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
+ if (pwchar_descriptor) {
+ void * vptr = 0;
+ if (SWIG_ConvertPtr(obj, &vptr, pwchar_descriptor, 0) == SWIG_OK) {
+ if (cptr) *cptr = (wchar_t *)vptr;
+ if (psize) *psize = vptr ? (wcslen((wchar_t *)vptr) + 1) : 0;
+ return SWIG_OK;
+ }
+ }
+ }
+ return SWIG_TypeError;
+}
+}
+
+%fragment("SWIG_FromWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
+SWIGINTERNINLINE PyObject *
+SWIG_FromWCharPtrAndSize(const wchar_t * carray, size_t size)
+{
+ if (carray) {
+ if (size > INT_MAX) {
+ swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
+ return pwchar_descriptor ?
+ SWIG_InternalNewPointerObj(%const_cast(carray,wchar_t *), pwchar_descriptor, 0) : SWIG_Py_Void();
+ } else {
+ return PyUnicode_FromWideChar(carray, %numeric_cast(size, Py_ssize_t));
+ }
+ } else {
+ return SWIG_Py_Void();
+ }
+}
+}
+
+
diff --git a/contrib/tools/swig/Lib/python/std_alloc.i b/contrib/tools/swig/Lib/python/std_alloc.i
new file mode 100644
index 00000000000..35dc051beab
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/std_alloc.i
@@ -0,0 +1 @@
+%include <std/std_alloc.i>
diff --git a/contrib/tools/swig/Lib/python/std_char_traits.i b/contrib/tools/swig/Lib/python/std_char_traits.i
new file mode 100644
index 00000000000..bf4e6c47dd4
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/std_char_traits.i
@@ -0,0 +1 @@
+%include <std/std_char_traits.i>
diff --git a/contrib/tools/swig/Lib/python/std_common.i b/contrib/tools/swig/Lib/python/std_common.i
new file mode 100644
index 00000000000..605766238bb
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/std_common.i
@@ -0,0 +1,74 @@
+%include <std/std_except.i>
+%include <pystdcommon.swg>
+
+
+/*
+ Generate the traits for a 'primitive' type, such as 'double',
+ for which the SWIG_AsVal and SWIG_From methods are already defined.
+*/
+
+%define %traits_ptypen(Type...)
+ %fragment(SWIG_Traits_frag(Type),"header",
+ fragment=SWIG_AsVal_frag(Type),
+ fragment=SWIG_From_frag(Type),
+ fragment="StdTraits") {
+namespace swig {
+ template <> struct traits< Type > {
+ typedef value_category category;
+ static const char* type_name() { return #Type; }
+ };
+ template <> struct traits_asval< Type > {
+ typedef Type value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal(Type)(obj, val);
+ }
+ };
+ template <> struct traits_from< Type > {
+ typedef Type value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From(Type)(val);
+ }
+ };
+}
+}
+%enddef
+
+/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
+ is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
+ instantiations required using %template). The STL containers define the 'front' method and the typemap
+ below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
+ standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
+ required in the generated code for enums. */
+
+%define %traits_enum(Type...)
+ %fragment("SWIG_Traits_enum_"{Type},"header",
+ fragment=SWIG_AsVal_frag(int),
+ fragment=SWIG_From_frag(int),
+ fragment="StdTraits") {
+namespace swig {
+ template <> struct traits_asval< Type > {
+ typedef Type value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal(int)(obj, (int *)val);
+ }
+ };
+ template <> struct traits_from< Type > {
+ typedef Type value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From(int)((int)val);
+ }
+ };
+}
+}
+%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
+%enddef
+
+
+%include <std/std_common.i>
+
+//
+// Generates the traits for all the known primitive
+// C++ types (int, double, ...)
+//
+%apply_cpptypes(%traits_ptypen);
+
diff --git a/contrib/tools/swig/Lib/python/std_container.i b/contrib/tools/swig/Lib/python/std_container.i
new file mode 100644
index 00000000000..d24c1570f1d
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/std_container.i
@@ -0,0 +1,2 @@
+%include <pycontainer.swg>
+%include <std/std_container.i>
diff --git a/contrib/tools/swig/Lib/python/std_except.i b/contrib/tools/swig/Lib/python/std_except.i
new file mode 100644
index 00000000000..af98428f65d
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/std_except.i
@@ -0,0 +1 @@
+%include <typemaps/std_except.swg>
diff --git a/contrib/tools/swig/Lib/python/std_string.i b/contrib/tools/swig/Lib/python/std_string.i
new file mode 100644
index 00000000000..dc1378ae6de
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/std_string.i
@@ -0,0 +1 @@
+%include <typemaps/std_string.swg>
diff --git a/contrib/tools/swig/Lib/python/std_vector.i b/contrib/tools/swig/Lib/python/std_vector.i
new file mode 100644
index 00000000000..2ac41a54d7d
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/std_vector.i
@@ -0,0 +1,34 @@
+/*
+ Vectors
+*/
+
+%fragment("StdVectorTraits","header",fragment="StdSequenceTraits")
+%{
+ namespace swig {
+ template <class T>
+ struct traits_reserve<std::vector<T> > {
+ static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
+ seq.reserve(n);
+ }
+ };
+
+ template <class T>
+ struct traits_asptr<std::vector<T> > {
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ }
+ };
+
+ template <class T>
+ struct traits_from<std::vector<T> > {
+ static PyObject *from(const std::vector<T>& vec) {
+ return traits_from_stdseq<std::vector<T> >::from(vec);
+ }
+ };
+ }
+%}
+
+#define %swig_vector_methods(Type...) %swig_sequence_methods(Type)
+#define %swig_vector_methods_val(Type...) %swig_sequence_methods_val(Type);
+
+%include <std/std_vector.i>
diff --git a/contrib/tools/swig/Lib/python/wchar.i b/contrib/tools/swig/Lib/python/wchar.i
new file mode 100644
index 00000000000..308139a3ab7
--- /dev/null
+++ b/contrib/tools/swig/Lib/python/wchar.i
@@ -0,0 +1,21 @@
+#ifdef __cplusplus
+
+%{
+#include <cwchar>
+%}
+
+#else
+
+%{
+#include <wchar.h>
+%}
+
+#endif
+
+%types(wchar_t *);
+%include <pywstrings.swg>
+
+/*
+ Enable swig wchar support.
+*/
+#define SWIG_WCHAR