Set a property value directly.

@return class instance
348457
public function set($key = null, $value = null)
    {
        $this->getObject()->set($key, $value);

        return $this;
    }
355222
public function build(): SetKeyframeKeyRequest
	{
		$instance = new SetKeyframeKeyRequest();
		if ($this->styleSheetId === null) {
			throw new BuilderException('Property [styleSheetId] is required.');
		}
		$instance->styleSheetId = $this->styleSheetId;
		if ($this->range === null) {
			throw new BuilderException('Property [range] is required.');
		}
		$instance->range = $this->range;
		if ($this->keyText === null) {
			throw new BuilderException('Property [keyText] is required.');
		}
		$instance->keyText = $this->keyText;
		return $instance;
	}
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;
    }
1358479
public function property()
    {
        if ($this->property === null) {
            $this->property = $this->createProperty();
        }

        return $this->property;
    }
6293
protected function setPropertyValue($reflection, $classInstance, $classProperty, $object)
    {
        /*
         | We will make property accessible and set the value into it
         */
        $reflection->makePropertyAccessible($classProperty);
        $reflectionProperty = $reflection->getReflectionProperty();
        $reflectionProperty->setValue($classInstance, $object);
    }
382901
final public static function values()
    {
        $class = get_called_class();

        if (!isset(self::$values[$class])) {
            self::$values[$class] = (new \ReflectionClass($class))->getConstants();
        }

        return self::$values[$class];
    }
606259
public function setValue($value = null)
    {
        if ($value && !($value instanceof \Countable && 0 === count($value))) { // empty or empty collection
            // store into temporary variable
            $this->entityData = $value;

            // store into database format
            if (is_array($value) || $value instanceof \ArrayAccess) {
                // this is the case if multiple = true
                $saveValue = array();
                $saveClass = null;
                foreach ($value as $val) {
                    $saveValue[] = $val->getId();
                    $saveClass = ClassUtils::getClass($val); // only the last class type is stored. We assume that it's the same anyway
                }
            } else {
                // this is the case if multiple = false
                $saveValue = $value->getId();
                $saveClass = ClassUtils::getClass($value);
            }
            if ($saveClass) {
                $this->entityValue = array(
                    'entityClass' => $saveClass,
                    'entityId' => $saveValue,
                );
            } else {
                $this->entityValue = null;
            }
        } else {
            $this->entityValue = null;
            $this->entityData = null;
        }

        return $this;
    }
147157
def set_property(self, prop, value):
        """"""
        cmd_url = 'ctrl-int/1/setproperty?{}={}&[AUTH]'.format(
            prop, value)
        return self.daap.post(cmd_url)
1106241
public function setValue($value) : self
    {
        if (is_bool($value)) {
            $value = ($value == true) ? '1' : '0';
        }

        $this->field->addAttribute('value', !is_null($value) ? (string) $value : '');

        return $this;
    }
1176206
public function setProperty($property, $value)
    {
        if (property_exists($this, $property) && $property !== 'form') {
            $this->$property = $value;
        }
        return $this;
    }
600179
private function createProperty()
    {
        $propType = $this->propertyType();
        if (empty($propType)) {
            $ident = $this->propertyIdent();
            if ($ident && is_string($ident)) {
                $message = sprintf('Missing property type for property "%s"', $ident);
            } else {
                $message = sprintf('Missing property type');
            }
            throw new UnexpectedValueException($message);
        }

        $prop = $this->propertyFactory()->create($propType);

        $prop->setIdent($this->propertyIdent());
        $prop->setData($this->propertyData());

        return $prop;
    }
363288
public function set(string $property, $data = null): self
    {
        $this->data[$property] = $data;

        return $this;
    }
254157
public function unsetValue() {
		if ($this->isOrphan()) {
			if ($this->orphanType == "publicproperty") {
				return $this->moufManager->unsetParameter($this->instanceDescriptor->getIdentifierName(), $this->name);
			} elseif ($this->orphanType == "setter") {
				return $this->moufManager->unsetParameterForSetter($this->instanceDescriptor->getIdentifierName(), $this->name);
			} elseif ($this->orphanType == "constructorargument") {
				return $this->moufManager->unsetParameterForConstructor($this->instanceDescriptor->getIdentifierName(), $this->name);
			} else {
				throw new MoufException("Unsupported orphan type: it is not a public field nor a setter nor a constructor...");
			}
		}
		
		if ($this->propertyDescriptor->isPublicFieldProperty()) {
			return $this->moufManager->unsetParameter($this->instanceDescriptor->getIdentifierName(), $this->name);
		} elseif ($this->propertyDescriptor->isSetterProperty()) {
			return $this->moufManager->unsetParameterForSetter($this->instanceDescriptor->getIdentifierName(), $this->name);
		} elseif ($this->propertyDescriptor->isConstructor()) {
			return $this->moufManager->unsetParameterForConstructor($this->instanceDescriptor->getIdentifierName(), $this->propertyDescriptor->getParameterIndex());
		} else {
			throw new MoufException("Unsupported property type: it is not a public field nor a setter nor a constructor...");
		}
	}
1069760
public function setValue($new_value) {
    if (gettype($new_value) !== 'object') {
      return parent::setValue($new_value);
    }

    $new_props = $this->getSetProps($new_value);

    foreach ($new_props as $new_prop) {
      $this->setProp($new_prop, $new_value->{$new_prop});
    }

    return $this;
  }
180132
public function setValue($value) {
		if ($value instanceof \ArrayObject)
			$this->value = $value->getArrayCopy();
		elseif (is_object($value))
			$this->value = get_object_vars($value);
		elseif (is_array($value))
			$this->value = $value;
		else
			throw new \InvalidArgumentException("Method 'setValue' expected an object or array value");
		
		return $this;
	}
1105673
protected function setProperties()
    {
        // Fetch request query string values passed by an API client.
        list($limit, $offset) = $this->paramBag->get('limit');
        list($sortKey, $sortDirection) = $this->paramBag->get('sort');

        // If nothing is passed by API client,
        // falling back to class property's value.
        $this->limit = $limit ?: $this->limit;
        $this->offset = $offset ?: $this->offset;
        $this->sortKey = $sortKey ?: $this->sortKey;
        $this->sortDirection = $sortDirection ?: $this->sortDirection;
    }
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;
	}