Filters out all methods that don't match the property signatures

@param  ReflectionMethod[]  $methods  An array of methods to filter

@return  ReflectionMethod[]  The methods after filtering out non-properties
962140
private static function filterProperties(array $methods): array {
    return array_filter($methods, function(ReflectionMethod $method) {
      return
        (strlen($method->name) > 3) && (
          (strpos($method->name, 'get') === 0) ||
          (strpos($method->name, 'set') === 0) ||
          (strpos($method->name, 'itr') === 0)
        )
      ;
    });
  }
486707
protected function methods(array $methods = null)
    {
        return is_null($methods)
            ? $this->methods
            : ($this->methods = $methods);
    }
1151762
protected function inAllowedMethods($method)
    {
        $allowedMethods = collect(config('admin.operation_log.allowed_methods'))->filter();

        if ($allowedMethods->isEmpty()) {
            return true;
        }

        return $allowedMethods->map(function ($method) {
            return strtoupper($method);
        })->contains($method);
    }
889699
public function getMethods($filter = null)
    {
        if (!isset($this->methods)) {
            $directMethods = ReflectionMethod::collectFromClassNode($this->classLikeNode, $this);
            $parentMethods = $this->recursiveCollect(function (array &$result, \ReflectionClass $instance, $isParent) {
                $reflectionMethods = [];
                foreach ($instance->getMethods() as $reflectionMethod) {
                    if (!$isParent || !$reflectionMethod->isPrivate()) {
                        $reflectionMethods[$reflectionMethod->name] = $reflectionMethod;
                    }
                }
                $result += $reflectionMethods;
            });
            $methods = $directMethods + $parentMethods;

            $this->methods = $methods;
        }
        if (!isset($filter)) {
            return array_values($this->methods);
        }

        $methods = [];
        foreach ($this->methods as $method) {
            if (!($filter & $method->getModifiers())) {
                continue;
            }
            $methods[] = $method;
        }

        return $methods;
    }
1307241
public function methods( $methods ) {
		$methods = array_merge(
			$this->getAttribute( 'methods', [] ),
			$methods
		);

		return $this->attribute( 'methods', $methods );
	}
954971
public function getReflectionMethod(string $method)
    {
        if (!isset($this->reflectionMethod[$method])) {
            $this->reflectionMethod[$method] = new ReflectionMethod($this, $method);
        }

        return $this->reflectionMethod[$method];
    }
434859
private function getImportFilters($prefix = 'filter')
    {
        $filters = [];
        try {
            $methods = (new \ReflectionClass(static::class))->getMethods();
            foreach ($methods as $methodDetails) {
                $methodName = $methodDetails->name;
                if (stripos($methodName, $prefix) === 0) {
                    $filters[] = [$this, $methodName];
                }
            }

        } catch (\ReflectionException $ex) {

        }
        return $filters;
    }
826670
protected function filterNotSavedProperties(array $properties)
    {
        foreach ($this->getMetadata()->getAttributes() as $fieldKey => $propMeta) {
            if (true === $propMeta->shouldSave() || !isset($properties[$fieldKey])) {
                continue;
            }
            unset($properties[$fieldKey]);
        }
        return $properties;
    }
23025
public function except($method)
    {
        if (!is_array($method)) {
            $method = [ $method ];
        }

        $this->except += $method;

        return $this;
    }
658552
private function getMethodSignature($method)
    {
        $validMethod = isset($this->methods[$method])
            && is_array($this->methods[$method])
            && count($this->methods[$method]) >= 2;

        if ($validMethod) {
            return $this->methods[$method];
        }

        return null;
    }
177351
public function getMethods($filter = \ReflectionProperty::IS_PUBLIC)
    {
        $methods = array();
        $reflectionMethods = $this->reflectionEntity->getMethods($filter);
        foreach ($reflectionMethods as $method) {
            $methods[] = new Method($method->name, $method->isStatic());
        }

        return $methods;
    }
1137464
private function filterByMethod(array $methods, $alt)
    {
        $methods = array_flip(array_map('strtolower', $methods));

        foreach ($this->routes as $route) {
            if (isset($methods[$route->getAction()[1]]) === $alt) {
                $route->forget();
            }
        }
    }
743210
public function getMethodAnnotations($method)
    {
        if (!$this->hasMethod($method)) {
            $name = $this->_getReflection()->getName();
            throw new Exception\InvalidArgumentException(
                "The class {$name} doesn't have a property called {$method}"
            );
        }

        if (empty($this->_annotations['methods'][$method])) {
            $comment = $this->_getReflection()
                ->getMethod($method)
                ->getDocComment();
            $data = AnnotationParser::getAnnotations($comment);
            $methodAnnotations = new AnnotationsList();
            foreach ($data as $property => $parsedData) {
                $methodAnnotations->append(
                    $this->_createAnnotation($property, $parsedData)
                );
            }
            $this->_annotations['methods'][$method] = $methodAnnotations;
        }
        return $this->_annotations['methods'][$method];
    }
937613
private function matchSequentiallyForMethods(array $methods, string $path)
    {
        if ($result = $this->matchKeyValue($path, $methods)) {
            return $result;
        }

        foreach ($methods as $currentMethod) {
            foreach ($this->routes[$currentMethod] ?? [] as $handler => $handlerData) {
                foreach ($handlerData as list($patternRoute, $extraParams)) {
                    /** @var PatternRoute $patternRoute */
                    /** @var array $extraParams */
                    if ($patternRoute->match($path, $queryParams)) {
                        return new InternalRoute($handler, \array_replace($extraParams, $queryParams));
                    }
                }
            }
        }

        return null;
    }
460995
public function inflectionMethod($method = null)
    {
        if ($method !== null) {
            $this->setInflectionMethod($method);
        }

        return $this->getInflectionMethod();
    }
875775
public function matchesMethod(\ReflectionMethod $method, array $arguments): bool
    {
        $class = new \ReflectionClass($method->class);

        return $this->has($class, $arguments[0]);
    }
880724
protected function getAllMethods($statements)
    {
        $methods = [];
        foreach ($statements as $statement) {
            if (get_class($statement) == ClassMethod::class) {
                $methods[$statement->name] = $statement;
            }
            if (property_exists($statement, 'stmts')) {
                $result = $this->getAllMethods($statement->stmts);
                if (!empty($result)) {
                    $methods = array_merge($methods, $result);
                }
            }
        }

        return $methods;
    }