Python declarations.full_name函数代码示例

    def test_name_based( self ):
        cls = self.global_ns.class_( name='class_for_nested_enums_t' )

        cls_demangled_name = cls.name
        self.failUnless( cls.cache.demangled_name == cls_demangled_name )

        cls_full_name = declarations.full_name( cls )
        self.failUnless( cls.cache.full_name == cls_full_name )

        cls_declaration_path = declarations.declaration_path( cls )
        self.failUnless( cls.cache.declaration_path == cls_declaration_path )

        enum = cls.enum( 'ENestedPublic' )

        enum_full_name = declarations.full_name( enum )
        self.failUnless( enum.cache.full_name == enum_full_name )

        enum_declaration_path = declarations.declaration_path( enum )
        self.failUnless( enum.cache.declaration_path == enum_declaration_path )

        #now we change class name, all internal decls cache should be cleared
        cls.name = "new_name"
        self.failUnless( not cls.cache.full_name )
        self.failUnless( not cls.cache.demangled_name )
        self.failUnless( not cls.cache.declaration_path )

        self.failUnless( not enum.cache.full_name )
        self.failUnless( not enum.cache.demangled_name )
        self.failUnless( not enum.cache.declaration_path )

    def __fix_constructor_call(self, func, arg):
        call_invocation = declarations.call_invocation
        dv = arg.default_value
        if not call_invocation.is_call_invocation(dv):
            return False
        base_type = declarations.base_type(arg.type)
        decl = base_type.declaration
        name, args = call_invocation.split(dv)
        if decl.name != name:
            # we have some alias to the class
            relevant_typedefs = [
                typedef for typedef in decl.aliases if typedef.name == name]
            if 1 == len(relevant_typedefs):
                f_q_name = self.__join_names(
                    declarations.full_name(
                        relevant_typedefs[0].parent),
                    name)
            else:  # in this case we can not say which typedef user uses:
                f_q_name = self.__join_names(
                    declarations.full_name(
                        decl.parent),
                    decl.name)
        else:
            f_q_name = self.__join_names(
                declarations.full_name(
                    decl.parent),
                name)

        return call_invocation.join(f_q_name, args)

 def __str__( self ):
     desc = []
     desc.append( 'fget=%s' % declarations.full_name( self.fget ) )
     if self.fset:
         desc.append( ', ' )
         desc.append( 'fset=%s' % declarations.full_name( self.fset ) )
     return 'property "%s"[%s]' % ( self.name, ''.join( desc ) )

    def test_name_based(self):
        cls = self.global_ns.class_(name='class_for_nested_enums_t')

        if "CastXML" in utils.xml_generator:
            self.assertRaises(Exception, lambda: cls.cache.demangled_name)
        elif "GCCXML" in utils.xml_generator:
            self.failUnless(cls.cache.demangled_name == cls.name)

        cls_full_name = declarations.full_name(cls)
        self.failUnless(cls.cache.full_name == cls_full_name)

        cls_declaration_path = declarations.declaration_path(cls)
        self.failUnless(cls.cache.declaration_path == cls_declaration_path)

        enum = cls.enum('ENestedPublic')

        enum_full_name = declarations.full_name(enum)
        self.failUnless(enum.cache.full_name == enum_full_name)

        enum_declaration_path = declarations.declaration_path(enum)
        self.failUnless(enum.cache.declaration_path == enum_declaration_path)

        # now we change class name, all internal decls cache should be cleared
        cls.name = "new_name"
        self.failUnless(not cls.cache.full_name)
        if "GCCXML" in utils.xml_generator:
            self.failUnless(not cls.cache.demangled_name)
        self.failUnless(not cls.cache.declaration_path)

        self.failUnless(not enum.cache.full_name)
        if "GCCXML" in utils.xml_generator:
            self.failUnless(not enum.cache.demangled_name)
        self.failUnless(not enum.cache.declaration_path)

    def test(self):
        module_builder.set_logger_level( logging.CRITICAL )
        messages.disable( *messages.all_warning_msgs )

        ogre_file = autoconfig.data_directory.replace( 'pyplusplus_dev', 'pygccxml_dev' )
        ogre_file = parser.create_gccxml_fc( os.path.join( ogre_file, 'ogre.1.7.xml' ) )

        mb = module_builder.module_builder_t(
                [ ogre_file ]
                , gccxml_path=autoconfig.gccxml.executable
                , indexing_suite_version=2
                , compiler=pygccxml.utils.native_compiler.get_gccxml_compiler())

        mb.global_ns.exclude()
        mb.namespace('Ogre').include()

        x = mb.global_ns.decls( lambda d: 'Animation*' in d.name and 'MapIterator' in d.name )
        for y in x:
            print y.name
            print y.partial_name
            print declarations.full_name( y, with_defaults=False )

        target_dir = os.path.join( autoconfig.build_directory, 'ogre' )
        #~ if os.path.exists( target_dir ):
            #~ shutil.rmtree( target_dir )
        #~ os.mkdir( target_dir )

        mb.build_code_creator( 'Ogre3d' )
        mb.split_module( target_dir )

    def test_name_based(self):
        cls = self.global_ns.class_(name='class_for_nested_enums_t')

        if self.xml_generator_from_xml_file.is_castxml:
            self.assertIsNone(cls.cache.demangled_name)
        elif self.xml_generator_from_xml_file.is_gccxml:
            self.assertTrue(cls.cache.demangled_name == cls.name)

        cls_full_name = declarations.full_name(cls)
        self.assertTrue(cls.cache.full_name == cls_full_name)

        cls_declaration_path = declarations.declaration_path(cls)
        self.assertTrue(cls.cache.declaration_path == cls_declaration_path)

        enum = cls.enumeration('ENestedPublic')

        enum_full_name = declarations.full_name(enum)
        self.assertTrue(enum.cache.full_name == enum_full_name)

        enum_declaration_path = declarations.declaration_path(enum)
        self.assertTrue(enum.cache.declaration_path == enum_declaration_path)

        # now we change class name, all internal decls cache should be cleared
        cls.name = "new_name"
        self.assertTrue(not cls.cache.full_name)
        if self.xml_generator_from_xml_file.is_gccxml:
            self.assertTrue(not cls.cache.demangled_name)
        self.assertTrue(not cls.cache.declaration_path)

        self.assertTrue(not enum.cache.full_name)
        if self.xml_generator_from_xml_file.is_gccxml:
            self.assertTrue(not enum.cache.demangled_name)
        self.assertTrue(not enum.cache.declaration_path)

 def print_( extmodule ):
     creators = filter( missing_call_policies._selector
                        , code_creators.make_flatten_generator( extmodule.creators ) )
     for creator in creators:
         print creator.declaration.__class__.__name__, ': ', declarations.full_name( creator.declaration )
         print '  *** MISSING CALL POLICY', creator.declaration.function_type().decl_string
         print 

def _create_function_type_alias_code( self, exported_class_alias=None  ):
    f_type = self.declaration.function_type()
    falias = self.function_type_alias
    fname = declarations.full_name( self.declaration, with_defaults=False )
    fvalue = re.sub("_type$", "_value", falias )

    return "typedef %s;\n%s %s( &%s );" % (f_type.create_typedef( falias, with_defaults=False ),
                                           falias, fvalue, fname)

def _create_function_ref_code(self, use_function_alias=False):
    fname = declarations.full_name( self.declaration, with_defaults=False )
    if use_function_alias:
        falias = self.function_type_alias
        fvalue = re.sub("_type$", "_value", falias)
        return fvalue
    elif self.declaration.create_with_signature:
        return '(%s)( &%s )' % ( self.declaration.function_type().partial_decl_string, fname )
    else:
        return '&%s' % fname

    def _create_impl(self):
        if self.declaration.already_exposed:
            return ""

        answer = [self._create_namespaces_name()]
        answer.append(self.wrapper_type.decl_string)
        answer.append("".join([self.wrapper_creator_name, "(){"]))
        temp = "".join(
            ["return ", self.wrapper_type.decl_string, "( ", declarations.full_name(self.declaration), " );"]
        )
        answer.append(self.indent(temp))
        answer.append("}")
        answer.append("}" * len(self._create_namespaces()))
        return os.linesep.join(answer)

    def create_default(self):
        cntrl = self.controller.default_controller

        make_object = algorithm.create_identifier( self, 'pyplusplus::call_policies::make_object' )
        make_tuple = algorithm.create_identifier( self, 'boost::python::make_tuple' )
        
        tmpl_values = dict()

        tmpl_values['unique_function_name'] = self.default_name()
        tmpl_values['return_type'] = cntrl.wrapper_return_type.decl_string
        tmpl_values['arg_declarations'] = self.args_default_declaration()        
        tmpl_values['wrapper_class'] = self.parent.wrapper_alias
        tmpl_values['wrapped_class'] = declarations.full_name( self.declaration.parent )
        tmpl_values['wrapped_inst'] = cntrl.inst_arg.name
        tmpl_values['wrapped_inst_constness'] = ''
        if declarations.is_const( declarations.remove_reference( cntrl.inst_arg.type ) ):
            tmpl_values['wrapped_inst_constness'] = 'const'
            
        decl_vars = cntrl.variables[:]
        if not declarations.is_void( self.declaration.return_type ):
            decl_vars.append( cntrl.result_variable )
        tmpl_values['declare_variables'] \
            = os.linesep + os.linesep.join( map( lambda var: self.indent( var.declare_var_string() )
                                                 , decl_vars ) )
                
        tmpl_values['pre_call'] = os.linesep + self.indent( os.linesep.join( cntrl.pre_call ) )

        tmpl_values['save_result'] = ''
        if not declarations.is_void( self.declaration.return_type ):
            tmpl_tmp = '%(result_var_name)s = '
            if declarations.is_reference( self.declaration.return_type ):
                tmpl_tmp = tmpl_tmp + '&'
            tmpl_values['save_result'] = tmpl_tmp % dict( result_var_name=cntrl.result_variable.name )

        tmpl_values['function_name'] = self.declaration.name
        tmpl_values['arg_expressions'] = self.PARAM_SEPARATOR.join( cntrl.arg_expressions )
        return_stmt_creator = calldef_utils.return_stmt_creator_t( self
                                    , cntrl
                                    , cntrl.result_variable
                                    , cntrl.return_variables )

        tmpl_values['post_call'] = os.linesep + self.indent( os.linesep.join( cntrl.post_call ) )
        if return_stmt_creator.pre_return_code:
            tmpl_values['post_call'] \
                = os.linesep.join([ tmpl_values['post_call']
                                    , self.indent( return_stmt_creator.pre_return_code )])
        tmpl_values['return'] = os.linesep + self.indent( return_stmt_creator.statement )
            
        f_def = cntrl.template.substitute(tmpl_values)
        return remove_duplicate_linesep( f_def )

 def create_accessor_code( self, f, ftype_alias ):
     f_ref_code = '%s( &%s )' % ( ftype_alias, declarations.full_name( f ) )
     if f.call_policies and f.call_policies.is_default():
         return f_ref_code
     result = [ self.make_function_identifier ]
     result.append( '( ' )
     result.append( os.linesep )
     result.append( self.indent( '  ', 2 ) )
     result.append( f_ref_code )
     if f.call_policies:
         result.append( os.linesep )
         result.append( self.indent( ', ', 2 ) )
         result.append( f.call_policies.create( self ) )
     else:
         result.append( os.linesep )
         result.append( self.indent( '  ', 2 ) )
         result.append( '/* undefined call policies */' )
     result.append( ' ) ' )
     return ''.join( result )

    def _generate_code_with_scope(self):
        result = []
        scope_var_name = self.alias + '_scope'
        base_classes, base_creators = self._exported_base_classes()
        result.append( 'typedef ' + self._generate_class_definition(base_creators) + ' ' + self.typedef_name + ';')
        result.append( self.typedef_name + ' ' + self.class_var_name )
        result[-1] = result[-1] + ' = '
        class_constructor, used_init = self._generate_constructor()
        result[-1] = result[-1] + self.typedef_name + class_constructor
        result[-1] = result[-1] + ';'

        result.append( algorithm.create_identifier( self, '::boost::python::scope' ) )
        result[-1] = result[-1] + ' ' + scope_var_name
        result[-1] = result[-1] + '( %s );' % self.class_var_name

        creators = self.creators
        if self.declaration.redefine_operators:
            creators = self.creators + self._get_base_operators(base_classes, base_creators)

        for x in creators:
            if x is used_init:
                continue
            if isinstance( x, ( calldef.calldef_t, calldef.calldef_overloads_t ) ):
                x.works_on_instance = False
                code = x.create()
                if code:
                    result.append( code )
                continue
            if not x.works_on_instance:
                code = x.create()
                if code:
                    result.append( code )
            else:
                result.append( '%s.%s;' % ( self.class_var_name, x.create() ) )

        code = os.linesep.join( result )

        result = [ '{ //%s' % declarations.full_name( self.declaration, with_defaults=False ) ]
        result.append( self.indent( code ) )
        result.append( '}' )

        return os.linesep.join( result )

 def _create_impl(self):
     answer = []
     if self.declaration.type_qualifiers.has_static:
         substitutions = {
             'type' : self.declaration.type.decl_string
             , 'name' : self.declaration.name
             , 'cls_type' : declarations.full_name( self.declaration.parent )
         }
         answer.append( self.MV_STATIC_GET_TEMPLATE % substitutions)
         if self.has_setter:
             answer.append( self.MV_STATIC_SET_TEMPLATE % substitutions )
     else:
         answer.append( self.MV_GET_TEMPLATE % {
             'type' : self.declaration.type.decl_string
             , 'name' : self.declaration.name
             , 'cls_type' : self.inst_arg_type( has_const=True ) })
         if self.has_setter:
             answer.append( self.MV_SET_TEMPLATE % {
             'type' : self.declaration.type.decl_string
             , 'name' : self.declaration.name
             , 'cls_type' : self.inst_arg_type( has_const=False ) })
     return os.linesep.join( answer )

    def add_code(self, mb):
        mb.classes().add_properties(exclude_accessors=True)

        as_number_template = (
            'def( "as_number", &%(class_def)s::operator %(class_def)s::value_type, bp::default_call_policies() )'
        )

        classes = mb.classes()
        classes.always_expose_using_scope = True  # better error reporting from compiler

        classes = mb.classes(lambda decl: decl.alias != "local_date_time")
        classes.redefine_operators = True  # redefine all operators found in base classes

        classes = mb.classes(lambda decl: decl.name.startswith("constrained_value<"))
        for cls in classes:
            cls.add_code(as_number_template % {"class_def": declarations.full_name(cls)})

        classes = mb.classes(lambda decl: decl.alias in ["date_duration", "time_duration"])
        for operator in [">", ">=", "<=", "<", "+", "-"]:
            classes.add_code("def( bp::self %s  bp::self )" % operator)

        ptime = mb.class_(lambda decl: decl.alias == "ptime")
        for operator in [">", ">=", "<=", "<", "-"]:
            ptime.add_code("def( bp::self %s  bp::self )" % operator)