Returns array with all types defined in property parameter.

@param array $propertyParameter

@return array
435825
private function getTypesProperty($propertyParameter)
    {
        $filterTypes = [];

        if (array_key_exists('types', $propertyParameter)
            && null !== ($types = explode(',', $propertyParameter['types']->getValue()))
        ) {
            foreach ($types as $type) {
                $filterTypes[] = $type;
            }
        }

        return $filterTypes;
    }
991741
public function getProperties()
    {
        $names = array_keys($this->getValue('properties'));
        $result = [];
        foreach ($names as $name) {
            $result[$name] = $this->get($name);
        }

        return $result;
    }
464582
public function getProperties()
    {
        if (!$this->propertiesCache) {
            $this->propertiesCache = [];
            foreach (array_keys($this->properties) as $name) {
                $this->propertiesCache[$name] = $this->getProperty($name);
            }
        }

        return $this->propertiesCache;
    }
1099248
public function getKeyedByPropertyMulti($property)
    {
        $keyed = [];
        foreach ($this as $model) {
            if (empty($keyed[$model->$property])) {
                $keyed[$model->$property] = [];
            }
            $keyed[$model->$property][] = $model;
        }
        return $keyed;
    }
347210
public function getPropertyType(string $propertyName) : string
    {
        $stringProperties = [
            'Comment' => 1,
            'Browser' => 1,
            'Browser_Maker' => 1,
            'Browser_Modus' => 1,
            'Browser_Type' => 1,
            'Platform' => 1,
            'Platform_Name' => 1,
            'Platform_Description' => 1,
            'Device_Name' => 1,
            'Platform_Maker' => 1,
            'Device_Code_Name' => 1,
            'Device_Maker' => 1,
            'Device_Brand_Name' => 1,
            'Device_Type' => 1,
            'RenderingEngine_Name' => 1,
            'RenderingEngine_Description' => 1,
            'RenderingEngine_Maker' => 1,
            'Parent' => 1,
            'PropertyName' => 1,
            'PatternId' => 1,
        ];

        if (isset($stringProperties[$propertyName])) {
            return self::TYPE_STRING;
        }

        $arrayProperties = [
            'Device_Pointing_Method' => 1,
            'Browser_Bits' => 1,
            'Platform_Bits' => 1,
        ];

        if (isset($arrayProperties[$propertyName])) {
            return self::TYPE_IN_ARRAY;
        }

        $genericProperties = [
            'Platform_Version' => 1,
            'RenderingEngine_Version' => 1,
        ];

        if (isset($genericProperties[$propertyName])) {
            return self::TYPE_GENERIC;
        }

        $numericProperties = [
            'Version' => 1,
            'CssVersion' => 1,
            'AolVersion' => 1,
            'MajorVer' => 1,
            'MinorVer' => 1,
        ];

        if (isset($numericProperties[$propertyName])) {
            return self::TYPE_NUMBER;
        }

        $booleanProperties = [
            'Alpha' => 1,
            'Beta' => 1,
            'Win16' => 1,
            'Win32' => 1,
            'Win64' => 1,
            'Frames' => 1,
            'IFrames' => 1,
            'Tables' => 1,
            'Cookies' => 1,
            'BackgroundSounds' => 1,
            'JavaScript' => 1,
            'VBScript' => 1,
            'JavaApplets' => 1,
            'ActiveXControls' => 1,
            'isMobileDevice' => 1,
            'isTablet' => 1,
            'isSyndicationReader' => 1,
            'Crawler' => 1,
            'MasterParent' => 1,
            'LiteMode' => 1,
            'isFake' => 1,
            'isAnonymized' => 1,
            'isModified' => 1,
        ];

        if (isset($booleanProperties[$propertyName])) {
            return self::TYPE_BOOLEAN;
        }

        throw new \InvalidArgumentException("Property {$propertyName} did not have a defined property type");
    }
930444
private function getPropertyTypes(ObjectInterface $object, $index)
    {
        $objectClass = get_class($object);

        if (!array_key_exists($objectClass, $this->reflectionCache) || !array_key_exists($index,
                $this->reflectionCache[$objectClass])) {

            $propertyTypes = $this->PropertyInfoExtractor->getTypes($objectClass, $index);

            $this->reflectionCache[$objectClass][$index] = $propertyTypes;
        } else {
            $propertyTypes = $this->reflectionCache[$objectClass][$index];
        }

        return $propertyTypes;
    }
1345512
public function getPropertyAnnotations(\ReflectionProperty $prop)
    {
        return array_merge(
            $this->reader->getPropertyAnnotations($prop),
            $this->converter->getPropertyAnnotations($prop)
        );
    }
309173
protected function getPropertyTypes()
	{
		$manager = \Aimeos\MShop::create( $this->getContext(), 'customer/property/type' );

		$search = $manager->createSearch( true )->setSlice( 0, 10000 );
		$search->setSortations( [$search->sort( '+', 'customer.property.type.position')] );

		return $manager->searchItems( $search );
	}
1023385
private function parameters($parameters): array
    {
        $values = (!is_array($parameters)) ? [$parameters] : $parameters;

        $strings = [];

        foreach ($values as $value) {
            $strings[] = self::make($value, $this->encoding);
        }

        return $strings;
    }
953223
public function getPropertyValidators($propertyName = null)
    {
        if ($propertyName !== null) {
            return $this->propertyValidators[$propertyName] ?? [];
        }
        return $this->propertyValidators;
    }
1273020
public static function getParameter($param)
    {
        $lexer = new Lexer('(' . $param . ')');

        // A dummy parser is used for error reporting.
        $param = ParameterDefinition::parse(new Parser(), $lexer->list);

        if (empty($param[0])) {
            return [
                '',
                '',
                '',
                '',
                '',
            ];
        }

        $param = $param[0];

        $options = [];
        foreach ($param->type->options->options as $opt) {
            $options[] = is_string($opt) ? $opt : $opt['value'];
        }

        return [
            empty($param->inOut) ? '' : $param->inOut,
            $param->name,
            $param->type->name,
            implode(',', $param->type->parameters),
            implode(' ', $options),
        ];
    }
1274909
protected function getTypeByProperty($type, $property, $value)
    {
        foreach($this[$type] as $item) {
            if (true === isset($item[$property]) && $value === $item[$property]) {
                return $item;
            }
        }

        throw new \RuntimeException(sprintf("Unknown %s item with %s '%s'", $type, $property, $value), 404);
    }
775376
private function createAssignsFromParams(array $params): array
    {
        $assigns = [];

        /** @var Param $param */
        foreach ($params as $param) {
            $propertyFetch = new PropertyFetch(new Variable('this'), $param->var->name);
            $assigns[] = new Assign($propertyFetch, new Variable($param->var->name));
        }

        return $assigns;
    }
783031
public function getProperties($properties){
        $values= array();
        foreach ($properties as $key) {
            $values[$key]= $this->getProperty($key);
        }
        return $values;
    }
1068534
public function make(\ReflectionProperty $reflectionParameter)
    {
        if (!$this->parser) {
            throw new \RuntimeException("Missing the parser Parser!");
        }

        $result = $this->parser->parse(
            $reflectionParameter->getDocComment()
        );

        if (!$result) {
            return [];
        }

        $validatorSet = [];
        $this->missingValidators = [];

        foreach ($result as $validatorToken) {
            // check if the annotation is with the full namespace already otherwise put it relative
            $className = $this->namespaceTransformer->transform(
                $this->classNameTransformer->transform(
                    $validatorToken[AnnotationValidatorParser::INDEX_INTERFACE]
                ),
                [
                    AnnotationValidatorPrependNameSpace::NAMESPACE_OPTION_INDEX => __NAMESPACE__
                ]
            );
            if (class_exists($className, true)) {
                // keep the validators in the runtime -> they are stateless and can be used as a reference
                if (empty($this->validatorTemplates[$className])) {
                    $this->validatorTemplates[$className] = new $className();
                }

                $validatorSet[] = [
                    self::INDEX_RESULT                             => null,
                    AnnotationValidatorParser::INDEX_MANDATORY     => $validatorToken[AnnotationValidatorParser::INDEX_MANDATORY],
                    AnnotationValidatorParser::INDEX_OPERATOR      => $validatorToken[AnnotationValidatorParser::INDEX_OPERATOR],
                    AnnotationValidatorParser::INDEX_INTERFACE     => $this->validatorTemplates[$className],
                    AnnotationValidatorParser::INDEX_EXPECTED      => $validatorToken[AnnotationValidatorParser::INDEX_EXPECTED],
                ];
            } else {
                $this->missingValidators[] = $className;
            }
        }

        if ($this->missingValidators) {
            throw new \RuntimeException("There is one or more Validators Missing: " . implode(',', $this->missingValidators));
        }

        return $validatorSet;
    }
1291403
private function makeParameters(array $parameters): array
    {
        return array_map(function (ReflectionParameter $parameter) {
            $class = $parameter->getClass();

            if ($class instanceof ReflectionClass) {
                return $this->make($class->getName());
            }

            if ($parameter->isDefaultValueAvailable()) {
                return $parameter->getDefaultValue();
            }

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

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

        return $names;
    }