Get the meta information for a single parameter.

@param string $paramName
@return array
337429
public function getParamInfo($paramName)
    {
        $propertyUtility = new RequestPropertyUtility($this, $paramName);

        return [
            'is_required'          => $propertyUtility->isRequired(),
            'is_array'             => $propertyUtility->isArray(),
            'is_not_blank'         => $propertyUtility->getNotBlank(),
            'is_not_null'          => $propertyUtility->getNotNull(),
            'description'          => $propertyUtility->getDescription(),
            'type'                 => $propertyUtility->getType(),
            'default_value'        => $propertyUtility->getDefaultValue(),
            'example_value'        => $propertyUtility->getExampleValue(),
            'default_value_string' => $propertyUtility->getDefaultValueAsString(),
            'example_value_string' => $propertyUtility->getExampleValueAsString(),
            'default_value_code'   => $propertyUtility->getDefaultValueAsCode(),
            'example_value_code'   => $propertyUtility->getExampleValueAsCode(),
            'choices'              => $propertyUtility->getChoices(),
            'regex'                => $propertyUtility->getRegex(),
            'range'                => $propertyUtility->getRange(),
            'count'                => $propertyUtility->getCount(),
            'uuid'                 => $propertyUtility->getUuid(),
        ];
    }
881542
public function getMetaData(string $key, $default = null)
    {
        $meta = $this->getAttribute('meta');

        return $meta->get($key, $default);
    }
1104249
public boolean getParamBoolean(String paramName) {
        Object paramValue = getParam(paramName);
        if (paramValue == null) {
            return false;
        }
        return Boolean.parseBoolean(paramValue.toString());
    }
935660
public function getParam($paramName)
    {
        return !empty($this->_params[$paramName]) ? $this->_params[$paramName] : NULL;
    }
678754
public function metadata($routeName)
	{
		return isset($this->_metadata[$routeName])
			? array_merge($this->_defaultMetadata, $this->_metadata[$routeName])
			: $this->_defaultMetadata
			;
	}
886862
public static function getParamFromLink($url, $paramName)
    {
        if (!$url) {
            throw new \InvalidArgumentException('url');
        }

        if (!$paramName) {
            throw new \InvalidArgumentException('paramName');
        }

        $parts = parse_url(html_entity_decode($url));
        if (isset($parts)) {
            parse_str($parts['query'], $query);
            if (array_key_exists($paramName, $query)) {
                return $query[$paramName];
            }
        }

        return null;
    }
1041018
public function getParamNames(): array
    {
        $names = [];

        foreach ($this->getPublicProperties() as $param) {
            $names[] = $param->getName();
        }

        return $names;
    }
930275
private function getBindParams(string $className, string $methodName): array
    {
        $reflectClass = new \ReflectionClass($className);
        $reflectMethod = $reflectClass->getMethod($methodName);
        $reflectParams = $reflectMethod->getParameters();

        // binding params
        $bindParams = [];
        foreach ($reflectParams as $key => $reflectParam) {
            $reflectType = $reflectParam->getType();

            // undefined type of the param
            if ($reflectType === null) {
                $bindParams[$key] = null;
                continue;
            }

            /**
             * defined type of the param
             * @notice \ReflectType::getName() is not supported in PHP 7.0, that is why use __toString()
             */
            $type = $reflectType->__toString();
            if ($type === Output::class) {
                $bindParams[$key] = \output();
            } elseif ($type === Input::class) {
                $bindParams[$key] = \input();
            } else {
                $bindParams[$key] = null;
            }
        }

        return $bindParams;
    }
1204656
public function getParameter($parameterName) {
    $parameterName = ltrim($parameterName, '$');
    $param_tags = $this->getDocBlock()->getTagsByName('param');
    /** @var \phpDocumentor\Reflection\DocBlock\Tag\ParamTag $param_tag */
    foreach ($param_tags as $param_tag) {
      if (ltrim($param_tag->getVariableName(), '$') === $parameterName) {
        return $param_tag;
      }
    }
    return NULL;
  }
1269602
public final function getMetadata($key = null)
   {
       return isset($key)
            ? (array_key_exists($key, $this->meta) ? $this->meta[$key] : null)
            : $this->meta;
   }
97527
public function getParams($filename = "")
    {

        if (empty($filename)) {
            return $this->namespace;
        } elseif (!empty($filename) && isset($this->namespace[$filename])) {
            return $this->namespace[$filename];
        } else {
            return array(); //if the params don't exists;
        }
    }
100391
public function getMeta($name)
    {
        return $this->getMetas()->filter(function (ArticleMeta $meta) use ($name) {
            return $meta->getMeta()->getName() == $name;
        })->first();
    }
20456
protected function param($paramName)
    {
        $fallbacks = $this->getDefaultParamsNonPersistentCached();

        if ($paramName == 'content') {
            return $this->content
                ? $this->content
                : $fallbacks['content'];
        }

        if (isset($this->params[$paramName])) {
            return $this->params[$paramName];
        } elseif (isset($fallbacks[$paramName])) {
            return $fallbacks[$paramName];
        } else {
            return null;
        }
    }
307362
public function hasMetadata($paramName)
	{
		if ( ! is_string($paramName) || empty($paramName)) {
			throw new WorkflowException("Invalid metadata name : non empty string expected");
		}
		return array_key_exists($paramName, $this->_metadata);
	}
310544
public function getMetaTags($tagName, array $params = array())
    {
        if (!isset($params[0])) {
            throw new InvalidArgumentException(
                '$params[0]',
                'Literal URL handler requires the path to output.'
            );
        }

        $path = $params[0];
        $request = $this->requestStack->getCurrentRequest();

        if (!preg_match('/^https?:\/\//', $path) && $request instanceof Request) {
            $path = $request->getUriForPath('/' . ltrim($path, '/'));
        }

        return array(
            new Item(
                $tagName,
                $path
            ),
        );
    }
700896
public String getParam(String paramName) {
		if (requestParameters == null) {
			return null;
		}
		String[] values = requestParameters.get(paramName);
		if (ArrayUtil.isNotEmpty(values)) {
			return values[0];
		}
		return null;
	}
647743
protected function parseMeta($meta)
    {
        $fields = [];
        
        foreach ($meta as $key => $value) {
            $fields[] = [
                'title' => $key,
                'value' => $value,
            ];
        }
        
        return $fields;
    }