{

public:

ExtensionModuleBase( const char *name );

virtual ~ExtensionModuleBase();

Module module( void ) const; // only valid after initialize() has been called

Dict moduleDictionary( void ) const; // only valid after initialize() has been called

virtual Object invoke_method_noargs( void *method_def ) = 0;

virtual Object invoke_method_keyword( void *method_def, const Tuple &_args, const Dict &_keywords ) = 0;

virtual Object invoke_method_varargs( void *method_def, const Tuple &_args ) = 0;

const std::string &name() const;

const std::string &fullName() const;

// what is returned from PyInit_<module> function

Object moduleObject( void ) const;

protected:

// Initialize the module

void initialize( const char *module_doc );

const std::string m_module_name;

const std::string m_full_module_name;

MethodTable m_method_table;

#if PY3

PyModuleDef m_module_def;

#endif

PyObject *m_module;

private:

//

// prevent the compiler generating these unwanted functions

//

ExtensionModuleBase( const ExtensionModuleBase & ); //unimplemented

void operator=( const ExtensionModuleBase & ); //unimplemented

{

public:

ExtensionModule( const char *name )

: ExtensionModuleBase( name )

{}

virtual ~ExtensionModule()

{}

protected:

typedef Object (T::*method_noargs_function_t)();

typedef Object (T::*method_varargs_function_t)( const Tuple &args );

typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws );

typedef std::map<std::string, MethodDefExt<T> *> method_map_t;

static void add_noargs_method( const char *name, method_noargs_function_t function, const char *doc="" )

{

method_map_t &mm = methods();

mm[ std::string( name ) ] = new MethodDefExt<T>( name, function, method_noargs_call_handler, doc );

}

static void add_varargs_method( const char *name, method_varargs_function_t function, const char *doc="" )

{

method_map_t &mm = methods();

mm[ std::string( name ) ] = new MethodDefExt<T>( name, function, method_varargs_call_handler, doc );

}

static void add_keyword_method( const char *name, method_keyword_function_t function, const char *doc="" )

{

method_map_t &mm = methods();

mm[ std::string( name ) ] = new MethodDefExt<T>( name, function, method_keyword_call_handler, doc );

}

void initialize( const char *module_doc="" )

{

ExtensionModuleBase::initialize( module_doc );

Dict dict( moduleDictionary() );

//

// put each of the methods into the modules dictionary

// so that we get called back at the function in T.

//

method_map_t &mm = methods();

EXPLICIT_TYPENAME method_map_t::const_iterator i = mm.begin();

EXPLICIT_TYPENAME method_map_t::const_iterator i_end = mm.end();

for ( ; i != i_end; ++i )

{

MethodDefExt<T> *method_def = (*i).second;

#if PY_VERSION_HEX < 0x02070000

static PyObject *self = PyCObject_FromVoidPtr( this, do_not_dealloc );

#else

static PyObject *self = PyCapsule_New( this, NULL, NULL );

#endif

Tuple args( 2 );

args[0] = Object( self );

#if PY_VERSION_HEX < 0x02070000

args[1] = Object( PyCObject_FromVoidPtr( method_def, do_not_dealloc ) );

#else

args[1] = Object( PyCapsule_New( method_def, NULL, NULL ) );

#endif

PyObject *func = PyCFunction_New

(

&method_def->ext_meth_def,

new_reference_to( args )

);

method_def->py_method = Object( func, true );

dict[ (*i).first ] = method_def->py_method;

}

}

protected: // Tom Malcolmson reports that derived classes need access to these

static method_map_t &methods( void )

{

static method_map_t *map_of_methods = NULL;

if( map_of_methods == NULL )

map_of_methods = new method_map_t;

return *map_of_methods;

}

// this invoke function must be called from within a try catch block

virtual Object invoke_method_noargs( void *method_def )

{

// cast up to the derived class, method_def and call

T *self = static_cast<T *>( this );

MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>( method_def );

return (self->*meth_def->ext_noargs_function)();

}

// this invoke function must be called from within a try catch block

virtual Object invoke_method_varargs( void *method_def, const Tuple &args )

{

// cast up to the derived class, method_def and call

T *self = static_cast<T *>( this );

MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>( method_def );

return (self->*meth_def->ext_varargs_function)( args );

}

// this invoke function must be called from within a try catch block

virtual Object invoke_method_keyword( void *method_def, const Tuple &args, const Dict &keywords )

{

// cast up to the derived class, method_def and call

T *self = static_cast<T *>( this );

MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>( method_def );

return (self->*meth_def->ext_keyword_function)( args, keywords );

}

private:

//

// prevent the compiler generating these unwanted functions

//

ExtensionModule( const ExtensionModule<T> & ); //unimplemented

void operator=( const ExtensionModule<T> & ); //unimplemented