Updates each value of <em>existing</em> element, using the value(s) of <em>update</em>.

@param update   BioPAX element of which values are used for update
@param existing BioPAX element to be updated
@param target
343314
private void updateObjectFields(BioPAXElement update,
	                                BioPAXElement existing, Model target)
	{
		Set<PropertyEditor> editors =
				map.getEditorsOf(update);
		for (PropertyEditor editor : editors)
		{
			updateObjectFieldsForEditor(editor, update, existing, target);
		}

//		if (!update.getUri().equals(existing.getUri()))
//		{
//TODO addNew a unification xref
//			if(existing instanceof XReferrable)
//			{
//				((XReferrable) existing).addXref(fa);
//			}
//		}
	}
216526
def update_target(self, name, current, total):
        """"""
        self.refresh(self._bar(name, current, total))
1223218
private void updateDelegate()
	{
		T parentValue = parent.getValue();
		
		Observable<U> child = childFactory.createObservable(parentValue);
		
		if (child == null)
		{
			child = Observables.nullObservable();
		}
		
		setDelegate(child);
	}
1302522
public void update(final List<Long> groupTargetCounts, final Long totalTargetCount) {
        this.groupTargetCounts = groupTargetCounts;
        this.totalTargetCount = totalTargetCount;

        if (groupTargetCounts != null) {
            long sum = 0;
            for (Long targetCount : groupTargetCounts) {
                sum += targetCount;
            }
            unassignedTargets = totalTargetCount - sum;
        }

        draw();

    }
248032
public static void set(Object target, Field field, Object value)
    {
        if (target != null)
        {
            if (!field.isAccessible())
            {
                field.setAccessible(true);
            }
            try
            {
                field.set(target, value);
            }
            catch (IllegalArgumentException iarg)
            {
                throw new PropertyAccessException(iarg);
            }
            catch (IllegalAccessException iacc)
            {
                throw new PropertyAccessException(iacc);
            }
        } // ignore if object is null;
    }
1080403
static final void hipAndKxQIncrementalUpdate(final AbstractHllArray host, final int oldValue,
      final int newValue) {
    assert newValue > oldValue;
    final int configK = 1 << host.getLgConfigK();
    //update hipAccum BEFORE updating kxq0 and kxq1
    double kxq0 = host.getKxQ0();
    double kxq1 = host.getKxQ1();
    host.addToHipAccum(configK / (kxq0 + kxq1));
    //update kxq0 and kxq1; subtract first, then add.
    if (oldValue < 32) { host.putKxQ0(kxq0 -= invPow2(oldValue)); }
    else               { host.putKxQ1(kxq1 -= invPow2(oldValue)); }
    if (newValue < 32) { host.putKxQ0(kxq0 += invPow2(newValue)); }
    else               { host.putKxQ1(kxq1 += invPow2(newValue)); }
  }
26029
@Override
  public void update(final long value) {
    count.incrementAndGet();
    int index = (int) (value / binWidth);
    if (index >= numBins) {
      index = numBins - 1;
    }
    values.incrementAndGet(index);
  }
631203
public void updateFixture(final String uuid, final Consumer<FixtureResult> update) {
        final Optional<FixtureResult> found = storage.getFixture(uuid);
        if (!found.isPresent()) {
            LOGGER.error("Could not update test fixture: test fixture with uuid {} not found", uuid);
            return;
        }
        final FixtureResult fixture = found.get();

        notifier.beforeFixtureUpdate(fixture);
        update.accept(fixture);
        notifier.afterFixtureUpdate(fixture);
    }
738425
public void _updateXYImpl(boolean bExact) {
		m_envelope.setEmpty();
		AttributeStreamOfDbl stream = (AttributeStreamOfDbl) m_vertexAttributes[0];
		Point2D pt = new Point2D();
		for (int i = 0; i < m_pointCount; i++) {
			stream.read(2 * i, pt);
			m_envelope.merge(pt);
		}
	}
354064
def _updateTargetFromNode(self):
        
        self.viewBox.setAspectLocked(lock=self.configValue, ratio=self.aspectRatioCti.configValue)
259964
public void setValue(final Object targetObj, final Object value) {
        ArgUtils.notNull(targetObj, "targetObj");
        
        if(targetSetter.isPresent()) {
            try {
                targetSetter.get().invoke(targetObj, value);
            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                throw new FieldAccessException(this, "fail setter value", e);
            }
            
        } else if(targetField.isPresent()) {
            try {
                targetField.get().set(targetObj, value);
                
            } catch (IllegalArgumentException | IllegalAccessException e) {
                throw new FieldAccessException(this, "fail setter field value", e);
            }
            
        } else {
            throw new FieldAccessException(this, "not found setter method or field.");
        }
    }
662022
void apply(UpdateableSegmentMetadata target) {
        if (!this.isChanged) {
            // No changes made.
            return;
        }

        Preconditions.checkArgument(target.getId() == this.id,
                "Target Segment Id mismatch. Expected %s, given %s.", this.id, target.getId());
        Preconditions.checkArgument(target.getName().equals(this.name),
                "Target Segment Name mismatch. Expected %s, given %s.", name, target.getName());

        // Apply to base metadata.
        target.setLastUsed(this.lastUsed);
        target.updateAttributes(this.attributeUpdates);
        target.setLength(this.length);

        // Update StartOffset after (potentially) updating the length, since he Start Offset must be less than or equal to Length.
        target.setStartOffset(this.startOffset);
        if (this.storageLength >= 0) {
            // Only update this if it really was set. Otherwise we might revert back to an old value if the Writer
            // has already made progress on it.
            target.setStorageLength(this.storageLength);
        }

        if (this.sealed) {
            target.markSealed();
            if (this.sealedInStorage) {
                target.markSealedInStorage();
            }
        }

        if (this.merged) {
            target.markMerged();
        }

        if (this.deleted) {
            target.markDeleted();
            if (this.deletedInStorage) {
                target.markDeletedInStorage();
            }
        }

        if (this.pinned) {
            target.markPinned();
        }
    }
264309
private void updateObjectFields(BioPAXElement source, Model target)
	{
		//Skip if target model had a different object with the same URI as the source's,
		//and no Filter was set (mergePropOf is null); i.e., when
		//we simply want the source to be replaced with the object
		//having the same type and URI and that's already present in the target model.
		BioPAXElement keep = target.getByID(source.getUri());
		if(keep != source && mergePropOf ==null)
		{
			return; //nothing to do
		}
		
		Set<PropertyEditor> editors = map.getEditorsOf(source);
		for (PropertyEditor editor : editors)
		{
			if (editor instanceof ObjectPropertyEditor)
			{
				//copy prop. values (to avoid concurrent modification exception)
				Set<BioPAXElement> values = new HashSet<BioPAXElement>((Set<BioPAXElement>) editor.getValueFromBean(source));
				if(keep == source) //i.e., it has been just added to the target, - simply update properties
				{
					for (BioPAXElement value : values) {
						migrateToTarget(source, target, editor, value);
					}
				} else //source is normally to be entirely replaced, but if it passes the filter,
					if(mergePropOf !=null && mergePropOf.filter(source)
						&& editor.isMultipleCardinality()) // and the prop. is multi-cardinality,
				{
					// - then we want to copy some values
					for (BioPAXElement value : values) {
						mergeToTarget(keep, target, editor, value);
					}
				}

			}
			else // - primitive, enum, or string property editor (e.g., comment, name), and -
				if (mergePropOf != null && mergePropOf.filter(source) && editor.isMultipleCardinality())
			{
				Set<Object> values = new HashSet<Object>((Set<Object>) editor.getValueFromBean(source));
				for (Object value : values) {
					mergeToTarget(keep, target, editor, value);
				}
			}
		}
	}
1268202
public static <OriginObject, TargetObject> void append(OriginObject originObject, TargetObject targetObject) {
        if (originObject == null) {
            return;
        }
        if (targetObject == null) {
            throw new IllegalArgumentException("targetClass can't be null");
        }
        @SuppressWarnings("unchecked")
        Class<TargetObject> targetClass = (Class<TargetObject>) targetObject.getClass();
        setValue(originObject, targetObject, targetClass);

    }
348959
public void setTarget(java.lang.String target) {
        getStateHelper().put(PropertyKeys.target, target);
    }
365409
public function updateTarget(Target $target): void
    {
        $query = $this->connection->createQueryBuilder();
        $query
            ->update('ngbm_rule_target')
            ->set('rule_id', ':rule_id')
            ->set('type', ':type')
            ->set('value', ':value')
            ->where(
                $query->expr()->eq('id', ':id')
            )
            ->setParameter('id', $target->id, Type::INTEGER)
            ->setParameter('rule_id', $target->ruleId, Type::INTEGER)
            ->setParameter('type', $target->type, Type::STRING)
            ->setParameter('value', $target->value, is_array($target->value) ? Type::JSON_ARRAY : Type::STRING);

        $this->applyStatusCondition($query, $target->status);

        $query->execute();
    }
343521
protected void set(PofValue target, Object value) {
        navigator.navigate(target).setValue(value);
    }