/* This file was generated by PyBindGen 0.15.0 */
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h>


#if PY_VERSION_HEX < 0x020400F0

#define PyEval_ThreadsInitialized() 1

#define Py_CLEAR(op)				\
        do {                            	\
                if (op) {			\
                        PyObject *tmp = (PyObject *)(op);	\
                        (op) = NULL;		\
                        Py_DECREF(tmp);		\
                }				\
        } while (0)


#define Py_VISIT(op)							\
        do { 								\
                if (op) {						\
                        int vret = visit((PyObject *)(op), arg);	\
                        if (vret)					\
                                return vret;				\
                }							\
        } while (0)

#endif



#if PY_VERSION_HEX < 0x020500F0

typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intobjargproc ssizeobjargproc;

#endif


#if     __GNUC__ > 2
# define PYBINDGEN_UNUSED(param) param __attribute__((__unused__))
#elif     __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
# define PYBINDGEN_UNUSED(param) __attribute__((__unused__)) param
#else
# define PYBINDGEN_UNUSED(param) param
#endif  /* !__GNUC__ */

typedef enum _PyBindGenWrapperFlags {
   PYBINDGEN_WRAPPER_FLAG_NONE = 0,
   PYBINDGEN_WRAPPER_FLAG_OBJECT_NOT_OWNED = (1<<0),
} PyBindGenWrapperFlags;


#include "foo.h"
#include <typeinfo>
#include <ostream>
#include <sstream>
#include <map>
#include <iostream>
/* --- forward declarations --- */


typedef struct {
    PyObject_HEAD
    AbstractBaseClass *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyAbstractBaseClass;


extern PyTypeObject PyAbstractBaseClass_Type;

extern std::map<void*, PyObject*> PyAbstractBaseClass_wrapper_registry;

typedef struct {
    PyObject_HEAD
    AbstractBaseClass2 *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyAbstractBaseClass2;


extern PyTypeObject PyAbstractBaseClass2_Type;

class PyAbstractBaseClass2__PythonHelper : public AbstractBaseClass2
{
public:
    PyObject *m_pyself;
    PyAbstractBaseClass2__PythonHelper()
        : AbstractBaseClass2(), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PyAbstractBaseClass2__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    static PyObject * _wrap_protected_virtual(PyAbstractBaseClass2 *self, PyObject *args, PyObject *kwargs);
    inline int protected_virtual__parent_caller(int x)
    { return AbstractBaseClass2::protected_virtual(x); }

    virtual int protected_pure_virtual(int x) const;

    virtual int protected_virtual(int x) const;

    virtual int private_virtual(int x) const;
};

extern std::map<void*, PyObject*> PyAbstractBaseClass2_wrapper_registry;

typedef struct {
    PyObject_HEAD
    AbstractBaseClassImpl *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyAbstractBaseClassImpl;


extern PyTypeObject PyAbstractBaseClassImpl_Type;


typedef struct {
    PyObject_HEAD
    AbstractXpto *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyAbstractXpto;


extern PyTypeObject PyAbstractXpto_Type;

class PyAbstractXpto__PythonHelper : public AbstractXpto
{
public:
    PyObject *m_pyself;
    PyAbstractXpto__PythonHelper(AbstractXpto const & arg0)
        : AbstractXpto(arg0), m_pyself(NULL)
        {}

    PyAbstractXpto__PythonHelper()
        : AbstractXpto(), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PyAbstractXpto__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    virtual void something(int x) const;
};

extern std::map<void*, PyObject*> PyAbstractXpto_wrapper_registry;

typedef struct {
    PyObject_HEAD
    AbstractXptoImpl *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyAbstractXptoImpl;


extern PyTypeObject PyAbstractXptoImpl_Type;

class PyAbstractXptoImpl__PythonHelper : public AbstractXptoImpl
{
public:
    PyObject *m_pyself;
    PyAbstractXptoImpl__PythonHelper(AbstractXptoImpl const & arg0)
        : AbstractXptoImpl(arg0), m_pyself(NULL)
        {}

    PyAbstractXptoImpl__PythonHelper()
        : AbstractXptoImpl(), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PyAbstractXptoImpl__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    virtual void something(int x) const;
};


typedef struct {
    PyObject_HEAD
    Box *obj;
    PyBindGenWrapperFlags flags:8;
} PyBox;


extern PyTypeObject PyBox_Type;
extern PyTypeObject PyBoxMeta_Type;

extern std::map<void*, PyObject*> PyBox_wrapper_registry;

typedef struct {
    PyObject_HEAD
    CannotBeConstructed *obj;
    PyBindGenWrapperFlags flags:8;
} PyCannotBeConstructed;


extern PyTypeObject PyCannotBeConstructed_Type;

extern std::map<void*, PyObject*> PyCannotBeConstructed_wrapper_registry;

typedef struct {
    PyObject_HEAD
    ClassThatTakesFoo *obj;
    PyBindGenWrapperFlags flags:8;
} PyClassThatTakesFoo;


extern PyTypeObject PyClassThatTakesFoo_Type;

extern std::map<void*, PyObject*> PyClassThatTakesFoo_wrapper_registry;

typedef struct {
    PyObject_HEAD
    ClassThatThrows *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyClassThatThrows;


extern PyTypeObject PyClassThatThrows_Type;

class PyClassThatThrows__PythonHelper : public ClassThatThrows
{
public:
    PyObject *m_pyself;
    PyClassThatThrows__PythonHelper(ClassThatThrows const & arg0)
        : ClassThatThrows(arg0), m_pyself(NULL)
        {}

    PyClassThatThrows__PythonHelper(double x)
        : ClassThatThrows(x), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PyClassThatThrows__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    virtual int throw_error() const throw (std::exception);
};

extern std::map<void*, PyObject*> PyClassThatThrows_wrapper_registry;

typedef struct {
    PyObject_HEAD
    Foo *obj;
    PyBindGenWrapperFlags flags:8;
} PyFoo;


extern PyTypeObject PyFoo_Type;
extern PyTypeObject PyFooMeta_Type;



#include <map>
#include <typeinfo>
#if defined(__GNUC__) && __GNUC__ >= 3
# include <cxxabi.h>
#endif

namespace pybindgen {

class TypeMap
{
   std::map<const char *, PyTypeObject *> m_map;

public:

   TypeMap() {}

   void register_wrapper(const std::type_info &cpp_type_info, PyTypeObject *python_wrapper)
   {
       m_map[cpp_type_info.name()] = python_wrapper;
   }

   PyTypeObject * lookup_wrapper(const std::type_info &cpp_type_info, PyTypeObject *fallback_wrapper)
   {
       PyTypeObject *python_wrapper = m_map[cpp_type_info.name()];
       if (python_wrapper)
           return python_wrapper;
       else {
#if defined(__GNUC__) && __GNUC__ >= 3

           // Get closest (in the single inheritance tree provided by cxxabi.h)
           // registered python wrapper.
           const abi::__si_class_type_info *_typeinfo =
               dynamic_cast<const abi::__si_class_type_info*> (&cpp_type_info);
           while (_typeinfo && (python_wrapper = m_map[_typeinfo->name()]) == 0)
               _typeinfo = dynamic_cast<const abi::__si_class_type_info*> (_typeinfo->__base_type);

           return python_wrapper? python_wrapper : fallback_wrapper;

#else // non gcc 3+ compilers can only match against explicitly registered classes, not hidden subclasses
           return fallback_wrapper;
#endif
       }
   }
};

}


extern pybindgen::TypeMap PyFoo__typeid_map;

extern std::map<void*, PyObject*> PyFoo_wrapper_registry;

typedef struct {
    PyObject_HEAD
    Foobar *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyFoobar;


extern PyTypeObject PyFoobar_Type;
extern PyTypeObject PyFoobarMeta_Type;

extern std::map<void*, PyObject*> PyFoobar_wrapper_registry;

typedef struct {
    PyObject_HEAD
    InterfaceId *obj;
    PyBindGenWrapperFlags flags:8;
} PyInterfaceId;


extern PyTypeObject PyInterfaceId_Type;

extern std::map<void*, PyObject*> PyInterfaceId_wrapper_registry;

typedef struct {
    PyObject_HEAD
    Bar *obj;
    PyBindGenWrapperFlags flags:8;
} PyBar;


extern PyTypeObject PyBar_Type;


typedef struct {
    PyObject_HEAD
    MIRoot *obj;
    PyBindGenWrapperFlags flags:8;
} PyMIRoot;


extern PyTypeObject PyMIRoot_Type;

extern std::map<void*, PyObject*> PyMIRoot_wrapper_registry;

typedef struct {
    PyObject_HEAD
    ManipulatedObject *obj;
    PyBindGenWrapperFlags flags:8;
} PyManipulatedObject;


extern PyTypeObject PyManipulatedObject_Type;

extern std::map<void*, PyObject*> PyManipulatedObject_wrapper_registry;

typedef struct {
    PyObject_HEAD
    MapLike *obj;
    PyBindGenWrapperFlags flags:8;
} PyMapLike;


extern PyTypeObject PyMapLike_Type;


typedef struct {
    PyObject_HEAD
    PyMapLike *container;
    MapLike::Iterator *iterator;
} PyMapLike_Iter;


extern PyTypeObject PyMapLike_IterType;

extern std::map<void*, PyObject*> PyMapLike_wrapper_registry;

typedef struct {
    PyObject_HEAD
    PointerHolder< Zbr > *obj;
    PyBindGenWrapperFlags flags:8;
} PyPointerHolder__Zbr;


extern PyTypeObject PyPointerHolder__Zbr_Type;

extern std::map<void*, PyObject*> PyPointerHolder__Zbr_wrapper_registry;

typedef struct {
    PyObject_HEAD
    ProtectedConstructor *obj;
    PyBindGenWrapperFlags flags:8;
} PyProtectedConstructor;


extern PyTypeObject PyProtectedConstructor_Type;

extern std::map<void*, PyObject*> PyProtectedConstructor_wrapper_registry;

typedef struct {
    PyObject_HEAD
    ReferenceManipulator *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyReferenceManipulator;


extern PyTypeObject PyReferenceManipulator_Type;

class PyReferenceManipulator__PythonHelper : public ReferenceManipulator
{
public:
    PyObject *m_pyself;
    PyReferenceManipulator__PythonHelper()
        : ReferenceManipulator(), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PyReferenceManipulator__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    virtual void do_manipulate_object(ManipulatedObject & obj);
};

extern std::map<void*, PyObject*> PyReferenceManipulator_wrapper_registry;

typedef struct {
    PyObject_HEAD
    SingletonClass *obj;
    PyBindGenWrapperFlags flags:8;
} PySingletonClass;


extern PyTypeObject PySingletonClass_Type;

extern std::map<void*, PyObject*> PySingletonClass_wrapper_registry;

typedef struct {
    PyObject_HEAD
    Socket *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PySocket;


extern PyTypeObject PySocket_Type;

class PySocket__PythonHelper : public Socket
{
public:
    PyObject *m_pyself;
    PySocket__PythonHelper()
        : Socket(), m_pyself(NULL)
        {}

    PySocket__PythonHelper(Socket const & arg0)
        : Socket(arg0), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PySocket__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    virtual int Bind();

    virtual int Bind(int address);
};

extern std::map<void*, PyObject*> PySocket_wrapper_registry;

typedef struct {
    PyObject_HEAD
    SomeObject *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PySomeObject;


extern PyTypeObject PySomeObject_Type;
extern PyTypeObject PySomeObjectMeta_Type;

class PySomeObject__PythonHelper : public SomeObject
{
public:
    PyObject *m_pyself;
    PySomeObject__PythonHelper(SomeObject const & other)
        : SomeObject(other), m_pyself(NULL)
        {}

    PySomeObject__PythonHelper(std::string const prefix)
        : SomeObject(prefix), m_pyself(NULL)
        {}

    PySomeObject__PythonHelper(int prefix_len)
        : SomeObject(prefix_len), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PySomeObject__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    static PyObject * _wrap_protected_method_that_is_not_virtual(PySomeObject *self, PyObject *args, PyObject *kwargs);
    inline std::string protected_method_that_is_not_virtual__parent_caller(std::string arg)
    { return SomeObject::protected_method_that_is_not_virtual(arg); }

    virtual std::string get_prefix() const;

    virtual std::string get_prefix_with_foo_ptr(Foo const *foo) const;

    virtual std::string get_prefix_with_foo_ref(Foo const & foo) const;

    virtual std::string get_prefix_with_foo_value(Foo foo) const;

    virtual PyObject * get_pyobject();

    virtual std::string get_something() const;

    virtual std::string get_something(int x) const;

    virtual void set_pyobject(PyObject *pyobject);
};

extern std::map<void*, PyObject*> PySomeObject_wrapper_registry;

typedef struct {
    PyObject_HEAD
    SomeObject::NestedClass *obj;
    PyBindGenWrapperFlags flags:8;
} PySomeObjectNestedClass;


extern PyTypeObject PySomeObjectNestedClass_Type;
extern PyTypeObject PySomeObjectNestedClassMeta_Type;


extern pybindgen::TypeMap PySomeObjectNestedClass__typeid_map;

extern std::map<void*, PyObject*> PySomeObjectNestedClass_wrapper_registry;

typedef struct {
    PyObject_HEAD
    TestContainer *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyTestContainer;


extern PyTypeObject PyTestContainer_Type;

class PyTestContainer__PythonHelper : public TestContainer
{
public:
    PyObject *m_pyself;
    PyTestContainer__PythonHelper(TestContainer const & arg0)
        : TestContainer(arg0), m_pyself(NULL)
        {}

    PyTestContainer__PythonHelper()
        : TestContainer(), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PyTestContainer__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    virtual SimpleStructList get_simple_list();

    virtual SimpleStructMap get_simple_map();

    virtual SimpleStructVec get_simple_vec();

    virtual int set_simple_list(SimpleStructList list);

    virtual int set_simple_list_by_ref(SimpleStructList & inout_list);

    virtual int set_simple_map(SimpleStructMap map);

    virtual int set_simple_vec(SimpleStructVec vec);
};

extern std::map<void*, PyObject*> PyTestContainer_wrapper_registry;

typedef struct {
    PyObject_HEAD
    Tupl *obj;
    PyBindGenWrapperFlags flags:8;
} PyTupl;


extern PyTypeObject PyTupl_Type;

extern std::map<void*, PyObject*> PyTupl_wrapper_registry;

typedef struct {
    PyObject_HEAD
    UdpSocket *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyUdpSocket;


extern PyTypeObject PyUdpSocket_Type;

class PyUdpSocket__PythonHelper : public UdpSocket
{
public:
    PyObject *m_pyself;
    PyUdpSocket__PythonHelper()
        : UdpSocket(), m_pyself(NULL)
        {}

    PyUdpSocket__PythonHelper(UdpSocket const & arg0)
        : UdpSocket(arg0), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PyUdpSocket__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    virtual int Bind();

    virtual int Bind(int address);
};


typedef struct {
    PyObject_HEAD
    VectorLike *obj;
    PyBindGenWrapperFlags flags:8;
} PyVectorLike;


extern PyTypeObject PyVectorLike_Type;

extern std::map<void*, PyObject*> PyVectorLike_wrapper_registry;

typedef struct {
    PyObject_HEAD
    VectorLike2 *obj;
    PyBindGenWrapperFlags flags:8;
} PyVectorLike2;


extern PyTypeObject PyVectorLike2_Type;


typedef struct {
    PyObject_HEAD
    PyVectorLike2 *container;
    VectorLike2::Iterator *iterator;
} PyVectorLike2_Iter;


extern PyTypeObject PyVectorLike2_IterType;

extern std::map<void*, PyObject*> PyVectorLike2_wrapper_registry;

typedef struct {
    PyObject_HEAD
    Word *obj;
    PyBindGenWrapperFlags flags:8;
} PyWord;


extern PyTypeObject PyWord_Type;

extern std::map<void*, PyObject*> PyWord_wrapper_registry;

typedef struct {
    PyObject_HEAD
    Zbr *obj;
    PyObject *inst_dict;
    PyBindGenWrapperFlags flags:8;
} PyZbr;


extern PyTypeObject PyZbr_Type;
extern PyTypeObject PyZbrMeta_Type;

class PyZbr__PythonHelper : public Zbr
{
public:
    PyObject *m_pyself;
    PyZbr__PythonHelper()
        : Zbr(), m_pyself(NULL)
        {}

    PyZbr__PythonHelper(std::string datum)
        : Zbr(datum), m_pyself(NULL)
        {}

    PyZbr__PythonHelper(Zbr const & other)
        : Zbr(other), m_pyself(NULL)
        {}


    void set_pyobj(PyObject *pyobj)
    {
        Py_XDECREF(m_pyself);
        Py_INCREF(pyobj);
        m_pyself = pyobj;
    }

    virtual ~PyZbr__PythonHelper()
    {
        Py_CLEAR(m_pyself);
    }


    virtual int get_int(int x);
};

extern std::map<void*, PyObject*> PyZbr_wrapper_registry;

typedef struct {
    PyObject_HEAD
    Zoo *obj;
    PyBindGenWrapperFlags flags:8;
} PyZoo;


extern PyTypeObject PyZoo_Type;


extern pybindgen::TypeMap PyZoo__typeid_map;

extern std::map<void*, PyObject*> PyZoo_wrapper_registry;

typedef struct {
    PyObject_HEAD
    property< std::string > *obj;
    PyBindGenWrapperFlags flags:8;
} PyProperty__StdString;


extern PyTypeObject PyProperty__StdString_Type;

extern std::map<void*, PyObject*> PyProperty__StdString_wrapper_registry;

typedef struct {
    PyObject_HEAD
    simple_struct_t *obj;
    PyBindGenWrapperFlags flags:8;
} PySimple_struct_t;


extern PyTypeObject PySimple_struct_t_Type;

extern std::map<void*, PyObject*> PySimple_struct_t_wrapper_registry;

typedef struct {
    PyObject_HEAD
    MIBase1 *obj;
    PyBindGenWrapperFlags flags:8;
} PyMIBase1;


extern PyTypeObject PyMIBase1_Type;


typedef struct {
    PyObject_HEAD
    MIBase2 *obj;
    PyBindGenWrapperFlags flags:8;
} PyMIBase2;


extern PyTypeObject PyMIBase2_Type;


typedef struct {
    PyObject_HEAD
    MIMixed *obj;
    PyBindGenWrapperFlags flags:8;
} PyMIMixed;


extern PyTypeObject PyMIMixed_Type;


typedef struct {
    PyObject_HEAD
    std::vector< std::string > *obj;
} Pystd__vector__lt___std__string___gt__;


typedef struct {
    PyObject_HEAD
    Pystd__vector__lt___std__string___gt__ *container;
    std::vector< std::string >::iterator *iterator;
} Pystd__vector__lt___std__string___gt__Iter;


extern PyTypeObject Pystd__vector__lt___std__string___gt___Type;
extern PyTypeObject Pystd__vector__lt___std__string___gt__Iter_Type;

int _wrap_convert_py2c__std__vector__lt___std__string___gt__(PyObject *arg, std::vector< std::string > *container);

typedef struct {
    PyObject_HEAD
    SimpleStructList *obj;
} PySimpleStructList;


typedef struct {
    PyObject_HEAD
    PySimpleStructList *container;
    SimpleStructList::iterator *iterator;
} PySimpleStructListIter;


extern PyTypeObject PySimpleStructList_Type;
extern PyTypeObject PySimpleStructListIter_Type;

int _wrap_convert_py2c__SimpleStructList(PyObject *arg, SimpleStructList *container);

typedef struct {
    PyObject_HEAD
    std::vector< simple_struct_t > *obj;
} Pystd__vector__lt___simple_struct_t___gt__;


typedef struct {
    PyObject_HEAD
    Pystd__vector__lt___simple_struct_t___gt__ *container;
    std::vector< simple_struct_t >::iterator *iterator;
} Pystd__vector__lt___simple_struct_t___gt__Iter;


extern PyTypeObject Pystd__vector__lt___simple_struct_t___gt___Type;
extern PyTypeObject Pystd__vector__lt___simple_struct_t___gt__Iter_Type;

int _wrap_convert_py2c__std__vector__lt___simple_struct_t___gt__(PyObject *arg, std::vector< simple_struct_t > *container);

typedef struct {
    PyObject_HEAD
    SimpleStructVec *obj;
} PySimpleStructVec;


typedef struct {
    PyObject_HEAD
    PySimpleStructVec *container;
    SimpleStructVec::iterator *iterator;
} PySimpleStructVecIter;


extern PyTypeObject PySimpleStructVec_Type;
extern PyTypeObject PySimpleStructVecIter_Type;

int _wrap_convert_py2c__SimpleStructVec(PyObject *arg, SimpleStructVec *container);

typedef struct {
    PyObject_HEAD
    SimpleStructMap *obj;
} PySimpleStructMap;


typedef struct {
    PyObject_HEAD
    PySimpleStructMap *container;
    SimpleStructMap::iterator *iterator;
} PySimpleStructMapIter;


extern PyTypeObject PySimpleStructMap_Type;
extern PyTypeObject PySimpleStructMapIter_Type;

int _wrap_convert_py2c__SimpleStructMap(PyObject *arg, SimpleStructMap *container);

typedef struct {
    PyObject_HEAD
    std::map< std::string, int > *obj;
} Pystd__map__lt___std__string__int___gt__;


typedef struct {
    PyObject_HEAD
    Pystd__map__lt___std__string__int___gt__ *container;
    std::map< std::string, int >::iterator *iterator;
} Pystd__map__lt___std__string__int___gt__Iter;


extern PyTypeObject Pystd__map__lt___std__string__int___gt___Type;
extern PyTypeObject Pystd__map__lt___std__string__int___gt__Iter_Type;

int _wrap_convert_py2c__std__map__lt___std__string__int___gt__(PyObject *arg, std::map< std::string, int > *container);

typedef struct {
    PyObject_HEAD
    std::set< unsigned int > *obj;
} Pystd__set__lt___unsigned_int___gt__;


typedef struct {
    PyObject_HEAD
    Pystd__set__lt___unsigned_int___gt__ *container;
    std::set< unsigned int >::iterator *iterator;
} Pystd__set__lt___unsigned_int___gt__Iter;


extern PyTypeObject Pystd__set__lt___unsigned_int___gt___Type;
extern PyTypeObject Pystd__set__lt___unsigned_int___gt__Iter_Type;

int _wrap_convert_py2c__std__set__lt___unsigned_int___gt__(PyObject *arg, std::set< unsigned int > *container);

typedef struct {
    PyObject_HEAD
    std::set< float > *obj;
} Pystd__set__lt___float___gt__;


typedef struct {
    PyObject_HEAD
    Pystd__set__lt___float___gt__ *container;
    std::set< float >::iterator *iterator;
} Pystd__set__lt___float___gt__Iter;


extern PyTypeObject Pystd__set__lt___float___gt___Type;
extern PyTypeObject Pystd__set__lt___float___gt__Iter_Type;

int _wrap_convert_py2c__std__set__lt___float___gt__(PyObject *arg, std::set< float > *container);

extern PyTypeObject *Pystd__exception_Type;


extern PyTypeObject *PyError_Type;


extern PyTypeObject *PyDomainError_Type;

/* --- forward declarations --- */


typedef struct {
    PyObject_HEAD
    TopNs::OuterBase *obj;
    PyBindGenWrapperFlags flags:8;
} PyTopNsOuterBase;


extern PyTypeObject PyTopNsOuterBase_Type;

extern std::map<void*, PyObject*> PyTopNsOuterBase_wrapper_registry;
/* --- forward declarations --- */


typedef struct {
    PyObject_HEAD
    TopNs::PrefixBottomNs::PrefixInner *obj;
    PyBindGenWrapperFlags flags:8;
} PyTopNsPrefixBottomNsPrefixInner;


extern PyTypeObject PyTopNsPrefixBottomNsPrefixInner_Type;

/* --- forward declarations --- */


typedef struct {
    PyObject_HEAD
    xpto::SomeClass *obj;
    PyBindGenWrapperFlags flags:8;
} PyXptoSomeClass;


extern PyTypeObject PyXptoSomeClass_Type;

extern std::map<void*, PyObject*> PyXptoSomeClass_wrapper_registry;

PyObject* _wrap_convert_c2py__Tupl(Tupl *cvalue);


int _wrap_convert_py2c__Tupl(PyObject *value, Tupl *address);


int _wrap_convert_py2c__Tupl_const___amp__(PyObject *value, Tupl *address);


int _wrap_convert_py2c__int(PyObject *value, int *address);


int _wrap_convert_py2c__VectorLike(PyObject *value, VectorLike *address);


int _wrap_convert_py2c__std__string(PyObject *value, std::string *address);


int _wrap_convert_py2c__simple_struct_t(PyObject *value, simple_struct_t *address);


int _wrap_convert_py2c__unsigned_int(PyObject *value, unsigned int *address);


int _wrap_convert_py2c__float(PyObject *value, float *address);

