{

typedef typename boost::mpl::push_front<

typename SigArg<F,N-1>::T,

typename Arg<F,Arity<F>::V-N+1>::T

>::type T;

{

typedef typename boost::mpl::push_front<

typename SigArg<F,Arity<F>::V>::T,

typename Return<F>::T

>::type T;

{

static_assert(rank==std::rank<T>::value,"rank==std::rank<T>::value");

T* x;

ArrayGet(): x(0) {}

ArrayGet(T& x): x(&x) {}

typedef typename ArrayGetReturn<T,rank>::T L;

L get(size_t i) const

{return L((*x)[i]);}

void set(size_t i, const L& v) {assign((*x)[i],v);}

{

typedef typename MemberType<M>::T MT;

static constexpr size_t rank=std::rank<MT>::value;

static_assert(rank>0,"rank>0");

M m;

ArrayMemRef(M m): m(m) {}

typedef ArrayGet<MT,rank> L;

L operator()(T& o) const

{return L(o.*m);}

{

M m;

ArrayMemRefSetItem(M m): m(m) {}

typedef typename std::remove_all_extents<typename MemberType<M>::T>::type V;

void operator()(T& o, size_t i, V& v) const

{assign((o.*m)[i], v);}

{

typedef typename MemberType<M>::T E;

M m;

EnumGet(M m): m(m) {}

string operator()(const C& o) const {return enum_keys<E>()(o.*m);}

{

typedef typename MemberType<M>::T E;

M m;

EnumSet(M m): m(m) {}

void operator()(C& o, const string& v) const {o.*m=enum_keys<E>()(v);}

{

auto i=x.find(k);

if (i!=x.end())

return i->second;

else

throw std::runtime_error("key not found");

{

typedef typename T::const_iterator I;

I i, end;

Iterator() {}

Iterator(I begin, I end): i(begin), end(end) {}

typename T::key_type next() {

if (i==end)

throw StopIteration();

else

{

auto j=i++;

return j->first;

}

}

static void registerClass(python_t&);

{

static bool value=false;

if (value) return true;

value=true;

return false;

if (boost::python::len(args)>2)

{

auto& x=boost::python::extract<T&>(args[0])();

auto el=boost::python::extract<boost::python::list>(args[1]);

if (el.check())

assignList(x,el);

}

return boost::python::object(); //ie None

{

static PyObject* convert(E e)

{

return boost::python::incref

(boost::python::object

(classdesc::enum_keys<E>()(e)).ptr());

}

{

EnumFromStr()

{

boost::python::converter::registry::push_back

(&convertible, &construct,

boost::python::type_id<E>());

}

static void* convertible(PyObject* obj_ptr)

{

// Extract the character data from the python string

const char* value = to_string(obj_ptr);

if (!value || !classdesc::enum_keys<E>().has(value)) return 0;

return obj_ptr;

}

static void construct(

PyObject* obj_ptr,

boost::python::converter::rvalue_from_python_stage1_data* data)

{

// Extract the character data from the python string

const char* value = to_string(obj_ptr);

// Verify that obj_ptr is a string (should be ensured by convertible())

assert(value);

// Grab pointer to memory into which to construct the new enum

void* storage = (

(boost::python::converter::rvalue_from_python_storage<E>*)

data)->storage.bytes;

// in-place construct the new enum using the character data

// extraced from the python object

new (storage) E(classdesc::enum_keys<E>()(value));

// Stash the memory chunk pointer for later use by boost.python

data->convertible = storage;

}

{

struct Scope

{

struct PythonDummy {};

string name;

boost::python::class_<PythonDummy> object;

shared_ptr<boost::python::scope> scope;

Scope(const string& name):

name(name), object(name.c_str()), scope(new boost::python::scope(object)) {}

// default object refers to current module

Scope(): name(PyModule_GetName(boost::python::scope().ptr())),

object(name.c_str()), scope(new boost::python::scope(object)) {}

};

std::vector<Scope> scopeStack; //push back current module onto stack

boost::python::scope topScope;

std::map<string,shared_ptr<boost::python::object>> namedScope;

struct ExtractClassNameAndSetScope

{

string className, modName;

boost::python::scope topScope;

std::vector<std::shared_ptr<boost::python::scope>> scopeStack;

ExtractClassNameAndSetScope(python_t& p, const string& qualifiedName)

{

const char* b=qualifiedName.c_str(), *e;

int nAngle=0; // template argument handling

for (; *b==':'; b++); //strip any leading global namespace qualifier

for (e=b; *e; ++e)

switch (*e)

{

case ':':

if (nAngle==0 && *(e+1)==':')

{

if (!modName.empty()) modName+=".";

modName+=string(b,e);

auto i=p.namedScope.find(modName);

if (i==p.namedScope.end())

i=p.namedScope.emplace

(modName, std::make_shared<Class<Scope::PythonDummy,true>>(modName)).first; // ensure exists

scopeStack.emplace_back(new boost::python::scope(*i->second));

e++;

b=e+1;

}

break;

case '<':

nAngle++;

break;

case '>':

nAngle--;

break;

}

className=b;

}

};

public:

/// @{

/// class registry

struct ClassBase

{

virtual ~ClassBase() {}

bool completed=false, started=false;

template <class T, bool copiable> struct PyClass;

template <class T> struct PyClass<T,true>: public boost::python::class_<T>

{

PyClass(const char* n): boost::python::class_<T>(n,boost::python::no_init){}

};

template <class T> struct PyClass<T,false>: public boost::python::class_<T,boost::noncopyable>

{

PyClass(const char* n): boost::python::class_<T,boost::noncopyable>(n,boost::python::no_init){}

};

};

/// @{

/// helper method to expose a default constructor if it exists in the underlying C++ type

template <class T,bool copiable>

static typename enable_if<is_default_constructible<T>,void>::T

addDefaultConstructor(ClassBase::PyClass<T,copiable>& c)

{c.def(boost::python::init<>());}

template <class T,bool copiable>

static typename enable_if<Not<is_default_constructible<T>>,void>::T

addDefaultConstructor(ClassBase::PyClass<T,copiable>&)

{}

template <class T, bool copiable> struct Class:

public ClassBase, public ClassBase::PyClass<T,copiable>

{

Class(const string& name): ClassBase::PyClass<T,copiable>(name.c_str())

{

python_t::addDefaultConstructor(*this);

// define a default equality operator

defFn("__eq__",pythonDetail::defaultEquality<T>);

}

// distinguish between assignable and unassignable properties, which may be const, or may have assignment deleted

template <class X>

typename enable_if<

And<

std::is_copy_assignable<typename pythonDetail::MemberType<X>::T>,

Not<is_const<typename pythonDetail::MemberType<X>::T>>

>,void>::T

addProperty(const string& d, X x) {this->def_readwrite(d.c_str(),x);}

template <class X>

typename enable_if<

Or<

Not<std::is_copy_assignable<typename pythonDetail::MemberType<X>::T>>,

is_const<typename pythonDetail::MemberType<X>::T>

>,void>::T

addProperty(const string& d, X x) {this->def_readonly(d.c_str(),x);}

using PyClass<T,copiable>::def;

// handle "raw" functions, enabling variable arguments and overload dispatch

template <class F>

typename enable_if<pythonDetail::is_rawFunction<F>, Class&>::T

defFn(const char* n, F f) {

static_assert(Not<is_reference<typename functional::Return<F>::T>>::value,

"\nreference return of raw function not supported.\nUse boost::python::ptr instead");

PyClass<T,copiable>::def(n,boost::python::raw_function(f));

return *this;

}

template <class F>

typename enable_if<

And<

Not<pythonDetail::is_rawFunction<F>>,

functional::AllArgs<F, is_complete>,

is_copy_constructible<functional::Return<F>>

>, Class&>::T

defFn(const char* n, F f) {PyClass<T,copiable>::def(n,f); return *this;}

template <class F>

typename enable_if<

And<

Not<pythonDetail::is_rawFunction<F>>,

Not<functional::AllArgs<F, is_complete>>,

Not<is_copy_constructible<functional::Return<F>>>

>, Class&>::T

defFn(const char* n, F f) {return *this;}

template <class R, class... Args>

typename enable_if<is_reference<R>, Class&>::T

overload(const char* n, R (T::*m)(Args...)) {

PyClass<T,copiable>::def(n,m,boost::python::return_internal_reference<>());

return *this;

}

template <class R, class... Args>

typename enable_if<Not<is_reference<R>>, Class&>::T

overload(const char* n, R (T::*m)(Args...)) {

PyClass<T,copiable>::def(n,m);

return *this;

}

template <class R, class O,class... Args>

typename enable_if<is_reference<R>, Class&>::T

overload(const char* n, R (T::*m)(Args...),const O& o) {

PyClass<T,copiable>::def(n,m,o[boost::python::return_internal_reference<>()]);

return *this;

}

template <class R, class O, class... Args>

typename enable_if<Not<is_reference<R>>, Class&>::T

overload(const char* n, R (T::*m)(Args...), const O& o) {

PyClass<T,copiable>::def(n,m,o);

return *this;

}

template <class R, class... Args>

typename enable_if<is_reference<R>, Class&>::T

overload(const char* n, R (T::*m)(Args...) const) {

PyClass<T,copiable>::def(n,m,boost::python::return_internal_reference<>());

return *this;

}

template <class R, class... Args>

typename enable_if<Not<is_reference<R>>, Class&>::T

overload(const char* n, R (T::*m)(Args...) const) {

PyClass<T,copiable>::def(n,m);

return *this;

}

template <class R, class O,class... Args>

typename enable_if<is_reference<R>, Class&>::T

overload(const char* n, R (T::*m)(Args...) const,const O& o) {

PyClass<T,copiable>::def(n,m,o[boost::python::return_internal_reference<>()]);

return *this;

}

template <class R, class O, class... Args>

typename enable_if<Not<is_reference<R>>, Class&>::T

overload(const char* n, R (T::*m)(Args...) const, const O& o) {

PyClass<T,copiable>::def(n,m,o);

return *this;

}

};

// lazy instantiation pattern to avoid needing an object file, and

// link time ordering dependencyy

//can be cleared after all python descriptor processing has

// finished to free memory, otherwise the descriptor will

// potentially throw an exception if this vector is cleared

static std::vector<shared_ptr<ClassBase> >& classes()

{

static std::vector<shared_ptr<ClassBase> > impl;

return impl;

}

// lazy instantiation pattern to register a unique class object

// per type.

template <class T>

Class<T,is_copy_constructible<T>::value>& getClass()

{

typedef Class<T,is_copy_constructible<T>::value> C;

static size_t id=classes().size();

if (id==classes().size())

{

ExtractClassNameAndSetScope scope(*this,typeName<T>());

classes().push_back(shared_ptr<ClassBase>(new C(scope.className)));

string pyQualName;

if (!scope.modName.empty()) pyQualName=scope.modName+".";

pyQualName+=scope.className;

// insert a reference to this class object for handling class scoped names

if (!namedScope.count(pyQualName))

namedScope.emplace

(pyQualName, std::dynamic_pointer_cast<boost::python::object>(classes().back()));

}

else if (id>classes().size())

throw exception("classes registry no longer valid");

return dynamic_cast<C&>(*classes()[id]);

}

/// @}

string tail(const string& d) {

size_t p=d.rfind('.');

if (p==string::npos)

return d;

else

return d.substr(p+1);

}

void checkScope(string d) {

size_t level=0;

for (size_t p=d.find('.'); p!=string::npos; p=d.find('.'), level++)

{

string head=d.substr(0,p);

if (level<scopeStack.size() && head!=scopeStack[level].name)

scopeStack.erase(scopeStack.begin()+level,scopeStack.end());

if (level==scopeStack.size())

scopeStack.push_back(Scope(head));

d=d.substr(p+1);

}

scopeStack.erase(scopeStack.begin()+level,scopeStack.end());

// final component of d is not part of scope

}

// recursively define classes of arguments

template <class F, int N>

struct DefineArgClasses {

static void define(python_t& p) {

typedef typename remove_const<

typename remove_reference<

typename functional::Arg<F,N>::T

>::type

>::type T;

if (!pythonDetail::classDefStarted<T>())

p.defineClass<T>();

DefineArgClasses<F,N-1>::define(p);

}

};

template <class F>

struct DefineArgClasses<F,0> {

static void define(python_t& p) {

typedef typename remove_const<

typename remove_reference<

typename functional::Return<F>::T

>::type

>::type T;

if (!pythonDetail::classDefStarted<T>())

// define return type

p.defineClass<T>();

}

};

template <class T>

typename enable_if<std::is_copy_assignable<T>,void>::T

addObject(const string& d, T& o) {

using namespace boost::python;

checkScope(d);

if (!scopeStack.empty())

scopeStack.back().object.def_readwrite(tail(d).c_str(),o);

else

extract<dict>(scope().attr("__dict__"))()[tail(d).c_str()]=ptr(&o);

}

template <class T>

typename enable_if<Not<std::is_copy_assignable<T>>,void>::T

addObject(const string& d, const T& o) {

using namespace boost::python;

checkScope(d);

if (!scopeStack.empty())

scopeStack.back().object.def_readonly(tail(d).c_str(),o);

else

extract<dict>(scope().attr("__dict__"))()[tail(d).c_str()]=ptr(&o);

}

template <class F>

typename enable_if<Not<is_pointer<typename functional::Return<F>::T>>, void>::T

addFunctional(const string& d, F f) {

checkScope(d);

boost::python::def(tail(d).c_str(),f);

if (!scopeStack.empty())

scopeStack.back().object.staticmethod(tail(d).c_str());

DefineArgClasses<F,functional::Arity<F>::value>::define(*this);

}

// ignore pointer returns, as we don't know anything about the object being pointed to.

template <class F>

typename enable_if<is_pointer<typename functional::Return<F>::T>, void>::T

addFunctional(const string&, F) {}

// no object present, update class definition

template <class C, class M>

typename enable_if<

And<

Not<is_reference<typename functional::Return<M>::T>>,

Not<is_pointer<typename functional::Return<M>::T>>

>,void>::T

addMemberFunction(const string& d, M m)

{

auto& c=getClass<C>();

if (!c.completed)

c.defFn(tail(d).c_str(),m);

DefineArgClasses<M,functional::Arity<M>::value>::define(*this);

}

// for methods returning a reference, create a wrapper object that

// can be pythonified

template <class C, class M>

typename enable_if<is_reference<typename functional::Return<M>::T>,void>::T

addMemberFunction(const string& d, M m)

{

auto& c=getClass<C>();

if (!c.completed)

c.def(tail(d).c_str(),m,boost::python::return_internal_reference<>());

DefineArgClasses<M,functional::Arity<M>::value>::define(*this);

}

// ignore pointer returns, as we don't know anything about the object being pointed to.

template <class C, class M>

typename enable_if<is_pointer<typename functional::Return<M>::T>,void>::T

addMemberFunction(const string&, M) {}

template <class C, class M>

typename enable_if<functional::is_nonmember_function_ptr<M>,void>::T

addMemberObject(const string& d, M m)

{

auto& c=getClass<C>();

if (!c.completed)

c.defFn(tail(d).c_str(),m);

}

template <class C, class M>

typename enable_if<And<Not<is_Carray<typename pythonDetail::MemberType<M>::T> >, Not<functional::is_nonmember_function_ptr<M> > >,void>::T

addMemberObject(const string& d, M m)

{

auto& c=getClass<C>();

if (!c.completed)

c.addProperty(tail(d),m);

// ensure member type is registered

DefineArgClasses<M,0>::define(*this);

}

template <class C, class M>

typename enable_if<is_Carray<typename pythonDetail::MemberType<M>::T>,void>::T

addMemberObject(const string& d, M m)

{

auto& c=getClass<C>();

if (!c.completed)

c.add_property(tail(d).c_str(), pythonDetail::ArrayMemRef<C,M>(m),

pythonDetail::ArrayMemRef<C,M>(m));

pythonDetail::ArrayMemRef<C,M>::L::registerClass(*this);

}

template <class C, class M>

typename enable_if<

And<is_member_function_pointer<M>,

functional::AllArgs<M,PythonTypableMember>,

Not<is_pointer<typename functional::Return<M>::T>>

>,void>::T

addMember(const string& d, M m) {addMemberFunction<C>(d,m);}

template <class C, class M>

typename enable_if<And<is_member_object_pointer<M>,

PythonTypableMember<M>,

Not<functional::is_nonmember_function_ptr<M> >

>,void>::T

addMember(const string& d, M m) {addMemberObject<C>(d,m);}

template <class C, class M>

typename enable_if<And<is_member_object_pointer<M>,

Or<

Not<PythonTypableMember<M>>,

functional::is_nonmember_function_ptr<M>

>>,void>::T

addMember(const string& d, M m) {}

template <class C, class M>

typename enable_if<

And<

functional::is_nonmember_function_ptr<M>,

functional::AllArgs<M,PythonTypableMember>,

Not<is_pointer<typename functional::Return<M>::T>>

>,void>::T

addMember(const string& d, M m) {

auto& c=getClass<C>();

if (!c.completed)

c.defFn(tail(d).c_str(),m);

}

// ignore pointer returns, and unassignable arguments

template <class C, class M>

typename enable_if<

Or<

is_pointer<typename functional::Return<M>::T>,

Not<functional::AllArgs<M, PythonTypableMember>>

>, void>::T

addMember(const string&, M) {}

template <class C, class T>

void addStaticMember(const string& d, T* a) {

auto& c=getClass<C>();

if (!c.completed)

c.addProperty(tail(d).c_str(),a);

}

template <class C, class M>

void addConstructor(M) {

auto& c=getClass<C>();

if (!c.completed)

c.def(typename pythonDetail::Init<M>::T());

DefineArgClasses<M,functional::Arity<M>::value>::define(*this);

}

template <class C, class M>

void addEnum(const string& d, M m)

{

auto& c=getClass<C>();

if (!c.completed)

c.add_property(tail(d).c_str(),pythonDetail::enumGet<C>(m),pythonDetail::enumSet<C>(m));

}

/// utility method to add a Python wrapper class for \a T

template <class T>

typename enable_if<Not<is_abstract<T> >, void>::T

defineClass() {python<T>(*this,"");}

template <class T>

typename enable_if<is_abstract<T>, void>::T

defineClass() {}

template <class E>

void defineEnum();

{

T x;

for (int i=0; i<boost::python::len(y); ++i)

x.push_back(boost::python::extract<typename T::value_type>(y[i]));

return x;

{

boost::shared_ptr<T> x(new T);

assignList(*x,y);

return x;

auto& c=p.getClass<C>();