[Swig-user] wrapper for std::tr1::array

[Russell E. O. <ro...@uw...>]

I asked earlier suggestions on wrapping C++ std::tr1::array in Python.

I finally came up with the following, which I present in case anyone 
else finds it useful. I only care about short arrays, so I didn't bother 
with a numpy interface. Suggested improvements would be welcome.

----- array.i -----

%{
#include <tr1/array>
%}

%import "std_except.i"
%include "array.h"

%extend std::tr1::array {
    inline size_t __len__() const { return $self->size(); }

    inline const value_type& _get(size_t i) const 
throw(std::out_of_range) {
        return $self->at(i);
    }

    inline void _set(size_t i, const value_type& v) 
throw(std::out_of_range) {
        $self->at(i) = v;
    }

    %pythoncode {
        def __getitem__(self, key):
            if isinstance(key, slice):
                return tuple(self._get(i) for i in 
range(*key.indices(len(self))))

            if key < 0:
                key += len(self)
            return self._get(key)
        
        def __setitem__(self, key, v):
            if isinstance(key, slice):
                for i in range(*key.indices(len(self))):
                    self._set(i, v[i])
            else:
                if key < 0:
                    key += len(self)
                self._set(key, v)

        def __repr__(self):
            return "%s(%s)" % (self.__class__.__name__, ", ".join(str(v) 
for v in self[:]))
    }
}

%template (ArrayD3) std::tr1::array<double, 3>;
...

------ and of array.i -----

I found that SWIG could not %include the real array.h file (some of the 
syntax confused it), so I made the following minimal copy of that. It 
could probably be even more minimal (e.g. fewer includes).

------ array.h ------

#pragma once
// minimal version of tr1::array, for SWIG

#include <new>
#include <iterator>
#include <algorithm>
#include <cstddef>
#include <bits/functexcept.h>
#include <ext/type_traits.h>

//namespace std::tr1
namespace std {
namespace tr1 {

  template<typename _Tp, std::size_t _Nm>
    struct array
    {
      typedef _Tp                      value_type;
      typedef value_type&                          reference;
      typedef const value_type&                    const_reference;
      typedef value_type*                    iterator;
      typedef const value_type*              const_iterator;
      typedef std::size_t                             size_type;
      typedef std::ptrdiff_t                          difference_type;
      typedef std::reverse_iterator<iterator>         reverse_iterator;
      typedef std::reverse_iterator<const_iterator>   
const_reverse_iterator;

      void assign(const value_type& __u);

      size_type size() const;

      reference at(size_type __n);
    };

}}

----- end of array.h -----