Defines an embedded value object collection property.

@param string $property

@return EmbeddedCollectionDefiner
@throws InvalidArgumentException
6064
public function embeddedCollection(string $property): EmbeddedCollectionDefiner
    {
        $this->verifyProperty(__METHOD__, $property);

        return $this->relation($property)->asEmbedded()->collection();
    }
1291775
final protected static function get_property_default_value($property) {
        $properties = static::properties_definition();
        if (!isset($properties[$property]['default'])) {
            return null;
        }
        $value = $properties[$property]['default'];
        if ($value instanceof \Closure) {
            return $value();
        }
        return $value;
    }
305621
public function get($property)
    {
        if (!array_key_exists($property, $this->data)) {
            throw new InvalidArgumentException(sprintf('Property %s does not exist', $property));
        }

        return $this->data[$property];
    }
500556
protected function getPropertyValue(string $property) : ?string
    {
        // For now, all unprefixed variables are also runtime variables.  If that ever changes this
        // logic will change with it.
        $isBuildVar = in_array($property, array_keys($this->directVariables));
        $isRuntimeVar = in_array($property, array_keys($this->directVariablesRuntime));
        $isUnprefixedVar = in_array($property, array_keys($this->unPrefixedVariablesRuntime));

        if ($isBuildVar) {
            $value = $this->getValue($this->directVariables[$property]);
        }
        else if ($isUnprefixedVar) {
            $value = $this->environmentVariables[$this->unPrefixedVariablesRuntime[$property]] ?? null;
        }
        else if ($isRuntimeVar) {
            $value = $this->getValue($this->directVariablesRuntime[$property]);
        }
        else {
            $value = null;
        }

        return $value;
    }
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);
    }
528370
public function addIdentifyingProperty($property)
    {
        if ($property->isSerializable()) {
            $this->_identifying_properties[$property->getName()] = $property;
        }

        //the proeprty as required
        $property->setRequired(true);

        return $this;
    }
655026
protected function setIfDefined($object, $field)
    {
        $propertyAccessor = $this->getPropertyAccessor();
        if (!$this->_has($field)) {
            return $propertyAccessor->isReadable($object, $field) ?
                $propertyAccessor->getValue($object, $field) :
                null
            ;
        }

        $propertyAccessor->setValue(
            $object,
            $field,
            $value = $this->_get($field)
        );

        return $value;
    }
702440
public function set($property, $value = null)
	{
		if (is_array($property))
		{
			foreach ($property as $p => $v)
			{
				$this->set($p, $v);
			}
			return $this;
		}

		$this->values[$property] = $value;

		return $this;
	}
1246900
public function setPropertyValues($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]->setProperty($property,$value);
			}
			else{
				return $this;
			}
		}
		return $this;
	}
1114216
public function relation(string $property): RelationUsingDefiner
    {
        $this->verifyProperty(__METHOD__, $property);

        $accessor = new PropertyAccessor($this->class->getClassName(), $this->class->getProperty($property));

        return $this->defineRelationVia($accessor, function () use ($property) {
            $this->mappedProperties[$property] = true;
        });
    }
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];
    }
978097
protected function valPropStructure($property)
    {
        // If the property object is invalid
        if (!is_object($property) || !$this->valPropProperties($property)) {
            throw new InvalidArgumentException(
                InvalidArgumentException::INVALID_PROPERTY_STR,
                InvalidArgumentException::INVALID_PROPERTY
            );
        }
    }
711423
public function set($property, $value)
    {
        // we need to convert booleans into string, because these are query parameters
        if (is_bool($value)) {
            $value = $value
                ? 'true'
                : 'false';
        }

        $this->container[$property] = $value;

        return $this;
    }
70729
public function getEmbeddedDiscriminatorValue(PropertyMetadata $mapping, $embeddedDocument)
    {
        if (!$mapping->embedded || get_class($embeddedDocument) !== $this->name) {
            throw new \InvalidArgumentException;
        }

        if ($mapping->targetDocument !== null) {
            return null;
        }

        $discriminatorMetadata = $this->getPropertyMetadata($mapping->discriminatorAttribute);
        $discriminatorValue    = $discriminatorMetadata->getValue($embeddedDocument);

        if ($discriminatorValue === null) {
            if ($discriminatorMetadata->discriminatorDefaultValue === null) {
                return null;
            }

            $discriminatorValue = $discriminatorMetadata->discriminatorDefaultValue;
        }

        if (isset($discriminatorMetadata->discriminatorMap[$discriminatorValue])) {
            return $discriminatorMetadata->discriminatorMap[$discriminatorValue];
        }

        return $discriminatorValue;
    }
1033737
public function &get($property)
    {
        if (!strlen((string)$property)) {
            throw new InvalidArgumentException('Cannot get an empty property');
        }

        $value = null;
        $method = static::_accessor($property, 'get');

        if (isset($this->_properties[$property])) {
            $value =& $this->_properties[$property];
        }

        if ($method) {
            $result = $this->{$method}($value);

            return $result;
        }

        return $value;
    }
588373
public function unassign($property)
	{
		if (null === $this->object)
		{
			$this->object = new Object;
		}

		$this->object->unassign($property);

		return $this;
	}
1043963
protected function get($property) {
        $mapping = $this->dao()->getMapping();

        if (isset($mapping['properties'][$property]))
            return $this->getNonRelationValue($property);

        if (isset($mapping['relations'][$property]))
            return $this->getRelationValue($property);

        throw new RuntimeException('Not a mapped property "'.$property.'"');
    }