Retrieves the list of annotations from provided property

@param string $property Property name
@throws Exception\InvalidArgumentException
@return AnnotationsList
776644
public function getPropertyAnnotations($property)
    {
        if (!$this->hasProperty($property)) {
            $name = $this->_getReflection()->getName();
            throw new Exception\InvalidArgumentException(
                "The class {$name} doesn't have a property called {$property}"
            );
        }

        if (empty($this->_annotations['properties'][$property])) {
            $comment = $this->_getReflection()
                ->getProperty($property)
                ->getDocComment();
            $data = AnnotationParser::getAnnotations($comment);
            $propertyAnnotations = new AnnotationsList();
            foreach ($data as $property => $parsedData) {
                $propertyAnnotations->append(
                    $this->_createAnnotation($property, $parsedData)
                );
            }
            $this->_annotations['properties'][$property] = $propertyAnnotations;
        }
        return $this->_annotations['properties'][$property];
    }
682496
public function getSerializedName(\ReflectionProperty $property, Property $annot = null)
    {
        if ($annot || $annot = $this->getPropertyAnnotation($property)) {

            return $annot->getName();
        }

        return $property->getName();
    }
92880
public function getMandatoryProperty($property)
    {
        \Assert\that($property)->string()->notEmpty();

        if (isset($this->description->{$property}) === false) {
            throw InvalidDescriptionException::missingMandatoryProperty($property);
        }

        if ($this->description->{$property} instanceof \stdClass) {
            return new static($this->description->{$property});
        }

        return $this->description->{$property};
    }
730439
private function existenceValidation(Property $property)
    {
        $key = $property->key;

        return [
            $key,
            'exist',
            'targetClass' => StaticValue::className(),
            'targetAttribute' => 'id',
            'allowArray' => $property->allow_multiple_values,
            'filter' => ['property_id' => $property->id],
            'skipOnEmpty' => true,
        ];

    }
1167190
private function getEmbeddedAnnotationData(\ReflectionProperty $property)
    {
        $result = $this->reader->getPropertyAnnotation($property, self::EMBEDDED_ANNOTATION);

        if ($result !== null && $result->name === null) {
            $result->name = Caser::snake($property->getName());
        }

        return $result;
    }
657870
protected function getAnnotation($entity, $property, $annotation) {
        $classRef = new \ReflectionClass($entity);
        $propertyRef = $classRef->getProperty($property);
        if ($propertyRef) return $this->annoReader->getPropertyAnnotation($propertyRef, $annotation);
        else return null;
    }
193146
protected function getElementName(Property $property)
	{
		/* @var $annotations ElementNameAnnotation[] */
		$annotations = $property->getAnnotationsFromPropertyOrClass('@element-name');

		if ( $annotations && ($annotations[0] instanceof ElementNameAnnotation) ) {
			return $annotations[0]->name;
		}

		return (string)$property;
	}
221133
private function getValidators($annotations, $class)
    {
        $validators = [];
        $it = $this->getAnnotations()->filter($annotations)
            ->is(ValidatorInterface::class)
            ->onProperties();
        foreach ($it as $annotation) {
            $property = $annotation->getPropertyName();
            if (!isset($validators[$property])) {
                $validators[$property] = [
                    'required' => false,
                    'validators' => [],
                ];
            }
            $validators[$property]['validators'][] = $annotation->getValidator($this);
            if ($annotation instanceof Required) {
                $validators[$property]['required'] = true;
            }
        }
        return $validators;
    }
35278
public static function getPropertyAnnotations($class, $property)
    {
        $annotationBag = Bridge\Loader::getInstance()->getPropertyAnnotations($class, str_replace('$', '', $property));
        $annotationBag = self::explodeNamespaces($annotationBag);

        return new ConfigObject($annotationBag);
    }
786578
public function getProperty($name)
    {
        if (!$this->hasProperty($name)) {
            throw new Exception\InvalidArgumentException(
                "Unknown property " . $name . "!"
            );
        }
        return $this->properties[$name];
    }
886738
private function findPropertyFromReference(&$property) : PropertyDefinition
    {
        $traceLevel = $this->propertyDefinitionTraceLevel;

        foreach ($this->propertyReferenceMap as $name => &$propertyReference) {
            if (ReferenceComparer::areEqual($property, $propertyReference)) {

                return $this->properties[$name];
            }
        }

        $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, $traceLevel + 1)[$traceLevel];
        throw new InvalidPropertyDefinitionException($this->class, $trace['file'], $trace['line']);
    }
501478
public function getAnnotation($name)
    {
        if (!$this->hasAnnotation($name)) {
            throw new Exception\InvalidArgumentException(
                "Annotation {$name} is not found in this list."
            );
        }

        $name = str_replace('@', '', $name);
        return $this[$name];
    }
214003
public function getPropertyAnnotation(\ReflectionProperty $property)
    {
        $annot = $this->reader->getPropertyAnnotation($property, '\Represent\Annotations\Property');

        if (!$annot) {
            return false;
        }

        return $annot;
    }
318876
public static function get_property_type($property) {

        self::fill_properties_cache();

        if (!array_key_exists($property, self::$propertiescache)) {
            throw new coding_exception('Invalid property requested: ' . $property);
        }

        return self::$propertiescache[$property]['type'];
    }
769952
public function getRelationMappedToProperty(string $property)
    {
        InvalidArgumentException::verify(is_string($property), 'property must be a string');
        $relations = $this->getRelationMappings();

        foreach ($relations as $mapping) {
            $accessor = $mapping->getAccessor();

            if ($accessor instanceof PropertyAccessor) {
                if ($accessor->getPropertyName() === $property) {

                    return $mapping->getRelation();
                }
            }
        }

        return null;
    }
1084351
public function add($property)
    {
        if (!$property instanceof PropertyInterface) {
            throw new \InvalidArgumentException(
                'This Property must be a instance of \ClassGeneration\PropertyInterface'
            );
        }
        if ($property->getName() === null) {
            $property->setName('property' . ($this->count() + 1));
        }

        parent::set($property->getName(), $property);

        return true;
    }
277342
public function getModifier($property)
    {
        $i = $this->indexOf($property);

        if ($i === -1) {
            throw new \InvalidArgumentException("Modifier '{$property}' not found");
        }

        return $this->modifiers[$i];
    }