Get annotation value from method doc. block

@param string $method method name
@param string $name annotation name
@param mixed $default default value
@throws \ReflectionException
@return mixed
196246
public function getMethodAnnotation($method, $name, $default = false)
    {
        $value = $default;

        if (isset($this->methodAnnotations[$method]) === false) {
            $this->methodAnnotations[$method] = $this->parse((string)$this->getMethod($method)->getDocComment());
        }

        if (isset($this->methodAnnotations[$method][$name])) {
            $value = $this->methodAnnotations[$method][$name];
        }

        return $value;
    }
150245
public static function get($name = null, $default = false)
	{
		if(isset(self::$modifys[$name]))
		{
			return self::$modifys[$name];
		}
		else if(array_key_exists($name,self::$modifys))
		{
			return $default;
		}
		else
		{
			self::init();
			self::save();
			if(null === $name)
			{
				return $_SESSION;
			}
			$names = parseCfgName($name);
			$var = $_SESSION;
			foreach($names as $name)
			{
				if('@' === $name)
				{
					$name = self::$prefix;
				}
				if('' !== $name)
				{
					$var = $var[$name];
				}
			}
			return isset($var) ? $var : $default;
		}
	}
1349620
protected function getParameter($name, $default = null)
    {
        return array_key_exists($name, $this->params)?$this->params[$name]:$default;
    }
411010
public function getActionParam($name, $default = null)
    {
        $params = $this->getActionParams();
        return isset($params[$name]) ? $params[$name] : $default;
    }
505850
private function getParameterValue(array $parameter, $name, $default = null)
    {
        if (!array_key_exists($name, $parameter)) {
            return $default;
        }

        return $parameter[$name]->getValue();
    }
453774
public function getGet($name = null, $defaultValue = null) 
    {
        if ($name === null) {
            return $_GET;
        }
        return (isset($_GET[$name])) ? $_GET[$name] : $defaultValue;
    }
169142
static function getAnnotationParam($name, $param, $class, $method = NULL, $default = NULL)
	{
		$annotation = self::getAnnotation($name, $class, $method, TRUE);

		return NULL === $annotation || !isset($annotation->{$param})
			? $default
			: $annotation->{$param};
	}
1179916
public function get(string $name, $default = null)
    {
        return ($this->exists($name)) ? $this->map[$name] : $default;
    }
719482
public function getParameter($name, $default = NULL)
	{
		if (isset($this->params[$name])) {
			return $this->params[$name];

		} else {
			return $default;
		}
	}
962315
protected function processMethodParams(array $method, string $file, string $name)
    {
        if (!empty($method['docblock']['inheritdoc'])) {
            return;
        }

        foreach ($method['params'] as $param => $type) {
            if (is_array($type)) {
                $type = implode('|', $type);
            }

            if (!isset($method['docblock']['params'][$param])) {
                $this->warnings[] = [
                    'type' => 'param-missing',
                    'file' => $file,
                    'class' => $name,
                    'method' => $name,
                    'line' => $method['line'],
                    'param' => $param,
                ];

                return;
            }

            if (empty($type)) {
                return;
            }

            $paramType = $method['docblock']['params'][$param];
            if ($paramType !== $type) {
                if (!($type == 'array' && substr($paramType, -2) == '[]')) {
                    $this->warnings[] = [
                        'type' => 'param-mismatch',
                        'file' => $file,
                        'class' => $name,
                        'method' => $name,
                        'line' => $method['line'],
                        'param' => $param,
                        'param-type' => $type,
                        'doc-type' => $method['docblock']['params'][$param],
                    ];
                }
            }
        }
    }
1185851
function findProperty($name)
    {
        //Get the property from the method name
        $property = Reflection::getProperty($name);

        if ($this->start->matches($property))
        {
            return $this->start;
        }

        if ($this->end->matches($property))
        {
            return $this->end;
        }

        return parent::findProperty($name);
    }
718854
protected function objectBuild($name, $method)
    {
        if (!$this->hasInstance($name))
        {
            $this->instances[$name] = $this->init($method);
        }

        return $this->instances[$name];
    }
68865
public function getMethod($name)
    {
        $m = $this->getReflectionClass()->getMethod($name);
        return MethodInfo::__internal_create($this, $m);
    }
8875
static public function getCommon($name = null, $default=null)
    {
        $value = self::get($name, self::$range);
        return $value === null ? $default : $value;
    }
714867
public static function getString($name, $default = null)
    {
        if (isset($_GET[$name]) && $_GET[$name] !== '') return self::parseInputToString($_GET[$name]);
        return $default;
    }
93487
public function get($module, $name, $default)
    {
        $index = 0;

        if ($this->has($module, $name, $index)) {
            return $this->data[$index][ConstProviderInterface::CONFIG_PARAM_VALUE];
        } else {
            return $default;
        }
    }
703696
public function getParameter($name, $default = null)
    {
        try {
            return ArrayHelper::get($this->getParameters(), $name, $default);
        } catch (Exception $ex) {
            return $default;
        }
    }