Update the specified annotation.
9706
def update(self, event, annotation):
        """"""
        # Decide whether or not to hide previous highlights...
        for artist in self.highlights.values():
            if self.display == 'multiple':
                continue
            if self.display == 'one-per-axes':
                if event.artist.axes is not artist.axes:
                    continue
            artist.set_visible(False)
        self.show_highlight(event.artist)
        DataCursor.update(self, event, annotation)
146273
public static Builder updateAnnotationArgumentValues(
      AnnotationTree annotation, String parameterName, Collection<String> newValues) {
    if (annotation.getArguments().isEmpty()) {
      String parameterPrefix = parameterName.equals("value") ? "" : (parameterName + " = ");
      return SuggestedFix.builder()
          .replace(
              annotation,
              annotation
                  .toString()
                  .replaceFirst("\\(\\)", "(" + parameterPrefix + newArgument(newValues) + ")"));
    }
    Optional<ExpressionTree> maybeExistingArgument = findArgument(annotation, parameterName);
    if (!maybeExistingArgument.isPresent()) {
      return SuggestedFix.builder()
          .prefixWith(
              annotation.getArguments().get(0),
              parameterName + " = " + newArgument(newValues) + ", ");
    }

    ExpressionTree existingArgument = maybeExistingArgument.get();
    return SuggestedFix.builder().replace(existingArgument, newArgument(newValues));
  }
1223038
public void setAnnotation( String name, String value)
    {
    String annotation = StringUtils.trimToNull( name);
    if( annotation == null)
      {
      throw new IllegalArgumentException( "Annotation name must be non-blank");
      }
    if( value == null)
      {
      annotations_.remove( annotation);
      }
    else
      {
      annotations_.put( annotation, value);
      }
    }
186053
def update(self, *args, **kwargs):
        """"""
        self._extend(args, kwargs, 'update', self._update_items)
488325
def update(self, instance, oldValue, newValue):
    """"""
    self.__set__(instance,
                 self.__get__(instance, None) + newValue - (oldValue or 0))
864987
public static void updateEnd(final Annotation annotation, final int end)
    {
        annotation.removeFromIndexes();
        annotation.setEnd(end);
        annotation.addToIndexes();
    }
1253226
def update(self, n=1):
    """"""
    with self._lock:
      self._pbar.update(n)
      self.refresh()
1113121
def update(self):
        """"""
        self.filename = self.parent.notes.annot.xml_file
        
        self.event_types = self.parent.notes.annot.event_types
        self.idx_evt_type.clear()
        for ev in self.event_types:
            self.idx_evt_type.addItem(ev)
261131
def update(self, event, annotation):
        """"""
        # Get artist-specific information about the pick event
        info = self.event_info(event)

        if self.props_override is not None:
            info = self.props_override(**info)

        # Update the xy position and text using the formatter function
        annotation.set_text(self.formatter(**info))
        annotation.xy = info['x'], info['y']

        # Unfortnately, 3D artists are a bit more complex...
        # Also, 3D artists don't share inheritance. Use naming instead.
        if '3D' in type(event.artist).__name__:
            annotation.xy = event.mouseevent.xdata, event.mouseevent.ydata

        # In case it's been hidden earlier...
        annotation.set_visible(True)

        if self.keep_inside:
            self._keep_annotation_inside(annotation)

        annotation._has_been_shown = True
        self._last_event = event
        self._last_annotation = annotation

        event.canvas.draw()
691451
def set_annotation(i, k, v):
    
    if not isinstance(i, dict):
        raise ValueError("Can only annotate dictionaries")

    if not isinstance(v, list):
        v = [v]

    if k in i:
        ev = i.get(k)
        if isinstance(ev, list):
            ev.extend(v)
    else:
        i[k] = v
217034
protected final void update() {
		BufferedImage image=getImageViewer()==null ? null : getImageViewer().getImage();
		if (image==null || model.isInvalid() || model.getX()>=image.getWidth() || model.getY()>=image.getHeight())
			updateLabelNoData();
		else
			updateLabel(image, model.getX(), model.getY(), statusBar.getWidth()-statusBarInsets.left-statusBarInsets.right);
	}
1215888
def update(self, **kwargs):
        """"""
        assert not self.called
        self.kw.update(kwargs)
        return self
526179
public void update(Object target) {
        if (target == null) {
            throw new IllegalArgumentException(
                    "Target to update cannot be null");
        }

        BeanWrapper bw = new BeanWrapperImpl(target);
        bw.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true));
        for (Map.Entry<String, Object> property : m_properties.entrySet()) {
            String propertyName = property.getKey();
            Object value = property.getValue();

            if (value instanceof Map) {
                PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
                if (!Map.class.isAssignableFrom(pd.getPropertyType()) || pd.getWriteMethod() == null) {
                    value = new DynamicObject((Map<String, Object>) value);
                }
            }

            if (value instanceof DynamicObject) {
                ((DynamicObject) value).update(bw.getPropertyValue(propertyName));
            }
            else {
                bw.setPropertyValue(propertyName, value);
            }
        }
    }
299784
public void update(ESMapping mapping, Object pkVal, Map<String, Object> esFieldData) {
        Map<String, Object> esFieldDataTmp = new LinkedHashMap<>(esFieldData.size());
        esFieldData.forEach((k, v) -> esFieldDataTmp.put(Util.cleanColumn(k), v));
        append4Update(mapping, pkVal, esFieldDataTmp);
        commitBulk();
    }
271969
public void addAnnotation(final Class<? extends Annotation> clazz, final Annotation ann) {
        if (ann == null || clazz == null) {
            return;
        }

        if (!foundAnnotations.containsKey(clazz)) {
            foundAnnotations.put(clazz, new ArrayList<Annotation>());
        }

        foundAnnotations.get(clazz).add(ann);
    }
1191422
def update(self, func, **kw):
        ""
        func.__name__ = self.name
        func.__doc__ = getattr(self, 'doc', None)
        func.__dict__ = getattr(self, 'dict', {})
        func.__defaults__ = getattr(self, 'defaults', ())
        func.__kwdefaults__ = getattr(self, 'kwonlydefaults', None)
        func.__annotations__ = getattr(self, 'annotations', None)
        callermodule = sys._getframe(3).f_globals.get('__name__', '?')
        func.__module__ = getattr(self, 'module', callermodule)
        func.__dict__.update(kw)
667087
def updateFromKwargs(self, properties, kwargs, collector, **unused):
        """'"""
        properties[self.name] = self.getFromKwargs(kwargs)