def AutoExclude( mb ): """ Automaticaly exclude a range of things that don't convert well from C++ to Python """ global_ns = mb.global_ns for ns in NAMESPACES: main_ns = global_ns.namespace( ns ) # vars that are static consts but have their values set in the header file are bad Remove_Static_Consts ( main_ns ) ## Exclude protected and private that are not pure virtual query = declarations.access_type_matcher_t( 'private' ) \ & ~declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.PURE_VIRTUAL ) try: non_public_non_pure_virtual = main_ns.calldefs( query ) non_public_non_pure_virtual.exclude() except: pass #Virtual functions that return reference could not be overriden from Python query = declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.VIRTUAL ) \ & declarations.custom_matcher_t( lambda decl: declarations.is_reference( decl.return_type ) ) try: main_ns.calldefs( query ).virtuality = declarations.VIRTUALITY_TYPES.NOT_VIRTUAL except: pass
def excludeAllPrivate(cls): cls.decls(declarations.matchers.access_type_matcher_t("private")).exclude() # include back pure virtual private functions query = declarations.matchers.access_type_matcher_t("private") \ & declarations.virtuality_type_matcher_t(declarations.VIRTUALITY_TYPES.PURE_VIRTUAL) cls.mem_funs(query, allow_empty = True).include()
def filter_declarations( mb ): global_ns = mb.global_ns global_ns.exclude() ogrerefapp_ns = global_ns.namespace( 'OgreRefApp' ) ogrerefapp_ns.include() ## Exclude protected and private that are not pure virtual query = ~declarations.access_type_matcher_t( 'public' ) \ & ~declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.PURE_VIRTUAL ) non_public_non_pure_virtual = ogrerefapp_ns.calldefs( query ) non_public_non_pure_virtual.exclude()
def AutoExclude( mb ): """ Automaticaly exclude a range of things that don't convert well from C++ to Python """ global_ns = mb.global_ns main_ns = global_ns # No namespaces in NxPhysics #Virtual functions that return reference could not be overriden from Python query = declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.VIRTUAL ) \ & declarations.custom_matcher_t( lambda decl: declarations.is_reference( decl.return_type ) ) try: main_ns.calldefs( query ).virtuality = declarations.VIRTUALITY_TYPES.NOT_VIRTUAL except: pass
def filter_declarations( mb ): """ filter class declarations """ global_ns = mb.global_ns global_ns.exclude() #global_ns.namespace('std').class_('pair<float, float>').include() MyGUI_ns = global_ns.namespace( 'MyGUI' ) MyGUI_ns.include() global_ns.namespace( 'Ogre' ).class_('SharedPtr<Ogre::Resource>').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('HardwarePixelBufferSharedPtr').include(already_exposed=True) global_ns.namespace( 'OIS' ).class_('KeyEvent').include(already_exposed=True) global_ns.namespace( 'OIS' ).class_('MouseEvent').include(already_exposed=True) # Exclude protected and private that are not pure virtual query = declarations.access_type_matcher_t( 'private' ) \ & ~declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.PURE_VIRTUAL ) MyGUI_ns.calldefs( query, allow_empty=True ).exclude()
def redefined_funcs( self ): """ returns list of member functions that should be defined in the class wrapper It comes useful in 3 tier hierarchy: .. code-block:: c++ struct base{ virtual void do_nothing() = 0; }; struct derived{ virtual void do_something() = 0; }; struct concrete{ virtual void do_nothing(){} virtual void do_something(){} }; The wrapper for class `derived`, should define `do_nothing` function, otherwise the generated code will not compile """ if isinstance( self._redefined_funcs, list ): return self._redefined_funcs all_included = declarations.custom_matcher_t( lambda decl: decl.ignore == False and decl.exportable ) all_protected = declarations.access_type_matcher_t( 'protected' ) & all_included all_pure_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.PURE_VIRTUAL ) all_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.VIRTUAL ) \ & ( declarations.access_type_matcher_t( 'public' ) \ | declarations.access_type_matcher_t( 'protected' )) all_not_pure_virtual = ~all_pure_virtual query = all_protected | all_pure_virtual mf_query = query | all_virtual relevant_opers = declarations.custom_matcher_t( lambda decl: decl.symbol in ('()', '[]') ) funcs = [] defined_funcs = [] for base in self.recursive_bases: if base.access == ACCESS_TYPES.PRIVATE: continue base_cls = base.related_class funcs.extend( base_cls.member_functions( mf_query, recursive=False, allow_empty=True ) ) funcs.extend( base_cls.member_operators( relevant_opers & query, recursive=False, allow_empty=True ) ) defined_funcs.extend( base_cls.member_functions( all_not_pure_virtual, recursive=False, allow_empty=True ) ) defined_funcs.extend( base_cls.member_operators( all_not_pure_virtual & relevant_opers, recursive=False, allow_empty=True ) ) not_reimplemented_funcs = set() is_same_function = declarations.is_same_function for f in funcs: cls_fs = self.calldefs( name=f.name, recursive=False, allow_empty=True ) for cls_f in cls_fs: if is_same_function( f, cls_f ): break else: #should test whether this function has been added or not for f_impl in not_reimplemented_funcs: if is_same_function( f, f_impl ): if declarations.is_base_and_derived( f_impl.parent, f.parent ): #add function from the most derived class not_reimplemented_funcs.remove( f_impl ) not_reimplemented_funcs.add( f ) break else: #should test whether this function is implemented in base class if f.virtuality != VIRTUALITY_TYPES.PURE_VIRTUAL: not_reimplemented_funcs.add( f ) else: for f_defined in defined_funcs: if is_same_function( f, f_defined ): break else: not_reimplemented_funcs.add( f ) functions = [f for f in list( not_reimplemented_funcs ) if ( False == f.ignore and True == f.exportable ) or all_pure_virtual( f )] #Boost.Python is not able to call for non-virtual function, from the base #class if there is a virtual function with the same within base class #See override_bug tester for more information def buggy_bpl_filter( f ): if f.parent is self: return False if f.access_type != ACCESS_TYPES.PUBLIC: return False if f.virtuality != VIRTUALITY_TYPES.NOT_VIRTUAL: return False #we need to check that we don't have "same" function in this class this_funs = self.decls( name=f.name , decl_type=declarations.calldef_t , recursive=False , allow_empty=True ) for this_f in this_funs: if is_same_function( this_f, f ): #there is already the function in the class, so no need to redefined it return False else: return True tmp = {} # id : f for redefined_f in functions: #redefined is virtual, I am not interested in virtual functions for rfo in redefined_f.overloads: if id(rfo) in tmp: continue if buggy_bpl_filter( rfo ): tmp[ id(rfo) ] = rfo functions.extend( list(tmp.values()) ) functions.sort( key=lambda f: ( f.name, f.location.as_tuple() ) ) self._redefined_funcs = functions return self._redefined_funcs
def redefined_funcs( self ): """returns list of member functions that should be defined in class wrapper It comes useful in 3 tier hierarchy: struct base{ virtual void do_nothing() = 0; }; struct derived{ virtual void do_something() = 0; }; struct concrete{ virtual void do_nothing(){} virtual void do_something(){} }; derived_wrapper should define do_nothing function, otherwise the generated code will not compile """ if isinstance( self._redefined_funcs, list ): return self._redefined_funcs all_included = declarations.custom_matcher_t( lambda decl: decl.ignore == False and decl.exportable ) all_protected = declarations.access_type_matcher_t( 'protected' ) & all_included all_pure_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.PURE_VIRTUAL ) all_not_pure_virtual = ~all_pure_virtual query = all_protected | all_pure_virtual relevant_opers = declarations.custom_matcher_t( lambda decl: decl.symbol in ('()', '[]') ) funcs = set() defined_funcs = set() for base in self.recursive_bases: if base.access == ACCESS_TYPES.PRIVATE: continue base_cls = base.related_class funcs.update( base_cls.member_functions( query, recursive=False, allow_empty=True ) ) funcs.update( base_cls.member_operators( relevant_opers & query, recursive=False, allow_empty=True ) ) defined_funcs.update( base_cls.member_functions( all_not_pure_virtual, recursive=False, allow_empty=True ) ) defined_funcs.update( base_cls.member_operators( all_not_pure_virtual & relevant_opers, recursive=False, allow_empty=True ) ) not_reimplemented_funcs = set() is_same_function = declarations.is_same_function for f in funcs: cls_fs = self.calldefs( name=f.name, recursive=False, allow_empty=True ) for cls_f in cls_fs: if is_same_function( f, cls_f ): break else: #should test whether this function has been added or not for f_impl in not_reimplemented_funcs: if is_same_function( f, f_impl ): if declarations.is_base_and_derived( f_impl.parent, f.parent ): #add function from the most derived class not_reimplemented_funcs.remove( f_impl ) not_reimplemented_funcs.add( f ) break else: #should test whether this function is implemented in base class if f.virtuality != VIRTUALITY_TYPES.PURE_VIRTUAL: not_reimplemented_funcs.add( f ) else: for f_defined in defined_funcs: if is_same_function( f, f_defined ): break else: not_reimplemented_funcs.add( f ) functions = list( not_reimplemented_funcs ) functions.sort( cmp=lambda f1, f2: cmp( ( f1.name, f1.location.as_tuple() ) , ( f2.name, f2.location.as_tuple() ) ) ) self._redefined_funcs = functions return self._redefined_funcs
def filter_declarations(self, mb): mb.global_ns.exclude() mb.global_ns.namespace('pyplusplus', recursive=False).include() boost_ns = mb.global_ns.namespace('boost', recursive=False) boost_ns.namespace('posix_time', recursive=False).include() boost_ns.namespace('date_time', recursive=False).include() boost_ns.namespace('gregorian', recursive=False).include() boost_ns.namespace('local_time', recursive=False).include() boost_ns.classes( lambda decl: decl.name.startswith('constrained_value<')).include() ## Exclude protected and private that are not pure virtual query = ~declarations.access_type_matcher_t( 'public' ) \ & ~declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.PURE_VIRTUAL ) non_public_non_pure_virtual = boost_ns.calldefs(query) non_public_non_pure_virtual.exclude() for name in ['month_str_to_ushort', 'from_stream_type', 'parse_date']: boost_ns.calldefs( lambda decl: decl.name.startswith(name)).exclude() to_be_removed = [ 'c_time', 'duration_traits_long', 'duration_traits_adapted', 'posix_time_system_config' #TODO find out link bug , 'millisec_posix_time_system_config' ] boost_ns.classes(lambda decl: decl.name in to_be_removed).exclude() starts_with = [ 'time_resolution_traits<', 'counted_time_rep<', 'date_facet<', 'period_formatter<', 'date_generator_formatter<', 'special_values_formatter<' ] for name in starts_with: boost_ns.classes(lambda decl: decl.name.startswith(name)).exclude() ends_with = ['_impl', '_config'] for name in ends_with: boost_ns.classes(lambda decl: decl.name.endswith(name)).exclude() boost_ns.classes( lambda decl: decl.alias.endswith('formatter')).exclude() #boost.date_time has problem to create local_[micro]sec_clock #variable, it has nothing to do with Py++ empty_classes = ['local_microsec_clock', 'local_sec_clock'] for alias in empty_classes: class_ = boost_ns.class_(lambda decl: decl.alias == alias) class_.exclude() class_.ignore = False for alias in ['microsec_clock', 'second_clock']: class_ = boost_ns.class_(lambda decl: decl.alias == alias) class_.calldefs().create_with_signature = True tdi = mb.class_(lambda decl: decl.alias == 'time_duration_impl') tdi_init = tdi.constructor(arg_types=[None, None, None, None], recursive=False) tdi_init.ignore = True #next declarations are not exported, but Py++ writes warnings about them: boost_ns.operators('<<').exclude() boost_ns.operators('>>').exclude() boost_ns.operators('=').exclude() #next function uses non public class in its definition. microsec_clocks = boost_ns.classes( lambda decl: decl.name.startswith('microsec_clock<')) for mc in microsec_clocks: mc.member_functions('create_time').exclude() #TODO: add FT #next function takes reference to int. This function could not be called #from Python. Function transformation feature solves this problem tz_db_base = boost_ns.class_( lambda decl: decl.name.startswith('tz_db_base<')) tz_db_base.member_functions('split_rule_spec').exclude()
def redefined_funcs(self): """ returns list of member functions that should be defined in the class wrapper It comes useful in 3 tier hierarchy: .. code-block:: c++ struct base{ virtual void do_nothing() = 0; }; struct derived{ virtual void do_something() = 0; }; struct concrete{ virtual void do_nothing(){} virtual void do_something(){} }; The wrapper for class `derived`, should define `do_nothing` function, otherwise the generated code will not compile """ if isinstance(self._redefined_funcs, list): return self._redefined_funcs all_included = declarations.custom_matcher_t( lambda decl: decl.ignore == False and decl.exportable) all_protected = declarations.access_type_matcher_t( 'protected') & all_included all_pure_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.PURE_VIRTUAL) all_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.VIRTUAL ) \ & ( declarations.access_type_matcher_t( 'public' ) \ | declarations.access_type_matcher_t( 'protected' )) all_not_pure_virtual = ~all_pure_virtual query = all_protected | all_pure_virtual mf_query = query | all_virtual relevant_opers = declarations.custom_matcher_t( lambda decl: decl.symbol in ('()', '[]')) funcs = [] defined_funcs = [] for base in self.recursive_bases: if base.access == ACCESS_TYPES.PRIVATE: continue base_cls = base.related_class funcs.extend( base_cls.member_functions(mf_query, recursive=False, allow_empty=True)) funcs.extend( base_cls.member_operators(relevant_opers & query, recursive=False, allow_empty=True)) defined_funcs.extend( base_cls.member_functions(all_not_pure_virtual, recursive=False, allow_empty=True)) defined_funcs.extend( base_cls.member_operators(all_not_pure_virtual & relevant_opers, recursive=False, allow_empty=True)) not_reimplemented_funcs = set() is_same_function = declarations.is_same_function for f in funcs: cls_fs = self.calldefs(name=f.name, recursive=False, allow_empty=True) for cls_f in cls_fs: if is_same_function(f, cls_f): break else: #should test whether this function has been added or not for f_impl in not_reimplemented_funcs: if is_same_function(f, f_impl): if declarations.is_base_and_derived( f_impl.parent, f.parent): #add function from the most derived class not_reimplemented_funcs.remove(f_impl) not_reimplemented_funcs.add(f) break else: #should test whether this function is implemented in base class if f.virtuality != VIRTUALITY_TYPES.PURE_VIRTUAL: not_reimplemented_funcs.add(f) else: for f_defined in defined_funcs: if is_same_function(f, f_defined): break else: not_reimplemented_funcs.add(f) functions = filter( lambda f: (False == f.ignore and True == f.exportable) or all_pure_virtual(f), list(not_reimplemented_funcs)) #Boost.Python is not able to call for non-virtual function, from the base #class if there is a virtual function with the same within base class #See override_bug tester for more information def buggy_bpl_filter(f): if f.parent is self: return False if f.access_type != ACCESS_TYPES.PUBLIC: return False if f.virtuality != VIRTUALITY_TYPES.NOT_VIRTUAL: return False #we need to check that we don't have "same" function in this class this_funs = self.decls(name=f.name, decl_type=declarations.calldef_t, recursive=False, allow_empty=True) for this_f in this_funs: if is_same_function(this_f, f): #there is already the function in the class, so no need to redefined it return False else: return True tmp = {} # id : f for redefined_f in functions: #redefined is virtual, I am not interested in virtual functions for rfo in redefined_f.overloads: if id(rfo) in tmp: continue if buggy_bpl_filter(rfo): tmp[id(rfo)] = rfo functions.extend(tmp.values()) functions.sort(cmp=lambda f1, f2: cmp((f1.name, f1.location.as_tuple( )), (f2.name, f2.location.as_tuple()))) self._redefined_funcs = functions return self._redefined_funcs
def filter_declarations( mb ): global_ns = mb.global_ns global_ns.exclude() ogrenewt_ns = global_ns.namespace( 'BasicJoints' ) ogrenewt_ns.include() ogrenewt_ns = global_ns.namespace( 'PrebuiltCustomJoints' ) ogrenewt_ns.include() ogrenewt_ns = global_ns.namespace( 'CollisionPrimitives' ) ogrenewt_ns.include() temp_ns = global_ns.namespace( 'Converters' ) temp_ns.include() temp_ns = global_ns.namespace( 'CollisionTools' ) temp_ns.include() temp_ns = global_ns.namespace( 'MomentOfInertia' ) temp_ns.include() ogrenewt_ns = global_ns.namespace( 'OgreNewt' ) ogrenewt_ns.include() ## these need to be excluded due to callback functions - Have been wrapped ogrenewt_ns.class_( "World" ).member_functions("setLeaveWorldCallback").exclude() ogrenewt_ns.class_( "Body" ).member_functions("addBouyancyForce").exclude() ogrenewt_ns.class_( "Body" ).member_functions("setAutoactiveCallback").exclude() ogrenewt_ns.class_( "Body" ).member_functions("setCustomForceAndTorqueCallback").exclude() ogrenewt_ns.class_( "Body" ).member_functions("setCustomTransformCallback").exclude() ogrenewt_ns.class_( "BodyIterator" ).member_functions("go").exclude() global_ns.namespace( 'BasicJoints' ).class_( "Hinge" ).member_functions("setCallback").exclude() global_ns.namespace( 'BasicJoints' ).class_( "Slider" ).member_functions("setCallback").exclude() global_ns.namespace( 'BasicJoints' ).class_( "Universal" ).member_functions("setCallback").exclude() ## Replaced these with 'useful' functions in the handwrappers - take and return python objects ogrenewt_ns.class_( "Body" ).member_functions("setUserData").exclude() ogrenewt_ns.class_( "Joint" ).member_functions("setUserData").exclude() ogrenewt_ns.class_( "Body" ).member_functions("getUserData").exclude() ogrenewt_ns.class_( "Joint" ).member_functions("getUserData").exclude() ## This one needs a list of vertices given to it ogrenewt_ns.class_( "TreeCollision" ).member_functions("addPoly").exclude() # ConvexHull has an overloaded constructor that takes 5 args, one is a pointer to a list of vectors which we can't # handle, so we created a helper function caller createConvexHull that takes a python list instead. mb.global_ns.namespace ('OgreNewt').class_('ConvexHull').constructor(arg_types=[None,None,None,None,None]).exclude() ### and we need the free functions for func in ogrenewt_ns.free_functions (): ## print "FREE Func:", func.name func.include() ## Exclude protected and private that are not pure virtual query = declarations.access_type_matcher_t( 'private' ) \ & ~declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.PURE_VIRTUAL ) ogrenewt_ns.calldefs( query, allow_empty=True ).exclude() ## Some varibles that we really do need and aren't exposed by default.. cls = ogrenewt_ns.class_("ContactCallback") cls.variable('m_body0').include() cls.variable('m_body1').include() cls.variable('m_contact').include() cls.variable('m_material').include() global_ns.namespace( 'Ogre' ).class_('AxisAlignedBox').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('Radian').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('SceneNode').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('IndexData').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('SceneManager').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('Vector3').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('Matrix4').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('Degree').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('Quaternion').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('Node').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('Serializer').include(already_exposed=True)
def filter_declarations(self, mb): mb.global_ns.exclude() mb.global_ns.namespace("pyplusplus", recursive=False).include() boost_ns = mb.global_ns.namespace("boost", recursive=False) boost_ns.namespace("posix_time", recursive=False).include() boost_ns.namespace("date_time", recursive=False).include() boost_ns.namespace("gregorian", recursive=False).include() boost_ns.namespace("local_time", recursive=False).include() boost_ns.classes(lambda decl: decl.name.startswith("constrained_value<")).include() ## Exclude protected and private that are not pure virtual query = ~declarations.access_type_matcher_t("public") & ~declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.PURE_VIRTUAL ) non_public_non_pure_virtual = boost_ns.calldefs(query) non_public_non_pure_virtual.exclude() for name in ["month_str_to_ushort", "from_stream_type", "parse_date"]: boost_ns.calldefs(lambda decl: decl.name.startswith(name)).exclude() to_be_removed = [ "c_time", "duration_traits_long", "duration_traits_adapted", "posix_time_system_config", # TODO find out link bug "millisec_posix_time_system_config", ] boost_ns.classes(lambda decl: decl.name in to_be_removed).exclude() starts_with = [ "time_resolution_traits<", "counted_time_rep<", "date_facet<", "period_formatter<", "date_generator_formatter<", "special_values_formatter<", ] for name in starts_with: boost_ns.classes(lambda decl: decl.name.startswith(name)).exclude() ends_with = ["_impl", "_config"] for name in ends_with: boost_ns.classes(lambda decl: decl.name.endswith(name)).exclude() boost_ns.classes(lambda decl: decl.alias.endswith("formatter")).exclude() # boost.date_time has problem to create local_[micro]sec_clock # variable, it has nothing to do with Py++ empty_classes = ["local_microsec_clock", "local_sec_clock"] for alias in empty_classes: class_ = boost_ns.class_(lambda decl: decl.alias == alias) class_.exclude() class_.ignore = False for alias in ["microsec_clock", "second_clock"]: class_ = boost_ns.class_(lambda decl: decl.alias == alias) class_.calldefs().create_with_signature = True tdi = mb.class_(lambda decl: decl.alias == "time_duration_impl") tdi_init = tdi.constructor(arg_types=[None, None, None, None], recursive=False) tdi_init.ignore = True # next declarations are not exported, but Py++ writes warnings about them: boost_ns.operators("<<").exclude() boost_ns.operators(">>").exclude() boost_ns.operators("=").exclude() # next function uses non public class in its definition. microsec_clocks = boost_ns.classes(lambda decl: decl.name.startswith("microsec_clock<")) for mc in microsec_clocks: mc.member_functions("create_time").exclude() # TODO: add FT # next function takes reference to int. This function could not be called # from Python. Function transformation feature solves this problem tz_db_base = boost_ns.class_(lambda decl: decl.name.startswith("tz_db_base<")) tz_db_base.member_functions("split_rule_spec").exclude()
def filter_declarations( mb ): global_ns = mb.global_ns global_ns.exclude() ode_ns = global_ns ## Ode doesn't have it's own namespace.. .namespace( 'ode' ) for cls in ode_ns.classes(): # # print "Checking ", cls.decl_string try: if cls.decl_string[2]=='d' and cls.decl_string[3].isupper(): # # print "Including Class:", cls.name cls.include() except: pass ## and the dxXXclasses for cls in ode_ns.classes(): # # print "Checking ", cls.decl_string if cls.decl_string[2:4]=='dx' and cls.decl_string[4].isupper(): # # print "Including dxClass:", cls.name cls.include() ## and we'll need the free functions as well for funcs in ode_ns.free_functions (): # # print "FREE Func:", funcs.name if funcs.name[0]=='d' and funcs.name[1].isupper(): # # print "Including Function", funcs.name funcs.include() for var in ode_ns.variables (): # # print "Checking Variable:", var.name if len(var.name) > 2: if var.name[0]=='d' and var.name[1].isupper(): # # print "Including variable", var.name var.include() for var in ode_ns.typedefs (): # # print "Checking typedef:", var.name if len(var.name) > 2: if var.name[0]=='d' and var.name[1].isupper(): # # print "Including typedef", var.name var.include() # print "Member Func:", funcs.name # if funcs.name[0]=='d': # print "Including Member Function", funcs.name # funcs.include() ## these either don't exist in the source or have strange arguments ignore=( "dGeomGetBodyNext", "dGeomMoved", "dPrintMatrix", "dWorldGetAutoDisableAngularAverageThreshold", "dWorldGetAutoDisableLinearAverageThreshold", "dWorldSetAutoDisableAngularAverageThreshold", "dWorldSetAutoDisableLinearAverageThreshold" , "dJointAddPUTorque", "dGeomTriMeshGetTriangle" ) for cls in ignore: try: ode_ns.free_function(cls).exclude() except: pass # # # in hand wrappers to handle pyobjects... ode_ns.class_( "dGeom" ).member_functions( "getData").exclude() ode_ns.class_( "dGeom" ).member_functions( "setData").exclude() ode_ns.class_( "dBody" ).member_functions( "setData").exclude() ode_ns.class_( "dBody" ).member_functions( "getData").exclude() ode_ns.class_( "dSpace" ).member_functions( "collide").exclude() ode_ns.class_( "dFixedJoint" ).member_functions( "create").exclude() ## Exclude protected and private that are not pure virtual ### need to be careful here as it removes free functions query = ( declarations.access_type_matcher_t( 'private' ) | declarations.access_type_matcher_t( 'protected' ) )\ & ~declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.PURE_VIRTUAL ) non_public_non_pure_virtual = ode_ns.calldefs( query ) # # print "TO EXCLUDE:", non_public_non_pure_virtual non_public_non_pure_virtual.exclude() #For some reason Py++ does not honor call policies in this case. #You will have to expose them by hand dContactGeom = ode_ns.class_( 'dContactGeom' ) g12 = dContactGeom.variables( lambda d: d.name in ('g1', 'g2' ) ) g12.exclude() #g12.getter_call_policies = call_policies.return_value_policy( call_policies.return_opaque_pointer ) ode_ns.class_( 'dBox' ).noncopyable = True ode_ns.class_( 'dCapsule' ).noncopyable = True ode_ns.class_( 'dGeom' ).noncopyable = True ode_ns.class_( 'dGeomTransform' ).noncopyable = True ode_ns.class_( 'dPlane' ).noncopyable = True ode_ns.class_( 'dQuadTreeSpace' ).noncopyable = True ode_ns.class_( 'dRay' ).noncopyable = True ode_ns.class_( 'dSphere' ).noncopyable = True
def filter_declarations( mb ): global_ns = mb.global_ns global_ns.exclude() global_ns.namespace('std').class_('pair<float, float>').include() CEGUI_ns = global_ns.namespace( 'CEGUI' ) CEGUI_ns.include() ## not available at link time.. CEGUI_ns.free_functions("lbi_greater").exclude() CEGUI_ns.free_functions("lbi_less").exclude() ## Dumb fix to remove all Properties classes - unfortunately the properties in these classes are indicated as public ## however within their 'parent' class they are defined as private.. ## see MultiLineEditboxProperties ## for cls in mb.global_ns.namespace ('CEGUI').classes(): if "Properties" in cls.decl_string: print "Excluding:", cls.name cls.exclude() ## EventNamespace causes failure when loading the python module ## possibly because of the ugly Properties fix above :) for cls in mb.global_ns.namespace ('CEGUI').classes(): try: cls.variable('EventNamespace').exclude() except: pass ## turns out that in SOME classes this also fails registration (Combodroplist for example) for cls in mb.global_ns.namespace ('CEGUI').classes(): try: cls.variable('WidgetTypeName').exclude() except: pass ## fix due to new gccxml try: global_ns.member_function('::CEGUI::ListboxItem::setSelectionColours', arg_types=['__restrict__ ::CEGUI::colour &']).exclude() global_ns.member_function('::CEGUI::ListboxTextItem::setTextColours', arg_types=['__restrict__ ::CEGUI::colour &']).exclude() except: pass ## Exclude protected and private that are not pure virtual query = declarations.access_type_matcher_t( 'private' ) \ & ~declarations.virtuality_type_matcher_t( declarations.VIRTUALITY_TYPES.PURE_VIRTUAL ) CEGUI_ns.calldefs( query, allow_empty=True ).exclude() ## lets work around a bug in GCCXMl - http://language-binding.net/pygccxml/design.html#patchers draws = mb.member_functions( 'draw' ) # find all the draw functions for draw in draws: for arg in draw.arguments: if arg.default_value == '0ffffffff': arg.default_value = '0xffffffff' ## class to exclude excludes=['::CEGUI::FactoryModule', '::CEGUI::ScriptFunctor', '::CEGUI::CEGUIRQListener', '::CEGUI::RefCounted< CEGUI::FormattedRenderedString >' # not in the debug version ] for e in excludes: try: CEGUI_ns.class_( e ).exclude() except: print "FAILED to exclude:", e ## now have functions in String that return uint arrays a need to be wrapped sc = CEGUI_ns.class_( "String" ) sc.member_functions('data').exclude() sc.member_functions('ptr').exclude() ## and only remove the at functions that are not returning constants ## the const version returns by value which is good, the non const returns a reference which doesn't compile sc.member_function( 'at', lambda decl: decl.has_const == False ).exclude() ## CEGUI::WindowManager::loadWindowLayout can take a function pointer as an agrument whcih isn't supported yet ## so lets remove the versions that expose the pointer lo = CEGUI_ns.class_( 'WindowManager' ).member_function( 'loadWindowLayout', arg_types=[None, None, None, None, None] ) lo.arguments[3].type = lo.arguments[4].type #AJM Not sure how args work so setting the func pointer to a void pointer ## OgreCEGUIRenderer.h has an assumed namespace in one of the default agrs that we need to fix try: orRe = CEGUI_ns.constructor('OgreCEGUIRenderer', arg_types=[None, None, None, None] ) pos = orRe.arguments[1].default_value.index("RENDER_QUEUE_OVERLAY") tempstring = orRe.arguments[1].default_value[:pos]+"::Ogre::"+orRe.arguments[1].default_value[pos:] orRe.arguments[1].default_value = tempstring except: pass # try to force this one.. ## a string one that stops pydoc working against CEGUI CEGUI_ns.class_('ListHeader').variable('SegmentNameSuffix').exclude() #Exclude non default constructors of iterator classes. for cls in CEGUI_ns.classes(): if not declarations.templates.is_instantiation( cls.name ): continue name = declarations.templates.name( cls.name ) if not name.endswith( 'Iterator' ): continue #default constructor does not have arguments constructors = cls.constructors( lambda decl: bool( decl.arguments ) , allow_empty=True , recursive=False ) constructors.exclude() # ## I'm going to exclude all iterators as there is a problem with CEGUIIteratorBase.h for cls in CEGUI_ns.classes(): # # print "checking", cls.name if 'iterator' in cls.name.lower() : cls.exclude() print "Excluding Iterator", cls.name try: # this is in the newer version of cegui so I'm OK if it fails CEGUI_ns.class_('OgreCEGUIResourceProvider').exclude() # it's _ogrePrivate.. except: pass ## Replaced these with 'useful' functions in the handwrappers - take and return python objects CEGUI_ns.class_( "Window" ).member_functions("setUserData").exclude() CEGUI_ns.class_( "Window" ).member_functions("getUserData").exclude() # Py++ doesn't know that this should be noncopyable so we set it here nocopy=['EventSet','GlobalEventSet','MouseCursor','OgreCEGUIRenderer','CEGUIOgreRenderer', ] for c in nocopy: try: CEGUI_ns.class_(c).noncopyable = True except: pass for c in CEGUI_ns.classes(): if c.name.endswith ("Exception"): c.noncopyable=True # changes to latest py++ can gccxml etc June 15 2008 excludes = ['::CEGUI::ItemListBase::getSortCallback', '::CEGUI::OgreRenderer::createOgreImageCodec', '::CEGUI::RefCounted<CEGUI::FormattedRenderedString>::isValid'] for f in excludes: try: CEGUI_ns.member_function(f).exclude() except: print "Couldn't exclude :",f CEGUI_ns.class_('RawDataContainer').exclude() # has pointers that need to be handled -- hopefully not needed CEGUI_ns.member_function("::CEGUI::WindowManager::loadWindowLayout", arg_types=[None,None,None,None,None]).exclude() global_ns.namespace( 'Ogre' ).class_('SceneManager').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('RenderWindow').include(already_exposed=True) global_ns.namespace( 'Ogre' ).class_('TexturePtr').include(already_exposed=True) if environment.isLinux(): for c in CEGUI_ns.classes(): if c.name.endswith ('Exception') and c.name != 'Exception' : c.exclude() print "Excluded:", c e = ['::CEGUI::OgreRenderer::destroyOgreImageCodec', # '::CEGUI::FileIOException', ] for c in e: global_ns.member_functions(c).exclude() cls = CEGUI_ns.class_('::CEGUI::RefCounted< CEGUI::BoundSlot >') cls.operator('==').exclude() # not in debug build