This notifies the embeddable properties on the owning Entity

@param string      $embeddablePropertyName
@param null|string $propName
@param null        $oldValue
@param null        $newValue
494889
public function notifyEmbeddablePrefixedProperties(
        string $embeddablePropertyName,
        ?string $propName = null,
        $oldValue = null,
        $newValue = null
    ): void {
        if ($oldValue !== null && $oldValue === $newValue) {
            return;
        }
        /**
         * @var ClassMetadata $metaData
         */
        $metaData = self::getDoctrineStaticMeta()->getMetaData();
        foreach ($metaData->getFieldNames() as $fieldName) {
            if (true === \ts\stringStartsWith($fieldName, $embeddablePropertyName)
                && false !== \ts\stringContains($fieldName, '.')
            ) {
                if ($fieldName !== null && $fieldName !== "$embeddablePropertyName.$propName") {
                    continue;
                }
                foreach ($this->notifyChangeTrackingListeners as $listener) {
                    //wondering if we can get away with not passing in the values?
                    $listener->propertyChanged($this, $fieldName, $oldValue, $newValue);
                }
            }
        }
    }
1166470
public void setProperty(Object object, String property, Object newValue) {
        setProperty(theClass, object, property, newValue, false, false);
    }
727812
public static void setProperty(String propertyName, String propertyValue) {
		try {
			FreeMarkerRender.getConfiguration().setSetting(propertyName, propertyValue);
		} catch (TemplateException e) {
			throw new RuntimeException(e);
		}
	}
261327
public static void setGroovyObjectProperty(Object newValue, GroovyObject object, String property) {
        object.setProperty(property, newValue);
    }
1164008
private function onPropertyChanged($name, $oldValue, $newValue)
    {
        foreach ($this->listeners as $listener) {
            $listener->propertyChanged($this, $name, $oldValue, $newValue);
        }
    }
159110
public function set($propName, $propValue)
    {
        $this->validateProp($propName);

        $this->getTsPropObj($propName)->setValue($propValue);

        return $this;
    }
705966
protected function getDecodedValueForProp($propName, $propValue)
    {
        if (in_array($propName, $this->propTypes['string'])) {
            // Strip away null terminators. I think this should be desired, otherwise it just ends in confusion.
            $value = str_replace("\0", '', $this->decodePropValue($propValue, true));
        } elseif (in_array($propName, $this->propTypes['time'])) {
            // Convert from microseconds to minutes (how ADUC displays it anyway, and seems the most practical).
            $value = hexdec($this->decodePropValue($propValue)) / self::TIME_CONVERSION;
        } elseif (in_array($propName, $this->propTypes['int'])) {
            $value = hexdec($this->decodePropValue($propValue));
        } else {
            $value = $this->decodePropValue($propValue);
        }

        return $value;
    }
1340573
protected final void firePrimitiveChanged(String propertyName, Object oldValue, Object newValue) {
		final BusChangeEvent event = new BusChangeEvent(
				// source of the event
				this,
				// type of the event
				BusChangeEventType.change(getClass()),
				// subobject
				this,
				// index in parent
				indexInParent(),
				propertyName,
				oldValue,
				newValue);
		firePrimitiveChanged(event);
	}
470514
public boolean setPropertyValue(String propName, String value) {
        if (OVERRIDE_ACTIVE) {
            return true;
        }

        System.setProperty(propName, value);
        return true;
    }
1205182
public HalResource renameEmbedded(String relToRename, String newRel) {
    List<HalResource> resources = getEmbedded(relToRename);
    return removeEmbedded(relToRename).addEmbedded(newRel, resources);
  }
745356
public function newProperty(string $propertyName, bool $enableGet, bool $enableSet): void
    {
        if ($this->propertyExists($propertyName)) {
            throw new DuplicatePropertyException($propertyName);
        }
        if (!$enableGet && !$enableSet) {
            throw new InvalidPropertyException($propertyName);
        }
        $this->properties[$propertyName] = self::PROPERTY_REAL;
        $this->realGetAvailable[$propertyName] = $enableGet;
        $this->realSetAvailable[$propertyName] = $enableSet;
        $this->setterHooks[$propertyName] = [];
        $this->getterHooks[$propertyName] = [];
    }
1279523
public function assignValue ( $propNameOrig, $propValue ) {
        $propNameA = str_replace( self::$replaceChars, '_', $propNameOrig );
        $propName = preg_replace( "/[^A-Za-z0-9_]/", "", $propNameA );
        if (property_exists( $this, $propName ) && $this->$propName !== NULL) {
            $this->assignExisting( $propName, $propValue );
        } elseif ($propName !== '') {
            $this->$propName = $propValue;
        }
    }
687130
public function setDocumentProperty($propertyName = '', $propertyValue = '')
    {

        if ($propertyName == '')
            throw new Exception('Property name not specified');

        //build URI to replace image
        $strURI = Product::$baseProductUri . '/pdf/' . $this->getFileName() . '/documentProperties/' . $propertyName;

        $putArray['Value'] = $propertyValue;
        $json = json_encode($putArray);

        //sign URI
        $signedURI = Utils::sign($strURI);
        $responseStream = Utils::processCommand($signedURI, 'PUT', 'json', $json);

        $response_arr = json_decode($responseStream);

        return $response_arr->DocumentProperty;
    }
667672
public function nodePropertyChanged(NodeInterface $node, $propertyName, $oldValue, $value)
    {
        if (!$this->eventEmittingService->isEnabled()) {
            return;
        }

        if ($oldValue === $value) {
            return;
        }

        $this->changedNodes[$node->getContextPath()]['newLabel'] = $node->getLabel();
        $this->changedNodes[$node->getContextPath()]['node'] = $node;
    }
785145
protected function checkDynamicAttributes(DOMElement $embed)
	{
		$settingName = strtolower($this->settingName);
		foreach ($embed->getElementsByTagNameNS(self::XMLNS_XSL, 'attribute') as $attribute)
		{
			$attrName = strtolower($attribute->getAttribute('name'));
			if ($attrName === $settingName)
			{
				throw new UnsafeTemplateException('Cannot assess the safety of dynamic attributes', $attribute);
			}
		}
	}
829911
function canBeSubtag ($propName)
  {
    if ($this->defines ($propName)) {
      $type = $this->getTypeOf ($propName);
      switch ($type) {
        case type::content:
        case type::collection:
        case type::metadata:
        case type::string:
        case type::number:
          return true;
      }
    }
    return false;
  }
35105
private function setEntityAndNotify(string $propName, ?EntityInterface $entity): void
    {
        if ($this->$propName === $entity) {
            return;
        }
        $oldValue        = $this->$propName;
        $this->$propName = $entity;
        foreach ($this->notifyChangeTrackingListeners as $listener) {
            $listener->propertyChanged($this, $propName, $oldValue, $entity);
        }
    }