Get raw property

@param string $rawName
@return object (name, value, priority)
542454
public function getRawProperty( $rawName )
    {
        if ( isset( $this->properties[$rawName] ) )
        {
            return (object) $this->properties[$rawName];
        }

        return null;
    }
365380
private function splitFieldNameAndPrefix($rawName)
    {
        $normalizedName = '';
        $prefix = '';

        if (!empty($rawName)) {
            if (strpos($rawName, CustomField::DEFAULT_PREFIX) === 0) {
                $normalizedName = substr($rawName, strlen(CustomField::DEFAULT_PREFIX));
                $prefix = CustomField::DEFAULT_PREFIX;
            } else {
                $normalizedName = $rawName;
            }
        }

        return [$normalizedName, $prefix];
    }
1152267
public function getProperty(&$object, string $propertyName)
    {
        $reflection = new ReflectionClass(get_class($object));

        /** @var ReflectionProperty $property */
        $property = $reflection->getProperty($propertyName);
        $property->setAccessible(true);

        return $property->getValue($object);
    }
1232308
public function __getSerialisablePropertyValue($propertyName) {
        $map = $this->__getSerialisablePropertyMap();
        if (array_key_exists($propertyName, $map)) {
            return $map [$propertyName];
        } elseif (array_key_exists(substr(strtoupper($propertyName), 0, 1) . substr($propertyName, 1), $map)) {
            return $map [substr(strtoupper($propertyName), 0, 1) . substr($propertyName, 1)];
        } else {
            throw new PropertyNotReadableException (get_class($this), $propertyName);
        }
    }
1373469
public function setValue($rawValue)
    {
        if ($rawValue === null) {
            $this->value = null;
            return $this;
        }
        if (is_object($rawValue) && $rawValue instanceof $this->dataType) {
            $this->value = $rawValue;
            return $this;
        }
        $this->value = $this->propertyMapper->convert($rawValue, $this->dataType, $this->getPropertyMappingConfiguration());
        $this->validationResults = $this->propertyMapper->getMessages();
        if ($this->validator !== null) {
            $validationMessages = $this->validator->validate($this->value);
            $this->validationResults->merge($validationMessages);
        }

        return $this;
    }
75179
public function getBasicValueForArrayProperty(PropertyDefinition $propertyDefinition, $rawValue)
	{
		if (!$propertyDefinition->getIsArray() || !is_array($rawValue)) {
			return [];
		}

		$values = [];

		foreach ($rawValue as $rawValueItem) {

			if ($propertyDefinition->getType() == PropertyDefinition::BASIC_TYPE_INTEGER) {
				if (is_numeric($rawValueItem) || is_bool($rawValueItem) || is_string($rawValueItem)) {
					$values[] = intval($rawValueItem);
				}

			} else if ($propertyDefinition->getType() == PropertyDefinition::BASIC_TYPE_FLOAT) {
				if (is_numeric($rawValueItem) || is_bool($rawValueItem) || is_string($rawValueItem)) {
					$values[] = floatval($rawValueItem);
				}
			} else if ($propertyDefinition->getType() == PropertyDefinition::BASIC_TYPE_STRING) {
				if (!is_array($rawValueItem) && !is_object($rawValueItem)) {
					$values[] = strval($rawValueItem);
				}
			} else if ($propertyDefinition->getType() == PropertyDefinition::BASIC_TYPE_BOOLEAN) {
				if (!is_array($rawValueItem) && !is_object($rawValueItem)) {
					$values[] = boolval($rawValueItem);
				}
			} else {
				// skip this value
			}
		}

		return $values;
	}
710040
public RawProperty getExperimentalProperty(String name) {
		for (RawProperty raw : getExperimentalProperties()) {
			if (raw.getName().equalsIgnoreCase(name)) {
				return raw;
			}
		}
		return null;
	}
361506
public function getProperty($name)
    {
        if (!$this->hasProperty($name)) {
            return;
        }

        if (strstr($name, '.')) {
            $value = false;
            @eval('$value = '.$this->resolveArrayPath($name).';');

            return $value;
        }

        if ($this->isArray()) {
            return $this->object[$name];
        } else {
            return $this->object->$name;
        }
    }
425478
protected function getPropertyValue($object, string $propertyName, $default = null)
    {
        if (!is_object($object)) {
            throw new InvalidArgumentException('The first argument should be an object');
        }

        if (!property_exists($object, $propertyName)) {
            return $default;
        }

        try {
            $reflectionProperty = new ReflectionProperty($object, $propertyName);
            $reflectionProperty->setAccessible(true);

            return $reflectionProperty->getValue($object);
        } catch (ReflectionException $e) {
            return $default;
        }
    }
155392
public function get($name, $raw = false)
	{
		// Build the request path.
		$path = '/gitignore/templates/' . $name;

		$headers = array();

		if ($raw)
		{
			$headers['Accept'] = 'application/vnd.github.raw+json';
		}

		$response = $this->client->get($this->fetchUrl($path), $headers);

		// Validate the response code.
		if ($response->code != 200)
		{
			// Decode the error response and throw an exception.
			$error   = json_decode($response->body);
			$message = isset($error->message) ? $error->message : 'Invalid response received from GitHub.';

			throw new UnexpectedResponseException($response, $message, $response->code);
		}

		return ($raw) ? $response->body : json_decode($response->body);
	}
1159434
public function get($name)
    {
        $name = $this->cleanAttributeName($name);

        return isset($this->props[$name]) ? $this->props[$name] : null;
    }
1102592
public function getPropertyByName($name)
    {
        foreach ($this->properties as $property) {
            if ($property->getName() === $name) {
                return $property;
            }
        }
    }
97054
public function get_header($name, $raw = false)
    {
        if (empty($this->headers)) {
            return null;
        }

        return $this->headers->get($name, !$raw);
    }
65401
public function getValue($name = 'key')
    {
        if (!isset($this->rawData[$name])) {
            return null;
        }

        return $this->rawData[$name];
    }
213745
public function get($propertyName)
    {
        return isset($this->result[$propertyName]) ? $this->result[$propertyName][1] : null;
    }
887632
protected function getPropertyValue($propertyName) {

		$originalValue = ObjectAccess::getProperty($this, $propertyName);

		if ($originalValue instanceof UriPointer) {
			/*
			 * UriPointer objects need to be transformed into the actual URI. Since this relies on
			 * an UriBuilder being bound to a \Neos\Flow\Http\Request object, this is no
			 * simple task at all without having a proper controller context.
			 * Only for the purpose of validation and change tracking we do this. Every other use
			 * case for UriPointer objects should make use of the surrounding controllers UriBuilder.
			 */
			return self::getUriForUriPointer($originalValue);
		}

		return $originalValue;
	}
1252110
public function get($name)
    {
        $lowerName = strtolower($name);
        if (isset($this->properties[$lowerName])) {
            return $this->properties[$lowerName];
        }
        throw new \InvalidArgumentException(
            "Undefined property: $name (Node ID: ".$this->properties['id'].')'
        );
    }