Updates <em>existing</em>, using the <em>updateValue</em> by the editor.

@param editor      editor for the specific value to be updated
@param updateValue the value for the update
@param existing    BioPAX element to be updated
@param target
424203
private void updateField(PropertyEditor editor, Object updateValue,
	                         BioPAXElement existing, Model target)
	{
		if (updateValue instanceof BioPAXElement)
		{
			BioPAXElement bpe = (BioPAXElement) updateValue;
			//Now there are two possibilities


			BioPAXElement ibpe = target.getByID(bpe.getUri());
			//1. has an identical in the target
			if (ibpe != null)
			{
				updateValue = ibpe;
			}
			//2. it has no identical in the target
			//I do not have to do anything as it will eventually
			//be moved.

		}
		editor.setValueToBean(updateValue, existing);
	}
276193
@SuppressWarnings({"rawtypes", "unchecked"})
  public void initializeEditors(final Object editor) {
    if (editor instanceof HasValueChangeHandlers && valueChangeHandler != null) {
      ((HasValueChangeHandlers) editor).addValueChangeHandler(valueChangeHandler);
      // if widget has a value change handler, validate on change
      if (validateOnVueChangeHandler != null) {
        ((HasValueChangeHandlers) editor).addValueChangeHandler(validateOnVueChangeHandler);
      }
    }
    // if widget has a key up handler, validate on key up
    if (editor instanceof HasKeyUpHandlers && validateOnKeyUpHandler != null) {
      ((HasKeyUpHandlers) editor).addKeyUpHandler(validateOnKeyUpHandler);
    }
    // try to submit form on return
    if (editor instanceof HasKeyPressHandlers && commitOnReturnHandler != null) {
      ((HasKeyPressHandlers) editor).addKeyPressHandler(commitOnReturnHandler);
    }
  }
701410
public void setValueWidget(I_CmsFormEditWidget widget, String value, String defaultValue, boolean active) {

        if (m_hasValue) {
            throw new RuntimeException("Value has already been set");
        }
        m_defaultValue = defaultValue;
        m_hasValue = true;
        m_isSimpleValue = true;
        m_widget = widget;
        if (CmsAttributeHandler.hasResizeHandler() && (m_widget instanceof HasResizeHandlers)) {
            ((HasResizeHandlers)m_widget).addResizeHandler(CmsAttributeHandler.getResizeHandler());
        }
        m_widgetHolder.clear();
        m_widget.setWidgetInfo(m_label, m_help);
        if (active) {
            m_widget.setValue(value, false);
        } else {
            m_widget.setValue("");
        }
        m_widgetHolder.add(m_widget);
        m_widget.setName(getHandler().getAttributeName());
        m_widget.addValueChangeHandler(new ChangeHandler());
        m_widget.addFocusHandler(new FocusHandler() {

            public void onFocus(FocusEvent event) {

                CmsValueFocusHandler.getInstance().setFocus(CmsAttributeValueView.this);
                activateWidget();
            }
        });
        m_widget.setActive(active);
        if (!active) {
            addActivationHandler();
        } else {
            removeStyleName(formCss().emptyValue());
        }
        addStyleName(formCss().simpleValue());

        if (m_widget instanceof CmsFormWidgetWrapper) {
            addLabelHoverHandler(((CmsFormWidgetWrapper)m_widget).getLabel());
        } else {
            removeLabelHoverHandler();
        }
    }
125743
@Override
    public void updateValue(final AttributeValue inValue) throws DevFailed {
        xlogger.entry(getName());
        // final Profiler profilerPeriod = new Profiler("read attribute " + name);
        // profilerPeriod.start("in");
        if (inValue == null) {
            throw DevFailedUtils.newDevFailed(ExceptionMessages.ATTR_VALUE_NOT_SET,
                    name + " read value has not been updated");
        }

        try {
            // copy value
            readValue = (AttributeValue) inValue.clone();
        } catch (final CloneNotSupportedException e) {
            throw DevFailedUtils.newDevFailed(e);
        }

        // update quality if necessary
        if (readValue.getValue() != null && !readValue.getQuality().equals(AttrQuality.ATTR_INVALID)) {
            updateQuality(readValue);
        }
        // profilerPeriod.start("clone");

        // profilerPeriod.stop().print();
        try {
            if (readValue.getValue() != null) {
                // profilerPeriod.start("checkUpdateErrors");
                checkUpdateErrors(readValue);
                // profilerPeriod.start("from2DArrayToArray");
                // get as array if necessary (for image)
                readValue.setValueWithoutDim(ArrayUtils.from2DArrayToArray(readValue.getValue()));
                // force conversion to check types
                // profilerPeriod.start("toAttributeValue5");
                TangoIDLAttributeUtil.toAttributeValue5(this, readValue, null);
            } else {
                throw DevFailedUtils.newDevFailed(ExceptionMessages.ATTR_VALUE_NOT_SET,
                        name + " read value has not been updated");
            }
            // profilerPeriod.start("updateDefaultWritePart");
            updateDefaultWritePart();
            // profilerPeriod.stop().print();

        } catch (final DevFailed e) {
            // readValue.setQuality(AttrQuality.ATTR_INVALID);
            readValue.setXDim(0);
            readValue.setYDim(0);
            lastError = e;
            throw e;
        }
        xlogger.exit(getName());
    }
260860
public static void checkUpdate(DatasetDescriptor existing,
                                 DatasetDescriptor updated) {
    checkNotChanged("location", existing.getLocation(), updated.getLocation());
    checkCompatible(existing, updated);
  }
1127148
public void setEditorTarget (PropertyEditorTarget target)
    {
        if (target instanceof DBMetaSchemaNode)
        {
            super.setEditorTarget(target);
            this.tfSchemaName.setText((String)target.getAttribute(DBMetaSchemaNode.ATT_SCHEMA_NAME));
        }
        else
        {
            throw new UnsupportedOperationException("This editor can only edit DBSchemaCatalogNode objects");
        }
    }
62237
private void updateDefault(final Instance _inst,
                               final String _value)
    {
        try {
            final Update update = new Update(_inst);
            update.add("Default", _value);
            update.execute();
        } catch (final EFapsException e) {
            DBPropertiesUpdate.LOG.error("updateDefault(String, String)", e);
        }
    }
327500
private void updateSingle(
            ReadOnlyStyledDocument<PS, SEG, S> newValue,
            RichTextChange<PS, SEG, S> change,
            MaterializedListModification<Paragraph<PS, SEG, S>> parChange) {
        updateMulti(newValue, Collections.singletonList(change), Collections.singletonList(parChange));
    }
479885
void updateReplace() {

        boolean replace = m_replace.getValue().booleanValue();

        m_replaceResource.setVisible(replace ? SearchType.resourcetype.equals(m_searchType.getValue()) : replace);
        m_replacePattern.setVisible(
            replace
            ? !SearchType.resourcetype.equals(m_searchType.getValue())
                & !SearchType.renameContainer.equals(m_searchType.getValue())
            : replace);

        m_newName.setVisible(replace ? SearchType.renameContainer.equals(m_searchType.getValue()) : replace);
        m_oldName.setVisible(replace ? SearchType.renameContainer.equals(m_searchType.getValue()) : replace);

        m_workProject.setVisible(replace);

        m_search.setCaption(
            replace
            ? CmsVaadinUtils.getMessageText(Messages.GUI_SOURCESEARCH_REPLACE_0)
            : CmsVaadinUtils.getMessageText(Messages.GUI_SOURCESEARCH_SEARCH_0));

    }
579364
public void update(Bbox mapBounds) {
		for (final SnappingRule condition : snappingRules) {
			condition.getSourceProvider().update(mapBounds);
			condition.getSourceProvider().getSnappingSources(new GeometryArrayFunction() {

				public void execute(Geometry[] geometries) {
					condition.getAlgorithm().setGeometries(geometries);
				}
			});
		}
	}
865067
@Override
    public void addParameterAnnotation(int param, AnnotationValue annotationValue) {
        HashMap<Integer, Map<ClassDescriptor, AnnotationValue>> updatedAnnotations = new HashMap<>(
                methodParameterAnnotations);
        Map<ClassDescriptor, AnnotationValue> paramMap = updatedAnnotations.get(param);
        if (paramMap == null) {
            paramMap = new HashMap<>();
            updatedAnnotations.put(param, paramMap);
        }
        paramMap.put(annotationValue.getAnnotationClass(), annotationValue);

        methodParameterAnnotations = updatedAnnotations;
        TypeQualifierApplications.updateAnnotations(this);
    }
152354
function(target, date) {
		var inst = this._getInst(target);
		if (inst) {
			this._setDate(inst, date);
			this._updateDatepicker(inst);
			this._updateAlternate(inst);
		}
	}
1338132
protected void setValue(int newValue, boolean updateTextField, boolean firePropertyChange) {
		int oldValue = value;
		if (newValue < min) {
			value = min;
		} else if (newValue > max) {
			value = max;
		} else {
			value = newValue;
		}

		if (updateTextField) {
			textField.setText(Integer.toString(value));
			textField.setForeground(Color.black);
		}

		if (firePropertyChange) {
			firePropertyChange("value", oldValue, value);
		}
	}
1356795
public boolean compareAndSet(final long expectedValue, final long updateValue)
    {
        return UnsafeAccess.UNSAFE.compareAndSwapLong(byteArray, addressOffset, expectedValue, updateValue);
    }
785569
public void update( EditorHost editor )
  {
    _editor = editor;
    _icon.setIcon( findIconForResults() );
    _feedback.repaint();
    repaint();
    editor.repaint();
  }
846987
public void update() {
		super.update();

		if (!canModifyEditor()) {
			setEnabled(false);
			return;
		}

		ITextEditor editor= getTextEditor();
		if (fOperationTarget == null && editor != null)
			fOperationTarget= (ITextOperationTarget) editor.getAdapter(ITextOperationTarget.class);

		boolean isEnabled= (fOperationTarget != null && fOperationTarget.canDoOperation(ITextOperationTarget.PREFIX) && fOperationTarget.canDoOperation(ITextOperationTarget.STRIP_PREFIX));
		setEnabled(isEnabled);
	}
975906
public boolean updateMetadata(final RuleMetadata target) {

        RuleMetadata metaData = getMetaData(target.getAttributeName());
        if (metaData != null) {
            metaData.setValue(target.getValue());
            return true;
        }

        addMetadata(target);
        return false;
    }