How to make a C++ class iterable from Python using SWIG?

Question

I have a C++ class Collection that manages a std::vector<Element> (a private member of the class).

From C++ I can iterate through the vector using the begin() and end() iterators (which are just typedefs for the vector's iterators) like:

Collection col;
for (Collection::const_iterator itr = col.begin(); itr != col.end(); itr++)
{
  std::cout << itr->get() << std::endl;
}

Now I wish to do a similar thing from Python like:

import example
el = example.Element()
el.set(5)
col = example.Collection()
col.add(el)
for e in col:
    print e.get()

But this results in:

TypeError: 'Collection' object is not iterable

I am not able to configure SWIG in a way that it generates the __iter__ (I think it's the only thing it needs) for the Python Collection class. How am I supposed to do this?

This is my code:

example.h:

#include <vector>

class Element
{
public:
  Element();
  ~Element();

  int get() const;
  void set(const int var);

private:
  int variable_;
};

class Collection
{
public:
  Collection();
  ~Collection();

  void add(const Element& element);

  typedef std::vector<Element> tElements;

  // iterators
  typedef tElements::iterator iterator;
  typedef tElements::const_iterator const_iterator;
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;

private:
  tElements          elements_;
};

example.cpp:

#include "example.h"

Element::Element() {}

Element::~Element() {}

int Element::get() const
{
  return variable_;
}

void Element::set(const int var)
{
  variable_ = var;
}

Collection::Collection() : elements_() {}

Collection::~Collection() {}

void Collection::add(const Element& element)
{
  elements_.push_back(element);
}

Collection::iterator Collection::begin()
{
  return elements_.begin();
}

Collection::const_iterator Collection::begin() const
{
  return elements_.begin();
}

Collection::iterator Collection::end()
{
  return elements_.end();
}

Collection::const_iterator Collection::end() const
{
  return elements_.end();
}

example.i:

%module example
%{
#include "example.h"
%}

// I've tried to add this, but that generates a whole
// other class, that is not what I want.
// %include "std_vector.i"
// %template(ElementVector) std::vector<Element>;

// I've also tried to %extend the class (which I think is what I want,
// but I cannot figure out with what to extend it with)

// Include the header file with above prototypes
%include "example.h"

Compile with:

swig -python -c++ -o example_wrap.cpp example.i
g++ -fPIC -c example.cpp example_wrap.cpp -I/usr/include/python2.6
g++ -shared example.o example_wrap.o -o _example.so

Answer 1

Inspired by the last example of: https://stackoverflow.com/a/8828454/3613373. I came up with a slightly different approach that does not use a variable to check the StopIterator exception state.

Also it only uses the begin() end end() iterators of Collection without requiring to expose (make public) the std::vector<Element> itself.

example.i:

%module example
%{
#include "example.h"
%}

%inline %{
class StopIterator {};
class Iterator {
  public:
    Iterator(Collection::iterator _cur, Collection::iterator _end) : cur(_cur), end(_end) {}
    Iterator* __iter__()
    {
      return this;
    }
    Collection::iterator cur;
    Collection::iterator end;
  };
%}

%include "example.h"

%include "exception.i"
%exception Iterator::next {
  try
  {
    $action // calls %extend function next() below
  }
  catch (StopIterator)
  {
    PyErr_SetString(PyExc_StopIteration, "End of iterator");
    return NULL;
  }
}

%extend Iterator
{
  Element& next()
  {
    if ($self->cur != $self->end)
    {
      // dereference the iterator and return reference to the object,
      // after that it increments the iterator
      return *$self->cur++;
    }
    throw StopIterator();
  }
}

%extend Collection {
  Iterator __iter__()
  {
    // return a constructed Iterator object
    return Iterator($self->begin(), $self->end());
  }
};

Only thing I could not figure out was how to create a templated version of Iterator in a way that I can pass just any Iterator<Collection, Element> without having to redefine next() for each template instantation. Solutions are welcome ;)

Answer 2

After hours of compiler errors I was able to generalize @boaz001 solution using swig macros.

---

iter.i

---

    %inline %{
    class SWIG_STOP_ITERATOR {};
    %}

    %define MAKE_CLASS_ITERABLE(
            CLASS,
            ITERATOR_CLASS,
            NEXT_RETURN_TYPE,
            HEADER)
    %inline %{
    class ITERATOR_CLASS {
            public:
            ITERATOR_CLASS(
            ##CLASS ::iterator _cur,
            ##CLASS ::iterator _end
            ) : cur(_cur), end(_end) {}
            ##ITERATOR_CLASS * __iter__()
            {
                return this;
            }
            ##CLASS ::iterator cur;
            ##CLASS ::iterator end;
    };
    %}
    %include HEADER
    %exception ITERATOR_CLASS::__next__ {
            try {
                $action;
            }
            catch (SWIG_STOP_ITERATOR)
            {
                PyErr_SetString(PyExc_StopIteration, "End of iterator");
                return NULL;
            }
    }

    %extend ITERATOR_CLASS {
            NEXT_RETURN_TYPE &__next__() {
                if ($self->cur != $self->end) {
                    return *$self->cur++;
                }
                throw SWIG_STOP_ITERATOR();
            }
    }

    %extend CLASS {
            ITERATOR_CLASS __iter__() {
                return ITERATOR_CLASS ($self->begin(), $self->end());
            }
    };
    %enddef

---

atom.h

---

#include <string>

    using namespace std;

    class Atom {
        public:
            Atom () = default;

            Atom (double x_, double y_ , double z_) :
                x(x_), y(y_), z(z_) {}

            Atom (double x_, double y_ , double z_, string name_) :
                    x(x_), y(y_), z(z_), name(move(name_)) {}

            double getX () const {
                return x;
            }
            void setX (double x_) {
                x = x_;
            }

            double getY () const {
                return y;
            }
            void setY (double y_) {
                y = y_;
            }

            double getZ () const {
                return z;
            }
            void setZ (double z_) {
                z = z_;
            }

            void setName(string name_) {
                name = move(name_);
            }

            string getName() {
                return name;
            }
        private:
            double x{};
            double y{};
            double z{};
            std::string name;
    };

---

node.h

---

#include atom.h
#include <vector>
#include <map>
    
using namespace std;

    class Node {
        public:
            Node () = default;

            ~Node () = default;

            void addAtom (Atom &atom_) {
                atoms.push_back(atom_);
            }

            Atom getAtom (int index) {
                return atoms.at(index);
            }

            typedef std::vector<Atom> tAtoms;
            typedef tAtoms::iterator iterator;
            typedef tAtoms::const_iterator const_iterator;

            //Define below 4 methods to make class compatible with iter.i

            iterator begin () {
                return atoms.begin();
            }

            const_iterator begin () const {
                return atoms.begin();
            }

            iterator end () {
                return atoms.end();
            }

            const_iterator end () const {
                return atoms.end();
            }
        private:
            tAtoms atoms;
     };

---

• node.i

---

%module node
    %include "std_string.i"
    %include "std_vector.i"
    %include "iter.i"
    %{
    #include "atom.h"
    #include "node.h"
    %}
    MAKE_CLASS_ITERABLE(Node, NodeIterator, Atom, "node.h")
    %include "atom.h"

---

example.py

---

from node import *
from random import random
node = Node()
for _ in range(10):
    node.addAtom(Atom(random(), random(), random(), f'atom{_}'))

for atom in node:
    atom_coords = f'{atom.getX()}, {atom.getY()}, {atom.getZ()}'
    atom_name = atom.getName()
    print("Name: ", atom_name, '\n', 'Coordinates: ', atom_coords)