handles single param

@param   \stubbles\input\valuereader\CommonValueReader  $valueReader  instance to filter value with
@param   \stubbles\reflect\annotation\Annotation        $annotation   annotation which contains filter metadata
@return  string
191257
protected function filter(CommonValueReader $valueReader, Annotation $annotation)
    {
        return $valueReader->asText(
                new StringLength(
                        $annotation->getMinLength(),
                        $annotation->getMaxLength()
                ),
                $this->allowedTags($annotation)
        );
    }
777029
public function normalize(PageUrlAnnotation $annotation)
	{
		$parser = new Parser($this->baseUrl);
		$parser->merge(new Parser($annotation->url));

		$parser->setParams(array_merge($parser->getParams(), $annotation->params));

		$ret = $parser->getComponents();

		if ( $annotation->secure !== null && !empty($ret['scheme']) ) {
			$ret['scheme'] = $annotation->secure ? 'https' : 'http';
		}

		return $ret;
	}
37096
public static function parse(Tokenizer $tokenizer, StreamReader $streamReader, PdfParser $parser)
    {
        $entries = [];

        while (true) {
            $token = $tokenizer->getNextToken();
            if ($token === '>' && $streamReader->getByte() === '>') {
                $streamReader->addOffset(1);
                break;
            }

            $key = $parser->readValue($token);
            if ($key === false) {
                return false;
            }

            // ensure the first value to be a Name object
            if (!($key instanceof PdfName)) {
                $lastToken = null;
                // ignore all other entries and search for the closing brackets
                while (($token = $tokenizer->getNextToken()) !== '>' && $token !== false && $lastToken !== '>') {
                    $lastToken = $token;
                }

                if ($token === false) {
                    return false;
                }

                break;
            }


            $value = $parser->readValue();
            if ($value === false) {
                return false;
            }

            if ($value instanceof PdfNull) {
                continue;
            }

            // catch missing value
            if ($value instanceof PdfToken && $value->value === '>' && $streamReader->getByte() === '>') {
                $streamReader->addOffset(1);
                break;
            }

            $entries[$key->value] = $value;
        }

        $v = new self;
        $v->value = $entries;

        return $v;
    }
376292
public function parse(\Imi\Bean\Annotation\Base $annotation, string $className, string $target, string $targetName)
    {
        if($annotation instanceof Tool)
        {
            $this->data['class'][$className]['Tool'] = $annotation;
            Event::trigger('TOOL_PARSER.PARSE_TOOL.' . $className);
        }
        else if($annotation instanceof Operation)
        {
            if(isset($this->data['class'][$className]['Methods'][$targetName]['Operation']) && $this->data['class'][$className]['Methods'][$targetName]['Operation'] != $annotation)
            {
                throw new \RuntimeException(sprintf('Tool %s/%s is already exists!', isset($this->data['class'][$className]['Tool']) ? $this->data['class'][$className]['Tool']->name : $className, $annotation->name));
            }
            $this->data['class'][$className]['Methods'][$targetName]['Operation'] = $annotation;
            if(isset($this->data['class'][$className]['Tool']))
            {
                $this->data['tool'][$this->data['class'][$className]['Tool']->name][$annotation->name] = [$className, $targetName];
            }
            else
            {
                $operation = $annotation;
                Event::one('TOOL_PARSER.PARSE_TOOL.' . $className, function() use($className, $operation, $targetName){
                    $this->data['tool'][$this->data['class'][$className]['Tool']->name][$operation->name] = [$className, $targetName];
                });
            }
            
        }
        else if($annotation instanceof Arg)
        {
            $this->data['class'][$className]['Methods'][$targetName]['Args'][$annotation->name] = $annotation;
        }
    }
1254372
public static function hasPropertyAnnotation(\ReflectionProperty $property, $annotationClass, AnnotationReader $reader)
    {
        if (null === self::getPropertyAnnotation($property, $annotationClass, $reader)) {
            return false;
        }

        return true;
    }
137503
protected function filter(CommonValueReader $valueReader, Annotation $annotation)
    {
        return $valueReader->asFloat(
                new NumberRange(
                        $annotation->getMinValue(),
                        $annotation->getMaxValue()
                ),
                $annotation->getDecimals()
        );
    }
698632
public static function renderAnnotation($annotation)
    {
        $annotationAsString = '@\\' . get_class($annotation);

        $optionNames = get_class_vars(get_class($annotation));
        $optionsAsStrings = [];
        foreach ($optionNames as $optionName => $optionDefault) {
            $optionValue = $annotation->$optionName;
            $optionValueAsString = '';
            if (is_object($optionValue)) {
                $optionValueAsString = self::renderAnnotation($optionValue);
            } elseif (is_scalar($optionValue) && is_string($optionValue)) {
                $optionValueAsString = '"' . $optionValue . '"';
            } elseif (is_bool($optionValue)) {
                $optionValueAsString = $optionValue ? 'true' : 'false';
            } elseif (is_scalar($optionValue)) {
                $optionValueAsString = $optionValue;
            } elseif (is_array($optionValue)) {
                $optionValueAsString = self::renderOptionArrayValueAsString($optionValue);
            }
            switch ($optionName) {
                case 'value':
                    $optionsAsStrings[] = $optionValueAsString;
                    break;
                default:
                    if ($optionValue === $optionDefault) {
                        break;
                    }
                    $optionsAsStrings[] = $optionName . '=' . $optionValueAsString;
            }
        }
        return $annotationAsString . ($optionsAsStrings !== [] ? '(' . implode(', ', $optionsAsStrings) . ')' : '');
    }
977001
protected function getMultipleSelectedValue($name, $valueAccessor, $defaultValue)
    {
        return sprintf(" {{ %s ? 'selected' : '' }}", $this->getMultipleRawOptionValue($name, $valueAccessor, $defaultValue));
    }
1122920
public function parser(string $className, $objectAnnotation = null, string $propertyName = "", string $methodName = "", $propertyValue = null)
    {
        $beanName = $className;
        $scope    = Scope::SINGLETON;

        BootstrapCollector::collect($className, $objectAnnotation, $propertyName, $methodName, $propertyValue);

        return [$beanName, $scope, ""];
    }
1238478
private static function getAnnotationReader()
    {
        if (null === self::$annotationReader) {
            if (!\class_exists('\\Doctrine\\Common\\Annotations\\AnnotationReader') ||
                !\class_exists('\\Doctrine\\Common\\Annotations\\AnnotationRegistry')) {
                throw new \Exception('In order to use graphql annotation, you need to require doctrine annotations');
            }

            AnnotationRegistry::registerLoader('class_exists');
            self::$annotationReader = new AnnotationReader();
        }

        return self::$annotationReader;
    }
694451
public function readEnv(string $envName): ValueReader
    {
        return new ValueReader(
                $this->env->errors(),
                $envName,
                $this->env->value($envName)
        );
    }
267003
public static function translate(string $value, array $valueMap) : string
    {
        if (!array_key_exists($value, $valueMap)) {
            throw new FilterException("The value '{$value}' was not found in the translation map array.");
        }

        return $valueMap[$value];
    }
761823
protected function initExtensions(\Doctrine\Common\Annotations\Reader $annotationReader, DriverChain $driverChain)
    {
        // load superclass metadata mapping only, into driver chain
        // also registers Gedmo annotations.NOTE: you can personalize it
        \Gedmo\DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $annotationReader);

        // create event manager and hook prefered extension listeners
        $evm = new \Doctrine\Common\EventManager();

        $eventsConf = Application::getConfigManager()->loadForModule('Cmf\Db', 'eventListener');

        foreach ($eventsConf as $itemConf) {
            $className = $itemConf->class;
            $listener = new $className();
            $listener->setAnnotationReader($annotationReader);
            $evm->addEventSubscriber($listener);
        }

        return $evm;
    }
651374
protected function getArgValue($data, $arg, $annotation, $includeAnnotationProperty = true)
    {
        if(!is_string($arg))
        {
            return $arg;
        }
        else if(preg_match('/\{:([^\}]+)\}/', $arg, $matches) > 0)
        {
            $argName = $matches[1];
            if('value' === $argName)
            {
                return ObjectArrayHelper::get($data, $annotation->name);
            }
            $list = explode('.', $argName, 2);
            if('data' === $list[0])
            {
                if(isset($list[1]))
                {
                    return ObjectArrayHelper::get($data, $list[1]);
                }
                else
                {
                    return $data;
                }
            }
        }
        else if($includeAnnotationProperty && preg_match('/\{([^\}]+)\}/', $arg, $matches) > 0)
        {
            $argName = $matches[1];
            return ObjectArrayHelper::get($annotation, $argName);
        }
        else
        {
            return $arg;
        }
    }
292432
public function readCookie(string $cookieName): ValueReader
    {
        return new ValueReader(
                $this->cookies->errors(),
                $cookieName,
                $this->cookies->value($cookieName)
        );
    }
426097
public function readParam(string $paramName): ValueReader
    {
        return new ValueReader(
                $this->params->errors(),
                $paramName,
                $this->params->value($paramName)
        );
    }
1252692
public function evaluate(
        QueryBuilder $queryBuilder,
        CreatePaginator $annotation
    ) {
        foreach ($this->paginatorEvaluators as $paginatorEvaluator) {
            $paginatorEvaluator->evaluate($queryBuilder, $annotation);
        }
    }