androguard/core/analysis/analysis.py
def find_methods(self, classname=".*", methodname=".*", descriptor=".*",
            accessflags=".*", no_external=False):
        """
        Find a method by name using regular expression.
        This method will return all MethodClassAnalysis objects, which match the
        classname, methodname, descriptor and accessflags of the method.

        :param classname: regular expression for the classname
        :param methodname: regular expression for the method name
        :param descriptor: regular expression for the descriptor
        :param accessflags: regular expression for the accessflags
        :param no_external: Remove external method from the output (default False)
        :rtype: Iterator[MethodClassAnalysis]
        """
        classname = bytes(mutf8.MUTF8String.from_str(classname))
        methodname = bytes(mutf8.MUTF8String.from_str(methodname))
        descriptor = bytes(mutf8.MUTF8String.from_str(descriptor))
        for cname, c in self.classes.items():
            if re.match(classname, cname):
                for m in c.get_methods():
                    z = m.get_method()
                    # TODO is it even possible that an internal class has
                    # external methods? Maybe we should check for ExternalClass
                    # instead...
                    if no_external and isinstance(z, ExternalMethod):
                        continue
                    if re.match(methodname, z.get_name()) and \
                       re.match(descriptor, z.get_descriptor()) and \
                       re.match(accessflags, z.get_access_flags_string()):
                        yield m

        Find a method by name using regular expression.
        This method will return all MethodClassAnalysis objects, which match the
        classname, methodname, descriptor and accessflags of the method.

        :param classname: regular expression for the classname
        :param methodname: regular expression for the method name
        :param descriptor: regular expression for the descriptor
        :param accessflags: regular expression for the accessflags
        :param no_external: Remove external method from the output (default False)
        :rtype: Iterator[MethodClassAnalysis]
        
Find a method by name using regular expression.
This method will return all MethodClassAnalysis objects, which match the
classname, methodname, descriptor and accessflags of the method.
Find a method by name using regular expression . This method will return all MethodClassAnalysis objects which match the classname methodname descriptor and accessflags of the method .
def find_methods(self, classname=".*", methodname=".*", descriptor=".*",
            accessflags=".*", no_external=False):
        classname = bytes(mutf8.MUTF8String.from_str(classname))
        methodname = bytes(mutf8.MUTF8String.from_str(methodname))
        descriptor = bytes(mutf8.MUTF8String.from_str(descriptor))
        for cname, c in self.classes.items():
            if re.match(classname, cname):
                for m in c.get_methods():
                    z = m.get_method()
                    if no_external and isinstance(z, ExternalMethod):
                        continue
                    if re.match(methodname, z.get_name()) and \
                       re.match(descriptor, z.get_descriptor()) and \
                       re.match(accessflags, z.get_access_flags_string()):
                        yield m
def find_methods ( self , classname = ".*" , methodname = ".*" , descriptor = ".*" , accessflags = ".*" , no_external = False ) : classname = bytes ( mutf8 . MUTF8String . from_str ( classname ) ) methodname = bytes ( mutf8 . MUTF8String . from_str ( methodname ) ) descriptor = bytes ( mutf8 . MUTF8String . from_str ( descriptor ) ) for cname , c in self . classes . items ( ) : if re . match ( classname , cname ) : for m in c . get_methods ( ) : z = m . get_method ( ) if no_external and isinstance ( z , ExternalMethod ) : continue if re . match ( methodname , z . get_name ( ) ) and re . match ( descriptor , z . get_descriptor ( ) ) and re . match ( accessflags , z . get_access_flags_string ( ) ) : yield m
Find a method by name using regular expression.
Find a method by name using regular expression .
"""
        Find a method by name using regular expression.
        This method will return all MethodClassAnalysis objects, which match the
        classname, methodname, descriptor and accessflags of the method.

        :param classname: regular expression for the classname
        :param methodname: regular expression for the method name
        :param descriptor: regular expression for the descriptor
        :param accessflags: regular expression for the accessflags
        :param no_external: Remove external method from the output (default False)
        :rtype: Iterator[MethodClassAnalysis]
        """ # TODO is it even possible that an internal class has # external methods? Maybe we should check for ExternalClass # instead...
None
Iterator[MethodClassAnalysis]
self
classname
regular expression for the classname
regular expression for the classname
methodname
regular expression for the method name
regular expression for the method name
descriptor
regular expression for the descriptor
regular expression for the descriptor
accessflags
regular expression for the accessflags
regular expression for the accessflags
no_external
Remove external method from the output (default False)
Remove external method from the output ( default False )