@param string $property

@return ValueInterface
771305
public function get($property)
    {
        if ('' === $property) {
            $property = '_empty_';
        }
        if (!$this->has($property)) {
            throw new Exception\UndefinedKeyException($property);
        }

        return $this->value->$property;
    }
453156
public function formatPropertyValue($value, string $property) : string
    {
        $valueOutput = (string) $value;

        switch ($this->propertyHolder->getPropertyType($property)) {
            case PropertyHolder::TYPE_STRING:
                $valueOutput = trim((string) $value);

                break;
            case PropertyHolder::TYPE_BOOLEAN:
                if (true === $value || 'true' === $value) {
                    $valueOutput = 'true';
                } elseif (false === $value || 'false' === $value) {
                    $valueOutput = 'false';
                } else {
                    $valueOutput = '';
                }

                break;
            case PropertyHolder::TYPE_IN_ARRAY:
                try {
                    $valueOutput = $this->propertyHolder->checkValueInArray($property, (string) $value);
                } catch (\InvalidArgumentException $ex) {
                    $valueOutput = '';
                }

                break;
            default:
                // nothing t do here
                break;
        }

        if ('unknown' === $valueOutput) {
            $valueOutput = '';
        }

        return '"' . str_replace('"', '""', $valueOutput) . '"';
    }
646852
public static function sanitizeValue(PropertyInterface $property, $value)
    {
        // If value empty, then override with empty value in property (if it has any).
        if (empty($value)
            && ($property instanceof EmptyValueAwarePropertyInterface)
            && $property->hasEmptyValue()
        ) {
            return $property->getEmptyValue();
        }

        return $value;
    }
593485
private function getValue($object, $property)
    {
        if (is_array($object)) {
            if (!isset($object[$property]) && 0 === strpos($property, 'get')) {
                $property = lcfirst(substr($property, 3));

            }

            return isset($object[$property]) ? $object[$property] : null;
        }

        $getter = 0 === strpos($property, 'get') ? $property : 'get' . ucfirst($property);

        if (method_exists($object, $getter)) {
            return call_user_func([$object, $getter]);
        }

        $reflection = new \ReflectionProperty(get_class($object), $property);
        $reflection->setAccessible(true);

        return $reflection->getValue($object);
    }
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;
    }
576065
private function getPropertyValue(array $property, $className = Entity::class)
    {
        $type = $this->getValueType($property);
        return $this->convertValue($type, $property[$type], $className);
    }
1339558
public function getOriginal($property)
    {
        if (!strlen((string)$property)) {
            throw new InvalidArgumentException('Cannot get an empty property');
        }
        if (array_key_exists($property, $this->_original)) {
            return $this->_original[$property];
        }

        return $this->get($property);
    }
1212310
public function getPropertyValue($property) {

        if (FALSE !== strstr($property, '.')) {
            $property = explode('.', $property);
        } else {
            $property = [$property];
        }

        if (count($property) == 1) {
            return $this
                ->getProperty($property[0])
                ->getValue($this->instance);
        }

        $classMapper = $this;
        foreach ($property as $item) {
            $value = $classMapper
                ->getProperty($item)
                ->getValue($classMapper->instance);

            if (is_object($value)) {
                $classMapper = $classMapper::createFromInstance($value);
            }
        }

        return $value;
    }
661541
public function setProperty($property)
    {
        $this->_properties[$property->getName()] = $property;

        //if property name is the same as the identity property
        //then set the identity property
        if (
            is_string($this->_identity_property) &&
            $property->getName() == $this->_identity_property
        ) {
            $this->setIdentityProperty($property);
        }

        return $this;
    }
25544
public function &offsetGet($property)
	{
		$null = null;
		
		if(array_key_exists($property, $this->list))
			return $this->list[$property];
		
		return $null;
	}
147848
public function removeProperty($property)
    {
        $property = $this->resolvePropertyName($property);
        unset($this->properties[$property]);
        return $this;
    }
1070678
protected function getValue($object, $property)
    {
        if (isset($object->{$property})) {
            return $object->{$property};
        }

        $reflectionClass = new ReflectionClass($object);

        if (!$reflectionClass->hasProperty($property)) {
            return null;
        }

        $reflectionProperty = $reflectionClass->getProperty($property);
        $reflectionProperty->setAccessible(true);

        return $reflectionProperty->getValue($object);
    }
950660
public function get(string $property)
    {
        $properties = explode('.', $property);
        $value = $this->rawConfig;

        foreach ($properties as $property) {
            if (!array_key_exists($property, $value)) {
                return null;
            }

            $value = $value[$property];
        }

        return $value;
    }
809551
private function getValue(PropertyInterface $property)
    {
        $default = ['presentAs' => null, 'items' => []];
        if (!is_array($property->getValue())) {
            return $default;
        }

        return array_merge($default, $property->getValue());
    }
756003
public function addPropertyValues($property,$values){
		if(\is_array($values)===false){
			$values=\array_fill(0, $this->count(),$values);
		}
		foreach ($values as $i=>$value){
			if(isset($this->content[$i])){
				$this->content[$i++]->addToProperty($property,$value);
			}
			else{
				return $this;
			}
		}
		return $this;
	}
164519
public static function getPropertyValue($object, $property)
    {
        $ref = new \ReflectionClass($object);
        $prop = static::getPrivateProperty($ref, $property);
        $prop->setAccessible(true);
        $value = $prop->getValue($object);
        $prop->setAccessible(false);

        return $value;
    }
1064289
protected function createConstraints(
        $property,
        Value\ConcreteValueInterface $value
    ) {
        switch ($property) {
            // generic constraints
            case 'enum':
                return array($this->createEnumConstraint($value));
            case 'type':
                return array($this->createTypeConstraint($value));
            case 'allOf':
                return array($this->createAllOfConstraint($value));
            case 'anyOf':
                return array($this->createAnyOfConstraint($value));
            case 'oneOf':
                return array($this->createOneOfConstraint($value));
            case 'not':
                return array($this->createNotConstraint($value));

            // object constraints
            case 'maxProperties':
                return array($this->createMaximumPropertiesConstraint($value));
            case 'minProperties':
                return array($this->createMinimumPropertiesConstraint($value));
            case 'required':
                return $this->createRequiredConstraints($value);
            case 'dependencies':
                return $this->createDependencyConstraints($value);

            // array constraints
            case 'maxItems':
                return array($this->createMaximumItemsConstraint($value));
            case 'minItems':
                return array($this->createMinimumItemsConstraint($value));
            case 'uniqueItems':
                return array($this->createUniqueItemsConstraint($value));

            // string constraints
            case 'maxLength':
                return array($this->createMaximumLengthConstraint($value));
            case 'minLength':
                return array($this->createMinimumLengthConstraint($value));
            case 'pattern':
                return array($this->createPatternConstraint($value));

            // number constraints
            case 'multipleOf':
                return array($this->createMultipleOfConstraint($value));

            // date-time constraints
            case 'maxDateTime':
                return array($this->createMaximumDateTimeConstraint($value));
            case 'minDateTime':
                return array($this->createMinimumDateTimeConstraint($value));

            // format constraints
            case 'format':
                $constraint = $this->formatConstraintFactory()->create($value->value());
                if (null === $constraint) {
                    return array();
                }

                return array($constraint);
        }

        return array();
    }