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  array
760370
protected function filter(CommonValueReader $valueReader, Annotation $annotation)
    {
        return $valueReader->asArray($annotation->getSeparator(CommonValueReader::ARRAY_SEPARATOR));
    }
647759
public function processAnnotations(): void
    {
        $class    = $this->property->getClass();
        $imports  = $class ? array_change_key_case($class->getUseStatements()) : [];
        $filename = $class ? $class->getFilename() : 'memory';

        // Get all the namespaces in which annotations reside.
        $namespaces = [];
        foreach ($this->annotation_processors as $processor) {
            $namespaces[] = $processor->getProcessableAnnotationNamespace();
        }

        // Filter all imports that could lead to non loaded annotations,
        // this would let the DocParser explode with an Exception, while
        // the goal is to ignore other annotations besides the one explicitly
        // loaded.
        $without_foreign_annotations = array_filter(
            $imports,
            function ($import) use ($namespaces) {
                foreach ($namespaces as $namespace) {
                    if (stripos($namespace, $import) === 0) {
                        return true;
                    }
                }

                return false;
            }
        );

        $this->parser->setImports($without_foreign_annotations);
        $this->parser->setIgnoreNotImportedAnnotations(true);

        $annotations = $this->parser->parse($this->property->getDocComment(), $filename);

        // If the property is encrypted, column type MUST be string.
        $is_encrypted = false;
        $is_string    = true;
        foreach ($this->annotation_processors as $processor) {
            foreach ($annotations as $annotation) {
                $processor->processAnnotation($annotation, $this);

                if ($annotation instanceof Generate && isset($annotation->encryption_alias)) {
                    $is_encrypted = true;
                }

                if (!($annotation instanceof Column)
                    || !isset($annotation->type)
                    || \in_array($annotation->type, ['string', 'text'])
                ) {
                    continue;
                }

                $is_string = false;
            }
        }

        if ($is_encrypted && !$is_string) {
            throw new \RuntimeException(sprintf(
                'Property %s in class %s\%s has an encryption_alias set, but is not declared as column type \'string\'',
                $this->getName(),
                $this->getNamespace(),
                $this->getClass()
            ));
        }
    }
1354441
protected function getEndpointsInClasses(SimpleAnnotationReader $reader)
    {
        $endpoints = new EndpointCollection();

        foreach ($this->getClassesToScan() as $class) {
            $endpoints = $endpoints->merge($this->getEndpointsInClass(
                $class, new AnnotationSet($class, $reader)
            ));
        }

        return $endpoints;
    }
403775
public function parser(string $className, $objectAnnotation = null, string $propertyName = "", string $methodName = "", $propertyValue = null)
    {
        $name     = $objectAnnotation->getName();
        $scope    = $objectAnnotation->getScope();
        $ref      = $objectAnnotation->getRef();
        $beanName = empty($name) ? $className : $name;

        return [$beanName, $scope, $ref];
    }
694451
public function readEnv(string $envName): ValueReader
    {
        return new ValueReader(
                $this->env->errors(),
                $envName,
                $this->env->value($envName)
        );
    }
905279
public function readHeader(string $headerName): ValueReader
    {
        return new ValueReader(
                $this->headers->errors(),
                $headerName,
                $this->headers->value($headerName)
        );
    }
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;
	}
126550
public function getAnnotationParserFor(RequestAnnotation $annotation)
    {
        foreach ($this->map as $key => $val) {
            if ($annotation instanceof  $key) {
                return new $val;
            }
        }
        throw new \Exception('Unsupported annotation: ' . get_class($annotation));
    }
622862
protected function initReaderInstance($initValue)
    {
        $position = $this->parser->getStreamReader()->getPosition()
            + $this->parser->getStreamReader()->getOffset() + $this->fileHeaderOffset;

        if ($initValue instanceof PdfToken && $initValue->value === 'xref') {
            try {
                return new FixedReader($this->parser);
            } catch (CrossReferenceException $e) {
                $this->parser->getStreamReader()->reset($position);
                $this->parser->getTokenizer()->clearStack();

                return new LineReader($this->parser);
            }
        }

        if ($initValue instanceof PdfIndirectObject) {
            // check for encryption
            $stream = PdfStream::ensure($initValue->value);

            $type = PdfDictionary::get($stream->value, 'Type');
            if ($type->value !== 'XRef') {
                throw new CrossReferenceException(
                    'The xref position points to an incorrect object type.',
                    CrossReferenceException::INVALID_DATA
                );
            }

            $this->checkForEncryption($stream->value);

            throw new CrossReferenceException(
                'This PDF document probably uses a compression technique which is not supported by the ' .
                'free parser shipped with FPDI. (See https://www.setasign.com/fpdi-pdf-parser for more details)',
                CrossReferenceException::COMPRESSED_XREF
            );
        }

        throw new CrossReferenceException(
            'The xref position points to an incorrect object type.',
            CrossReferenceException::INVALID_DATA
        );
    }
1254372
public static function hasPropertyAnnotation(\ReflectionProperty $property, $annotationClass, AnnotationReader $reader)
    {
        if (null === self::getPropertyAnnotation($property, $annotationClass, $reader)) {
            return false;
        }

        return true;
    }
877512
public function parser(string $className, $objectAnnotation = null, string $propertyName = "", string $methodName = "", $propertyValue = null)
    {
        Collector::$methodAnnotations[$className][$methodName][] = get_class($objectAnnotation);
        return null;
    }
1161806
public function getAnnotations(){
        if($this->reader === null){
            return null;
        }

        if($this->annotations === null){
            $this->annotations  = [];

            foreach($this->reader->getAnnotations() as $annotation){
                $key    = "";
                $value  = "";

                if(($pos = mb_strpos($annotation, " ")) === false){
                    $key    = mb_substr($annotation, 1);
                }else{
                    $key    = mb_substr($annotation, 1, $pos - 1);
                    $value  = ltrim(mb_substr($annotation, $pos));
                }

                if(!array_key_exists($key, $this->annotations)){
                    $this->annotations[$key]    = [];
                }

                $this->annotations[$key][]  = $value;
            }
        }

        return $this->annotations;
    }
242309
private function parseValue(ValueInterface $obj, Node $node) {
		$value = $node instanceof Const_ ? $node->value : $node->default;
		if ($value !== null) {
			if ($this->isPrimitive($value)) {
				$obj->setValue($this->getPrimitiveValue($value));
			} else {
				$obj->setExpression($this->getExpression($value));
			}
		}
	}
650405
public function parse($value, $annotation = null)
    {
        if (false === ($value = filter_var($value, FILTER_VALIDATE_INT))) {
            throw new ParserException("Raw value must be integer. Invalid value '{$value}' given.");
        }

        return $value;
    }
897942
public function parse(array $existing = [], string &$name = null): array
    {
        if($this->type !== AnnotationReader::ANNOTATION_TYPE_PROPERTY)
            throw new \Exception("[MVQN\Annotations\AnnotationReader] @KeepNullElements is only supported for properties!");

        $name = "keepNullElements";

        if($this->isValueEval($this->value))
        {
            $existing[$name] = "`{$this->value}`";
            return $existing;
        }
        elseif($this->value === null || $this->value === "")
        {
            $existing[$name] = true;
            return $existing;
        }
        else
        {
            // Exclude the item, as we do not know how to handle the 'value' specifically!
            return $existing;
        }
    }
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;
    }
295413
public function toArray( callable $valueConverter = null ): array {
		return [
			'type' => $this->getType(),
			'oldvalue' => $this->objectToArray( $this->oldValue, $valueConverter ),
		];
	}