Python pybindgen.retval函数代码示例

def inject_ParameterFunctional(module, exceptions, interfaces, CONFIG_H):
    assert(isinstance(module, pybindgen.module.Module))
    assert(isinstance(exceptions, list))
    assert(isinstance(interfaces, dict))
    for element in interfaces:
        assert(isinstance(element, str))
        assert(len(element) > 0)
        assert(isinstance(CONFIG_H, dict))
    namespace = module.add_cpp_namespace('Dune').add_cpp_namespace('Pymor')
    ParameterFunctional = namespace.add_class('ParameterFunctional', parent=[interfaces['Dune::Pymor::Parametric']])
    ParameterFunctional.add_copy_constructor()
    ParameterFunctional.add_constructor([param('const Dune::Pymor::ParameterType&', 'tt'),
                                         param('const std::string', 'exp')],
                                         throw=exceptions)
    ParameterFunctional.add_method('expression', retval('const std::string'), [], is_const=True)
    ParameterFunctional.add_method('report', retval('std::string'), [], is_const=True)
    ParameterFunctional.add_method('report',
                                   retval('std::string'),
                                   [param('const std::string', 'name')],
                                   is_const=True)
    ParameterFunctional.add_method('evaluate',
                                   'double',
                                   [param('const Parameter&', 'mu')],
                                   throw=exceptions,
                                   is_const=True)
    ParameterFunctional.allow_subclassing = True
    return module, ParameterFunctional

def inject_Parametric(module, exceptions, CONFIG_H):
    assert(isinstance(module, pybindgen.module.Module))
    assert(isinstance(exceptions, list))
    assert(isinstance(CONFIG_H, dict))
    namespace = module.add_cpp_namespace('Dune').add_cpp_namespace('Pymor')
    Parametric = namespace.add_class('Parametric')

    ###################################################################

    # The following code leads to segfaults of the python interpreter.
    # Not excactly sure why, but probably not needed on the python side
    # anyway.

    # Parametric.add_constructor([])
    # Parametric.add_constructor([param('Dune::Pymor::ParameterType', 'tt')])
    # Parametric.add_constructor([param('std::string', 'kk'),
    #                             param(CONFIG_H['DUNE_STUFF_SSIZE_T'], 'vv')])
    # Parametric.add_constructor([param('std::vector< std::string >', 'kk'),
    #                             param('std::vector< ' + CONFIG_H['DUNE_STUFF_SSIZE_T'] + ' >', 'vv')])
    # Parametric.add_copy_constructor()

    ###################################################################

    Parametric.add_method('parameter_type',
                          retval('const Dune::Pymor::ParameterType&'),
                          [],
                          is_const=True)
    Parametric.add_method('parametric', retval('bool'), [], is_const=True)
    # Parametric.allow_subclassing = True
    return module, Parametric

 def add_gram_schmidt(la_backend, name):
     MatrixType = 'Dune::Stuff::LA::'
     VectorType = 'Dune::Stuff::LA::'
     if 'eigen_sparse' in la_backend:
         MatrixType += 'EigenRowMajorSparseMatrix'
         VectorType += 'EigenDenseVector'
     elif 'istl_sparse' in la_backend:
         MatrixType += 'IstlRowMajorSparseMatrix'
         VectorType += 'IstlDenseVector'
     MatrixType += '< ' + RangeFieldType + ' >'
     VectorType += '< ' + RangeFieldType + ' >'
     module.add_function('gram_schmidt',
                         retval('std::vector< ' + VectorType + ' >'),
                         [param('const std::vector< ' + VectorType + ' >&', 'A'),
                          param('const bool', 'reiterate'),
                          param('const bool', 'check')],
                         throw=exceptions,
                         template_parameters=[VectorType],
                         custom_name='gram_schmidt_' + name)
     module.add_function('gram_schmidt',
                         retval('std::vector< ' + VectorType + ' >'),
                         [param('const std::vector< ' + VectorType + ' >&', 'A'),
                          param('const ' + MatrixType + '&', 'product'),
                          param('const bool', 'reiterate'),
                          param('const bool', 'check')],
                         throw=exceptions,
                         template_parameters=[VectorType, MatrixType],
                         custom_name='gram_schmidt_' + name)

def module_gen(name):
    mod = Module('display')
    mod.add_include('"display.h"')
    display = mod.add_class('Display')
    display.add_constructor([param('int', 'height'),
                            param('int', 'width')])
    display.add_method('stop', None, [])
    display.add_method('getHeight', retval('int'), [])
    display.add_method('getWidth', retval('int'), [])
    display.add_method('getValue', retval('int'), 
                                  [param('int', 'row'),
                                   param('int', 'col')])
    display.add_method('setValue', None, [param('int', 'row'),
                                         param('int', 'col'),
                                         param('int', 'color')])
    display.add_method('drawRectangle', None, [param('int', 'x'),
                                            param('int', 'y'),
                                            param('int', 'width'),
                                            param('int', 'height'),
                                            param('int', 'color')])
    display.add_method('drawTriangle', None, [param('int', 'x'),
                                              param('int', 'y'),
                                              param('int', 'width'),
                                              param('int', 'height'),
                                              param('int', 'color')])
    display.add_method('clear', None, [])
    mod.add_function('loop', retval('int'), [param('Display *', 'disp', 
                                                  transfer_ownership=False)])
    mod.generate(name)

    def reg_NfdCs(root_module, cls):
        cls.add_method('size', retval('size_t'), [], is_const=True)
        cls.add_container_traits(retval('const ns3::ndn::nfd::cs::Entry&', caller_manages_return=False),
                                 begin_method='begin', end_method='end', iterator_type='const_iterator')

        def reg_Entry(cls):
            cls.add_method('getName', retval('const ns3::ndn::Name&'), [], is_const=True)
        reg_Entry(root_module['ns3::ndn::nfd::cs::Entry'])

 def reg_strategychoicehelper(cls):
     cls.add_method('Install', retval('void'), [param('ns3::Ptr<ns3::Node>', 'node'),
                                                param('const const std::string&', 'name'),
                                                param('const const std::string&', 'strategy')], is_const=True, is_static=True)
     cls.add_method('Install', retval('void'), [param('const ns3::NodeContainer&', 'c'),
                                                param('const const std::string&', 'name'),
                                                param('const const std::string&', 'strategy')], is_const=True, is_static=True)
     cls.add_method('InstallAll', retval('void'), [param('const std::string&', 'name'),
                                                   param('const std::string&', 'strategy')], is_const=True, is_static=True)

def add_functions(mod):
    mod.add_function('iks_make_session',
                     retval('iks*', caller_owns_return=True),
                     [], custom_name='make_session')

    mod.add_function('iks_make_pres',
                     retval('iks*', caller_owns_return=True),
                     [param('int', 'show'),
                      param('const char *', 'status')],
                     custom_name='make_pres')

def inject_VectorBasedImplementation(module, exceptions, interfaces, CONFIG_H, Traits, template_parameters=None):
    assert isinstance(module, pybindgen.module.Module)
    assert isinstance(exceptions, list)
    assert isinstance(interfaces, dict)
    for element in interfaces:
        assert isinstance(element, str)
        assert len(element) > 0
    assert isinstance(CONFIG_H, dict)
    assert isinstance(Traits, dict)
    for key in Traits.keys():
        assert isinstance(Traits[key], str)
        assert len(Traits[key].strip()) > 0
    assert "SourceType" in Traits
    SourceType = Traits["SourceType"]
    assert "ScalarType" in Traits
    ScalarType = Traits["ScalarType"]
    assert "ContainerType" in Traits
    ContainerType = Traits["ContainerType"]
    if template_parameters is not None:
        if isinstance(template_parameters, str):
            assert len(template_parameters.strip()) > 0
            template_parameters = [template_parameters]
        elif isinstance(template_parameters, list):
            for element in template_parameters:
                assert isinstance(element, str)
                assert len(element.strip()) > 0
    module = module.add_cpp_namespace("Dune").add_cpp_namespace("Pymor").add_cpp_namespace("Functionals")
    Class = module.add_class(
        "VectorBased",
        parent=[interfaces["Dune::Pymor::Tags::FunctionalInterface"], interfaces["Dune::Pymor::Parametric"]],
        template_parameters=template_parameters,
    )
    Class.add_method("type_this", retval("std::string"), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method("type_source", retval("std::string"), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method("type_scalar", retval("std::string"), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method("type_frozen", retval("std::string"), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method("linear", retval("bool"), [], is_const=True)
    Class.add_method("dim_source", retval(CONFIG_H["DUNE_STUFF_SSIZE_T"]), [], is_const=True)
    Class.add_method(
        "apply", retval(ScalarType), [param("const " + SourceType + " &", "source")], is_const=True, throw=exceptions
    )
    Class.add_method(
        "apply",
        retval(ScalarType),
        [param("const " + SourceType + " &", "source"), param("const Dune::Pymor::Parameter", "mu")],
        is_const=True,
        throw=exceptions,
    )
    Class.add_method(
        "as_vector_and_return_ptr",
        retval(ContainerType + " *", caller_owns_return=True),
        [],
        is_const=True,
        throw=exceptions,
        custom_name="as_vector",
    )
    return Class

def inject_Parameter(module, exceptions, CONFIG_H):
    assert(isinstance(module, pybindgen.module.Module))
    assert(isinstance(exceptions, list))
    assert(isinstance(CONFIG_H, dict))
    namespace = module.add_cpp_namespace('Dune').add_cpp_namespace('Pymor')
    Parameter = namespace.add_class('Parameter')
    Parameter.add_constructor([])
    Parameter.add_constructor([param('std::string', 'kk'),
                               param('double', 'vv')])
    Parameter.add_constructor([param('Dune::Pymor::ParameterType', 'tt'),
                               param('double', 'vv')],
                              throw=exceptions)
    Parameter.add_constructor([param('std::string', 'kk'),
                               param('std::vector< double >', 'vv')],
                              throw=exceptions)
    Parameter.add_constructor([param('Dune::Pymor::ParameterType', 'tt'),
                               param('std::vector< double >', 'vv')],
                              throw=exceptions)
    Parameter.add_constructor([param('std::vector< std::string >', 'kk'),
                               param('std::vector< std::vector< double > >', 'vv')],
                              throw=exceptions)
    Parameter.add_constructor([param('Dune::Pymor::ParameterType', 'tt'),
                               param('std::vector< std::vector< double > >', 'vv')],
                              throw=exceptions)
    Parameter.add_method('type', retval('Dune::Pymor::ParameterType'), [], is_const=True)
    Parameter.add_method('empty', retval('bool'), [], is_const=True)
    Parameter.add_method('keys',
                         retval('std::vector< std::string >'),
                         [],
                         is_const=True)
    Parameter.add_method('values',
                         retval('std::vector< std::vector< double > >'),
                         [],
                         is_const=True)
    Parameter.add_method('hasKey',
                         retval('bool'),
                         [param('std::string', 'key')],
                         is_const=True)
    Parameter.add_method('set',
                         None,
                         [param('std::string', 'key'),
                          param('std::vector< double >', 'value')],
                         throw=exceptions)
    Parameter.add_method('get',
                         retval('std::vector< double >'),
                         [param('std::string', 'key')],
                         is_const=True,
                         throw=exceptions)
    Parameter.add_binary_comparison_operator('==')
    Parameter.add_binary_comparison_operator('!=')
    Parameter.add_method('size', retval(CONFIG_H['DUNE_STUFF_SSIZE_T']), [], is_const=True)
    Parameter.add_method('report', retval('std::string'), [], is_const=True)
    Parameter.add_method('report_for_filename', retval('std::string'), [], is_const=True)
    Parameter.allow_subclassing = True
    return module, Parameter

def inject_VectorBasedImplementation(module, exceptions, interfaces, CONFIG_H, Traits, template_parameters=None):
    assert(isinstance(module, pybindgen.module.Module))
    assert(isinstance(exceptions, list))
    assert(isinstance(interfaces, dict))
    for element in interfaces:
        assert(isinstance(element, str))
        assert(len(element) > 0)
    assert(isinstance(CONFIG_H, dict))
    assert(isinstance(Traits, dict))
    for key in Traits.keys():
        assert(isinstance(Traits[key], str))
        assert(len(Traits[key].strip()) > 0)
    assert('SourceType' in Traits)
    SourceType = Traits['SourceType']
    assert('ScalarType' in Traits)
    ScalarType = Traits['ScalarType']
    assert('ContainerType' in Traits)
    ContainerType = Traits['ContainerType']
    if template_parameters is not None:
        if isinstance(template_parameters, str):
            assert(len(template_parameters.strip()) > 0)
            template_parameters = [ template_parameters ]
        elif isinstance(template_parameters, list):
            for element in template_parameters:
                assert(isinstance(element, str))
                assert(len(element.strip()) > 0)
    module = module.add_cpp_namespace('Dune').add_cpp_namespace('Pymor').add_cpp_namespace('Functionals')
    Class = module.add_class('VectorBased',
                             parent=[interfaces['Dune::Pymor::Tags::FunctionalInterface'],
                                     interfaces['Dune::Pymor::Parametric']],
                             template_parameters=template_parameters)
    Class.add_method('type_this', retval('std::string'), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method('type_source', retval('std::string'), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method('type_scalar', retval('std::string'), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method('type_frozen', retval('std::string'), [], is_const=True, is_static=True, throw=exceptions)
    Class.add_method('linear', retval('bool'), [], is_const=True)
    Class.add_method('dim_source', retval(CONFIG_H['DUNE_STUFF_SSIZE_T']), [], is_const=True)
    Class.add_method('apply',
                     retval(ScalarType),
                     [param('const ' + SourceType + ' &', 'source')],
                     is_const=True,
                     throw=exceptions)
    Class.add_method('apply',
                     retval(ScalarType),
                     [param('const ' + SourceType + ' &', 'source'),
                      param('const Dune::Pymor::Parameter', 'mu')],
                     is_const=True,
                     throw=exceptions)
    Class.add_method('as_vector_and_return_ptr',
                     retval(ContainerType + ' *', caller_owns_return=True),
                     [],
                     is_const=True,
                     throw=exceptions,
                     custom_name='as_vector')
    return Class

    def reg_Name(root_module, cls):
        cls.add_output_stream_operator()
        for op in ['==', '!=', '<', '<=', '>', '>=']:
            cls.add_binary_comparison_operator(op)
        cls.add_container_traits(retval('const ns3::ndn::name::Component&'),
                                 begin_method='begin', end_method='end', iterator_type='const_iterator')

        cls.add_constructor([])
        cls.add_constructor([param('const ns3::ndn::Name&', 'other')])
        cls.add_constructor([param('const std::string&', 'url')])
        cls.add_method('append', 'ns3::ndn::Name &', [param('const ns3::ndn::name::Component&', 'comp')])
        cls.add_method('get', 'const ns3::ndn::name::Component&', [param('int', 'index')], is_const=True)
        cls.add_method('getPrefix', 'ns3::ndn::Name', [param('size_t', 'len')], is_const=True)
        cls.add_method('size', 'size_t', [], is_const=True)
        cls.add_method('toUri', retval('std::string'), [], is_const=True)

def register_Ns3GlobalRouter_methods(root_module, cls):
    ## global-router-interface.h: static ns3::TypeId ns3::GlobalRouter::GetTypeId() [member function]
    cls.add_method("GetTypeId", "ns3::TypeId", [], is_static=True)
    ## global-router-interface.h: ns3::GlobalRouter::GlobalRouter() [constructor]
    cls.add_constructor([])
    ## global-router-interface.h: void ns3::GlobalRouter::SetRoutingProtocol(ns3::Ptr<ns3::Ipv4GlobalRouting> routing) [member function]
    cls.add_method("SetRoutingProtocol", "void", [param("ns3::Ptr< ns3::Ipv4GlobalRouting >", "routing")])
    ## global-router-interface.h: ns3::Ptr<ns3::Ipv4GlobalRouting> ns3::GlobalRouter::GetRoutingProtocol() [member function]
    cls.add_method("GetRoutingProtocol", "ns3::Ptr< ns3::Ipv4GlobalRouting >", [])
    ## global-router-interface.h: ns3::Ipv4Address ns3::GlobalRouter::GetRouterId() const [member function]
    cls.add_method("GetRouterId", "ns3::Ipv4Address", [], is_const=True)
    ## global-router-interface.h: uint32_t ns3::GlobalRouter::DiscoverLSAs() [member function]
    cls.add_method("DiscoverLSAs", "uint32_t", [])
    ## global-router-interface.h: uint32_t ns3::GlobalRouter::GetNumLSAs() const [member function]
    cls.add_method("GetNumLSAs", "uint32_t", [], is_const=True)
    ## global-router-interface.h: bool ns3::GlobalRouter::GetLSA(uint32_t n, ns3::GlobalRoutingLSA & lsa) const [member function]
    cls.add_method("GetLSA", "bool", [param("uint32_t", "n"), param("ns3::GlobalRoutingLSA &", "lsa")], is_const=True)
    ## global-router-interface.h: void ns3::GlobalRouter::InjectRoute(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask) [member function]
    cls.add_method("InjectRoute", "void", [param("ns3::Ipv4Address", "network"), param("ns3::Ipv4Mask", "networkMask")])
    ## global-router-interface.h: uint32_t ns3::GlobalRouter::GetNInjectedRoutes() [member function]
    cls.add_method("GetNInjectedRoutes", "uint32_t", [])
    ## global-router-interface.h: ns3::Ipv4RoutingTableEntry * ns3::GlobalRouter::GetInjectedRoute(uint32_t i) [member function]
    cls.add_method(
        "GetInjectedRoute", retval("ns3::Ipv4RoutingTableEntry *", caller_owns_return=False), [param("uint32_t", "i")]
    )
    ## global-router-interface.h: void ns3::GlobalRouter::RemoveInjectedRoute(uint32_t i) [member function]
    cls.add_method("RemoveInjectedRoute", "void", [param("uint32_t", "i")])
    ## global-router-interface.h: bool ns3::GlobalRouter::WithdrawRoute(ns3::Ipv4Address network, ns3::Ipv4Mask networkMask) [member function]
    cls.add_method(
        "WithdrawRoute", "bool", [param("ns3::Ipv4Address", "network"), param("ns3::Ipv4Mask", "networkMask")]
    )
    ## global-router-interface.h: void ns3::GlobalRouter::DoDispose() [member function]
    cls.add_method("DoDispose", "void", [], visibility="private", is_virtual=True)
    return

def register_Ns3Ipv4DceRoutingHelper_methods(root_module, cls):
    ## ipv4-dce-routing-helper.h: ns3::Ipv4DceRoutingHelper::Ipv4DceRoutingHelper() [constructor]
    cls.add_constructor([])
    ## ipv4-dce-routing-helper.h: ns3::Ipv4DceRoutingHelper::Ipv4DceRoutingHelper(ns3::Ipv4DceRoutingHelper const & arg0) [copy constructor]
    cls.add_constructor([param('ns3::Ipv4DceRoutingHelper const &', 'arg0')])
    ## ipv4-dce-routing-helper.h: ns3::Ipv4DceRoutingHelper * ns3::Ipv4DceRoutingHelper::Copy() const [member function]
    cls.add_method('Copy', 
                   retval('ns3::Ipv4DceRoutingHelper *', caller_owns_return=False),
                   [], 
                   is_const=True)
    ## ipv4-dce-routing-helper.h: ns3::Ptr<ns3::Ipv4RoutingProtocol> ns3::Ipv4DceRoutingHelper::Create(ns3::Ptr<ns3::Node> node) const [member function]
    cls.add_method('Create', 
                   retval('ns3::Ptr<ns3::Ipv4RoutingProtocol >', caller_owns_return=False),
                   [param('ns3::Node *', 'node', transfer_ownership=False)], 
                   is_const=True, is_virtual=True)
    return

def inject_Example(module, exceptions, interfaces, CONFIG_H):
    '''injects the user code into the module'''
    # first the discretization
    GridType = 'Dune::SGrid< 2, 2 >'
    GridLayerType = 'Dune::Stuff::Grid::ChooseLayer::leaf'
    RangeFieldType = 'double'
    dimRange = '1'
    polOrder = '1'
    SpaceBackendType = 'Dune::GDT::ChooseSpaceBackend::pdelab'
    LaBackendType = 'Dune::Stuff::LA::ChooseBackend::istl_sparse'
    if 'istl_sparse' in LaBackendType:
        MatrixType = 'Dune::Stuff::LA::IstlRowMajorSparseMatrix< ' + RangeFieldType + ' >'
        VectorType = 'Dune::Stuff::LA::IstlDenseVector< ' + RangeFieldType + ' >'
    elif 'eigen_sparse' in LaBackendType:
        MatrixType = 'Dune::Stuff::LA::EigenRowMajorSparseMatrix< ' + RangeFieldType + ' >'
        VectorType = 'Dune::Stuff::LA::EigenDenseVector< ' + RangeFieldType + ' >'
    DiscretizationName = 'Dune::HDD::LinearElliptic::Discretizations::CG'
    DiscretizationFullName = (DiscretizationName + '< '
                              + GridType + ', ' + GridLayerType + ', '
                              + RangeFieldType + ', ' + dimRange + ', ' + polOrder + ', '
                              + SpaceBackendType + ', '
                              + LaBackendType + ' >')
    discretization = inject_StationaryDiscretizationImplementation(
        module, exceptions, interfaces, CONFIG_H,
        DiscretizationName,
        Traits={'VectorType': VectorType,
                'OperatorType': 'Dune::Pymor::Operators::LinearAffinelyDecomposedContainerBased< ' + MatrixType + ', ' + VectorType + ' >',
                'FunctionalType': 'Dune::Pymor::Functionals::LinearAffinelyDecomposedVectorBased< ' + VectorType + ' >',
                'ProductType': 'Dune::Pymor::Operators::LinearAffinelyDecomposedContainerBased< ' + MatrixType + ', ' + VectorType + ' > '},
        template_parameters=[GridType, GridLayerType, RangeFieldType, dimRange, polOrder, SpaceBackendType, LaBackendType ])
    # then add the example
    LinearellipticExampleCG = module.add_class('LinearellipticExampleCG',
                                               template_parameters=['Dune::SGrid< 2, 2 >'],
                                               custom_name='LinearellipticExampleCG')
    LinearellipticExampleCG.add_method('static_id',
                                       retval('std::string'),
                                       [], is_const=True, throw=[exceptions['Exception']])
    LinearellipticExampleCG.add_method('write_config_file',
                                       None, [], is_const=True, throw=[exceptions['Exception']])
    LinearellipticExampleCG.add_constructor([], throw=[exceptions['Exception']])
    LinearellipticExampleCG.add_method('initialize', None,
                                       [param('const std::vector< std::string >', 'arguments')],
                                       is_const=True, throw=[exceptions['Exception']])
    LinearellipticExampleCG.add_method('discretization_and_return_ptr',
                                       retval(DiscretizationFullName + ' *', caller_owns_return=True),
                                       [], is_const=True, throw=[exceptions['Exception']],
                                       custom_name='discretization')

def my_module_gen(out_file):

    mod = Module('bar')

    mod.add_include ('"bar.h"')

    Foo = mod.add_class('Foo', automatic_type_narrowing=True,
                        memory_policy=BoostSharedPtr('::Foo'))

    Foo.add_static_attribute('instance_count', ReturnValue.new('int'))
    Foo.add_constructor([Parameter.new('std::string', 'datum')])
    Foo.add_constructor([])
    Foo.add_method('get_datum', ReturnValue.new('const std::string'), [])
    Foo.add_method('is_initialized', ReturnValue.new('bool'), [], is_const=True)
    Foo.add_output_stream_operator()


    mod.add_function('function_that_takes_foo', ReturnValue.new('void'),
                               [param('boost::shared_ptr<Foo>', 'foo')])
    mod.add_function('function_that_returns_foo', retval('boost::shared_ptr<Foo>'), [])
    
    cls = mod.add_class('ClassThatTakesFoo', allow_subclassing=True)
    cls.add_constructor([Parameter.new('boost::shared_ptr<Foo>', 'foo')])
    cls.add_method('get_foo', ReturnValue.new('boost::shared_ptr<Foo>'), [])
    cls.add_method('get_modified_foo', retval('boost::shared_ptr<Foo>'),
                   [param('boost::shared_ptr<Foo>', 'foo')],
                   is_virtual=True, is_const=True)


    
    #### --- error handler ---
    class MyErrorHandler(pybindgen.settings.ErrorHandler):
        def __init__(self):
            super(MyErrorHandler, self).__init__()
            self.num_errors = 0
        def handle_error(self, wrapper, exception, traceback_):
            print("exception %s in wrapper %s" % (exception, wrapper), file=sys.stderr)
            self.num_errors += 1
            if 0: # verbose?
                import traceback
                traceback.print_tb(traceback_)
            return True
    pybindgen.settings.error_handler = MyErrorHandler()

    ## ---- finally, generate the whole thing ----
    mod.generate(FileCodeSink(out_file))