#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
#include <boost/array.hpp>
const int NC=6;


using namespace boost::python;

typedef boost::array<float,NC> Tarr6;

template<class T, int N>
struct _arrayN
{
    typedef boost::array<T,N> arrayN;

    static T get(arrayN const& self, int idx) 
    {
      if( 0<=idx && idx<N ) return self[idx];
      PyErr_SetString(PyExc_KeyError,"index out of range");
      throw_error_already_set();
    }

    static boost::python::list getslice(arrayN const& self, int a,int b) 
    {
      if( !(0<=a<N && 0<b<=N) ) 
      {
       PyErr_SetString(PyExc_KeyError,"index out of range");
       throw_error_already_set();
      }
      if(b>N){b=N;}
      if(a<0){a=0;}
      boost::python::list t;
      for(int i=a;i<b;++i)
          t.append(self[i]);
       return t;
    }
    static void setslice(arrayN& self, int a,int b,boost::python::object& v) 
    {
      if( !(0<=a<N && 0<b<=N) ) 
      {
       PyErr_SetString(PyExc_KeyError,"index out of range");
       throw_error_already_set();
      }
      if(b>N){b=N;}
      if(a<0){a=0;}
      
      for(int i=a;i<b;++i)
          self[i]=extract<float>(v[i]);
    }
    static void set(arrayN& self, int idx, const T val) { self[idx]=val; }

    static boost::python::list values(arrayN const& self)
    {
        boost::python::list t;
        for(int i=0;i<N;++i)
            t.append(self[i]);
        return t;
    }
    static int size(arrayN const & self)
    {
     return NC;
    }
};


BOOST_PYTHON_MODULE(rbt10)
{
    class_<Tarr6>("Tarr6")
        .def("__len__", &_arrayN<float,NC>::size)
//        .def("__getitem__",&_arrayN<float,NC>::get,return_value_policy<copy_non_const_reference>())
        .def("__getitem__",&_arrayN<float,NC>::get)
        .def("__getslice__",&_arrayN<float,NC>::getslice)
        .def("__setslice__",&_arrayN<float,NC>::setslice)
        .def("__setitem__",&_arrayN<float,NC>::set)
        .def("values", &_arrayN<float,NC>::values)
    ;
}

        .add_property("cell",
            make_getter(&Agent::cell, return_value_policy<reference_existing_object>()),
            make_setter(&Agent::cell, return_value_policy<reference_existing_object>()))

In [18]: world.cells[0][3].agent_n
Out[18]: 2

In [19]: map(lambda a: a.agent_n, world.cells[0])
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)

/media/3f16c67b-5e31-48bf-85c2-65bfd35e49f3/250gb/dima/alife/model/<ipython console> in <module>()

TypeError: No to_python (by-value) converter found for C++ type: Cell*

typedef vector <Cell *> Row;

typedef vector <Row> Grid;

..............


    class_< Row >("Row")
        .def(vector_indexing_suite< Row >())
    ;
    
    class_< Grid >("Grid")
        .def(vector_indexing_suite< Grid >())
    ;