// Python sequence <-> C++ container wrapper
// This wrapper, and its iterator, allows a general use (and reuse) of
// the the mapping between C++ and Python, thanks to the C++
// Of course, it needs the C++ compiler to support templates, but
// since we will use this wrapper with the STL containers, that should
/**** The PySequence C++ Wrap ***/
#if PY_VERSION_HEX < 0x02000000
#define PySequence_Size PySequence_Length
%fragment("PySequence_Base","header")
check_index(ptrdiff_t i, size_t size, bool insert = false) {
if ((size_t) (-i) <= size)
return (size_t) (i + size);
} else if ( (size_t) i < size ) {
} else if (insert && ((size_t) i == size)) {
throw std::out_of_range("index out of range");
slice_index(ptrdiff_t i, size_t size) {
if ((size_t) (-i) <= size) {
return (size_t) (i + size);
throw std::out_of_range("index out of range");
return ( (size_t) i < size ) ? ((size_t) i) : size;
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()));
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()));
template <class Sequence, class Difference>
getslice(const Sequence* self, Difference i, Difference j) {
typename Sequence::size_type size = self->size();
typename Sequence::size_type ii = swig::check_index(i, size);
typename Sequence::size_type jj = swig::slice_index(j, size);
typename Sequence::const_iterator vb = self->begin();
typename Sequence::const_iterator ve = self->begin();
return new Sequence(vb, ve);
template <class Sequence, class Difference, class InputSeq>
setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
typename Sequence::size_type size = self->size();
typename Sequence::size_type ii = swig::check_index(i, size, true);
typename Sequence::size_type jj = swig::slice_index(j, size);
typename Sequence::iterator sb = self->begin();
typename InputSeq::const_iterator vmid = v.begin();
std::advance(vmid, jj - ii);
self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
template <class Sequence, class Difference>
delslice(Sequence* self, Difference i, Difference j) {
typename Sequence::size_type size = self->size();
typename Sequence::size_type ii = swig::check_index(i, size, true);
typename Sequence::size_type jj = swig::slice_index(j, size);
typename Sequence::iterator sb = self->begin();
typename Sequence::iterator se = self->begin();
%fragment("PySequence_Cont","header",
fragment="PySequence_Base",
PySequence_Ref(PyObject* seq, int index)
: _seq(seq), _index(index)
swig::PyObject_var item = PySequence_GetItem(_seq, _index);
return swig::as<T>(item, true);
} catch (std::exception& e) {
PyOS_snprintf(msg, sizeof(msg), "in sequence element %d ", _index);
SWIG_type_error(swig::type_name<T>(), item);
SWIG_append_errmsg(e.what());
PySequence_Ref& operator=(const T& v)
PySequence_SetItem(_seq, _index, swig::from<T>(v));
struct PySequence_ArrowProxy
PySequence_ArrowProxy(const T& x): m_value(x) {}
const T* operator->() const { return &m_value; }
operator const T*() const { return &m_value; }
template <class T, class Reference >
typedef PySequence_Iter<T, Reference > self;
typedef std::random_access_iterator_tag iterator_category;
typedef Reference reference;
typedef int difference_type;
PySequence_Iter(PyObject* seq, int index)
: _seq(seq), _index(index)
reference operator*() const
return reference(_seq, _index);
return PySequence_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 += (difference_type n)
self operator +(difference_type n) const
return self(_seq, _index + n);
self& operator -= (difference_type n)
self operator -(difference_type n) const
return self(_seq, _index - n);
difference_type operator - (const self& ri) const
return _index - ri._index;
operator[](difference_type n) const
return reference(_seq, _index + n);
typedef PySequence_Ref<T> reference;
typedef const PySequence_Ref<T> const_reference;
typedef int difference_type;
typedef const pointer const_pointer;
typedef PySequence_Iter<T, reference> iterator;
typedef PySequence_Iter<T, const_reference> const_iterator;
PySequence_Cont(PyObject* seq) : _seq(0)
if (!PySequence_Check(seq)) {
throw std::invalid_argument("a sequence is expected");
if (_seq) Py_DECREF(_seq);
return PySequence_Size(_seq);
return iterator(_seq, 0);
const_iterator begin() const
return const_iterator(_seq, 0);
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(bool set_err = true) const
for (int i = 0; i < s; ++i) {
swig::PyObject_var item = PySequence_GetItem(_seq, i);
if (!swig::check<value_type>(item)) {
PyOS_snprintf(msg, sizeof(msg), "in sequence element %d", i);
SWIG_type_error(swig::type_name<value_type>(), item);
/**** The python container methods ****/
%define %swig_container_methods(Container...)
bool __nonzero__() const {
size_type __len__() const {
%define %swig_sequence_methods_common(Sequence...)
%swig_container_methods(SWIG_arg(Sequence))
%fragment("PySequence_Base");
value_type pop() throw (std::out_of_range) {
throw std::out_of_range("pop from empty container");
Sequence::value_type x = self->back();
Sequence* __getslice__(difference_type i, difference_type j) throw (std::out_of_range) {
return swig::getslice(self, i, j);
void __setslice__(difference_type i, difference_type j, const Sequence& v) throw (std::out_of_range, std::invalid_argument) {
swig::setslice(self, i, j, v);
void __delslice__(difference_type i, difference_type j) throw (std::out_of_range) {
swig::delslice(self, i, j);
void __delitem__(difference_type i) throw (std::out_of_range) {
self->erase(swig::getpos(self,i));
%define %swig_sequence_methods(Sequence...)
%swig_sequence_methods_common(SWIG_arg(Sequence))
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;
void append(const value_type& x) {
%define %swig_sequence_methods_val(Sequence...)
%swig_sequence_methods_common(SWIG_arg(Sequence))
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;
void append(value_type x) {
%fragment("StdSequenceTraits","header",
fragment="StdTraits",fragment="PyObject_var",
fragment="PySequence_Cont")
template <class PySeq, class Seq>
assign(const PySeq& pyseq, Seq* seq) {
#ifdef SWIG_STD_NOASSIGN_STL
typedef typename PySeq::value_type value_type;
typename PySeq::const_iterator it = pyseq.begin();
for (;it != pyseq.end(); ++it) {
seq->insert(seq->end(),(value_type)(*it));
seq->assign(pyseq.begin(), pyseq.end());
template <class Seq, class T = typename Seq::value_type >
struct traits_asptr_stdseq {
static int asptr(PyObject *obj, sequence **seq) {
if (PySequence_Check(obj)) {
PySequence_Cont<value_type> pyseq(obj);
sequence *pseq = new sequence();
} catch (std::exception& e) {
PyErr_SetString(PyExc_TypeError, e.what());
if (SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<sequence>(),0) != -1) {
PyErr_Format(PyExc_TypeError, "a %s is expected",
swig::type_name<sequence>());
template <class Seq, class T = typename Seq::value_type >
struct traits_from_stdseq {
typedef typename Seq::size_type size_type;
typedef typename sequence::const_iterator const_iterator;
static PyObject *from(const sequence& seq) {
size_type size = seq.size();
if (size <= (size_type)INT_MAX) {
PyObject *obj = PyTuple_New((int)size);
for (const_iterator it = seq.begin();
it != seq.end(); ++it, ++i) {
PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
PyErr_SetString(PyExc_OverflowError,
"sequence size not valid in python");