Returns an instance of JOII.Reflection.Method of a method by the
given name.

@param  string name
@return JOII.Reflection.Method
187244
function(name) {
        var list = this.getMethods();
        for (var i in list) {
            if (list[i].getName() === name) {
                return list[i];
            }
        }
        throw 'Method "' + name + '" does not exist.';
    }
629901
protected function findMethod($name) {
    if ($method = $this->ownBody->getOwnMethod($name)) {
      return $method;
    }
    if (NULL !== $parentClass = $this->extends->getParentClass()) {
      if ($method = $this->extends->getParentClass()->getOwnMethod($name)) {
        return $method;
      }
    }
    foreach ($this->interfacesAll->getAllInterfaces(FALSE) as $interface) {
      $method = $interface->getOwnMethod($name);
      if (FALSE !== $method) {
        return $method;
      }
    }
    return NULL;
  }
626534
public static function getFunction(string $name)
    {
        return isset(self::$functions[$name]) ? self::$functions[$name] : null;
    }
1096677
public Method getMethod(String methodName) {
        return checkNotNull(methods().get(checkNotNull(methodName)), 
        		"The method %s is not exists of object %s", methodName, delegateClass().getName());
    }
453884
public function getJavaClass($name): Interfaces\JavaClass
    {
        if (!array_key_exists($name, $this->classMapCache)) {
            $this->classMapCache[$name] = new JavaClass($name);
        }

        return $this->classMapCache[$name];
    }
434974
public function getMethod($name) {
    $methods = $this
      ->getMethods()
      ->filter(function (InterfaceMethodNode $method) use ($name) {
        return $method->getName()->getText() === $name;
      });
    return $methods->isEmpty() ? NULL : $methods[0];
  }
685411
function getOwnMethod($name) {
    if (isset($this->methods[$name])) {
      return $this->methods[$name];
    }
    if ($this->methodsComplete) {
      return NULL;
    }
    if (array_key_exists($name, $this->methodsNotFound)) {
      return NULL;
    }
    $methodObj = $this->findOwnMethod($name);
    if (NULL === $methodObj) {
      $this->methodsNotFound[$name] = TRUE;
      return NULL;
    }
    $this->methods[$name] = $methodObj;
    return $methodObj;
  }
962266
public function load($name)
    {
        $helper = $this->getRegisteredHelper($name);

        $reflection = new \ReflectionClass($helper);
        $class = $reflection->newInstance($this->di);

        return $class;
    }
1081800
protected function findOwnMethod($name) {
    $method = $this->getMethod($name);
    if ($this->qcn === $method->getDeclaringClassName()) {
      return $method;
    }
    return NULL;
  }
376566
public List<MethodNode> getMethods(String name) {
        List<MethodNode> answer = new ArrayList<MethodNode>();
        ClassNode node = this;
        while (node != null) {
            answer.addAll(node.getDeclaredMethods(name));
            node = node.getSuperClass();
        }
        return answer;
    }
815981
public List<Method> getMethods( String name )
    {
        List<Method> methods = new ArrayList<Method>();
        
        for (Method method : target.getMethods())
        {
            if (compare( method.getName(), name )) methods.add(method);
        }
        return methods;
    }
497978
public function getAnnotation($name, $method = null, $default = false)
    {
        $value = $this->getClassAnnotation($name, $default);

        if ($method !== null) {
            $value = $this->getMethodAnnotation($method, $name, $value);
        }

        return $value;
    }
1238641
public function getMethod($name)
    {
        $methods = $this->getMethods();
        foreach ($methods as $method) {
            if ($method->getName() == $name) {
                return $method;
            }
        }

        return false;
    }
1111610
public function get(string $name)
    {
        if ($this->isSingleton($name)) {
            /*
             * Object is instantiated as
             * singleton already. Just fetch it.
             */
            return $this->singletonObjects[$name];
        } elseif ($this->isDefined($name)) {
            /*
             * Creates a new instance
             * using map information.
             */
            return $this->build($name);
        } elseif (class_exists($name)) {
            /*
             * Class exists but it is
             * not mapped yet.
             */
            $this->set(
                $name,
                method_exists($name, '__construct') ?
                    $this->generateArgumentsMap($name) : []
            );

            return $this->get($name);
        }

        throw new \Exception("Couldn't create '$name'");
    }
60414
public function getMethod($name)
    {
        if ($this->reflected->hasMethod($name))
            return $this->annotations['methods'][$name];

        return null;
    }
706035
protected function getMethod($name) 
    {
        if (isset(self::$_methods[$name])) {
            return $name;
        }

        if (isset(self::$_methods['str_'.$name])) {
            return 'str_'.$name;
        }
        
        $unspaced = str_replace('_', '', $name);
        
        if (isset(self::$_methods[$unspaced])) {
            return $unspaced;
        }
        
        if (isset(self::$_methods['str'.$unspaced])) {
            return 'str'.$unspaced;
        }
        
        $uncamel = strtolower(preg_replace("/([A-Z])/", "_$1", $name));

        if (isset(self::$_methods[$uncamel])) {
            return $uncamel;
        }

        if (isset(self::$_methods['str_'.$uncamel])) {
            return 'str_'.$uncamel;
        }
        
        $unspaced = str_replace('_', '', $uncamel);
        
        if (isset(self::$_methods[$unspaced])) {
            return $unspaced;
        }
        
        if (isset(self::$_methods['str'.$unspaced])) {
            return 'str'.$unspaced;
        }

        return $name;
    }
119639
private final Object getObject(String name)
   {
      Object result = m_map.get(name);
      return (result);
   }