Returns raw string type format from the var annotation
@param \ReflectionProperty $property
@return string
5581
private function getRawType(\ReflectionProperty $property)
    {
        $matches = [];
        if (preg_match('/@var\s+([^\s]+)/', $property->getDocComment(), $matches)) {
            list(, $rawType) = $matches;
        } else {
            $rawType = 'mixed';
        }
        return $rawType;
    }
234392
final protected static function get_format_field($definitions, $property) {
        $formatproperty = $property . 'format';
        if (($definitions[$property]['type'] == PARAM_RAW || $definitions[$property]['type'] == PARAM_CLEANHTML)
                && isset($definitions[$formatproperty])
                && $definitions[$formatproperty]['type'] == PARAM_INT) {
            return $formatproperty;
        }
        return false;
    }
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;
    }
925817
public function getPropertyMapper($property)
    {
        if( !$this->propertyMapper ) {
            throw new NoPropertyMapperSet();
        }
        $refl = new ReflectionClass($this->propertyMapper);
        return $refl->newInstance($property);
    }
520085
public function getProperty($property){        
        //Primero Busco por get
        $getMethod= 'get' . strtoupper($property[0]) . substr($property, 1);                     
        if($this->reflection->hasMethod($getMethod)){
            $reflectionMethod= $this->reflection->getMethod($getMethod);
            //Si existe el metodo set y es public lo seteo
            if($reflectionMethod->isPublic()){
                return $this->object->$getMethod();
            }            
        }else if($this->reflection->hasProperty($property)){
            //Si existe la propiedad y es public la seteo
            $reflectionProperty= $this->reflection->getProperty($property);
            if($reflectionProperty->isPublic()){
                return $this->object->$property;
            }
        }
        return NULL;
    }
1334991
protected function getNumericValue(string $property)
    {
        return ($property === 'time')
               ? (float) $this->accumulate('getTotalTime')
               : (int) $this->accumulate('getTotal' . ucfirst($property));
    }
1491
public function getProperty(PHPStanClassReflection $reflection, string $property) : PHPStanPropertyReflection
	{
		$native = $reflection->getNativeReflection();
		
		if($native->hasMethod("getter_".$property))
			return $this->getUnderscoreGetter($reflection, $property);
		
		return null;
	}
392171
public static function property($property = null)
	{
		$property = strtolower($property);
		return array_key_exists($property, static::$properties) ? static::$properties[$property] : null;
	}
346540
public function buildAttribute($property)
    {
        $attribute = '';
        if (isset($this->$property)) {
            $attribute .= ' ' . $property . '="';
            if (is_bool($this->$property)) {
                $attribute .= ($this->$property) ? 'true' : 'false';
            } else {
                $attribute .= SolrRequest::escapeXml($this->$property);
            }
            $attribute .= '"';
        }
        return $attribute;
    }
719144
public function get($property)
    {
        $value = null;

        if ($this->_convert) {
            $property = str_replace( "_", "-", $property );
        } else {
            $property = str_replace( "-", "_", $property );
        }

        if (array_key_exists($property, $this->_values)) {
            return $this->_values[$property];
        } else {
            return null;
        }

    }
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'];
    }
852699
private function getParameter(Property $property): array
    {
        $type = $property->getType();
        if (TypeChecker::isKnownType($type) && $this->options->useTypeHints()) {
            return [
                [
                    'name' => $property->getName(),
                    'type' => $type,
                ],
            ];
        }

        return [$property->getName()];
    }
1356128
protected function RetrievePropertyValueFromData(string $property)
    {
        $isNullable = in_array(
            $property,
            static::DaftObjectNullableProperties(),
            DefinitionAssistant::IN_ARRAY_STRICT_MODE
        );

        if ( ! array_key_exists($property, $this->data) && ! $isNullable) {
            throw Exceptions\Factory::PropertyNotNullableException(static::class, $property);
        } elseif ($isNullable) {
            return $this->data[$property] ?? null;
        }

        return $this->data[$property];
    }
871727
private function createValueExposure($property): string
    {
        if ($property->readValueFilter) {
            $exposure = \sprintf('$data[\'%s\'] = %s;', $property->exposeAs, $property->readValueFilter);
        } elseif ($property->isScalarType()) {
            $exposure = \sprintf('$data[\'%s\'] = (%s) $value;', $property->exposeAs, $property->type);
        } elseif ($property->isMixedCollectionType()) {
            $exposure = \sprintf('$data[\'%s\'] = $value;', $property->exposeAs);
        } elseif ($property->isCollection()) {
            $template = <<<STRING
\$collection = [];
    foreach (\$value as \$key => \$val) {
        \$collection[\$key] = {reader}
    }
    \$data['{exposeAs}'] = \$collection;
STRING;
            if ($property->isScalarCollectionType()) {
                $reader = \sprintf('(%s) $val;', $property->getTypeOfCollection());
            } else {
                $reader = '$this->serializer->normalize($val, $context);';
            }

            $exposure = \strtr($template, [
                '{reader}' => $reader,
                '{exposeAs}' => $property->exposeAs,
            ]);
        } else {
            $exposure = \sprintf('$data[\'%s\'] = $this->serializer->normalize($value, $context);', $property->exposeAs);
        }

        if (!$this->configuration->isMaxDepthCheckEnabled()) {
            return $exposure;
        }

        $maxDepthWrap = <<<STRING
if (!\$context->isMaxDepthAchieve(\$this->classMetadata->{locatePropertyAt}['{propertyName}'])) {
        {exposure}
    }
STRING;

        return \strtr($maxDepthWrap, [
            '{exposure}' => $exposure,
            '{propertyName}' => $property->name,
            '{locatePropertyAt}' => $property instanceof PropertyMetadata ? 'propertyMetadata' : 'methodMetadata',
        ]);
    }
772324
private function getPropertyValue($property)
    {
        $value  = null;
        $getter = 'get' . SimpleDataObjectConverter::snakeCaseToUpperCamelCase($property);

        if (method_exists($this, $getter)) {
            $value = $this->{$getter}();
        } elseif ($this->returnAdditionalSetting($property)) {
            $value = $this->returnAdditionalSetting($property);
        }

        return $value;
    }
214445
protected function getNumericValue(string $property)
    {
        return ($property === 'time')
            ? (float) $this->suites[0]->$property
            : (int) $this->suites[0]->$property;
    }
106506
public static function readProperty( $property , $annotation = null ) {

		$ref = $property instanceof ReflectionProperty ? $property : new ReflectionProperty( $property[0] , $property[1] );

		return $annotation ? static::reader()->getPropertyAnnotation( $ref , $annotation ) : static::reader()->getPropertyAnnotations( $ref );

	}