try (StemmerOverrideUpdater updater = new StemmerOverrideUpdater(item)) {
            reload(updater);
        }
    }

    @Override
    public synchronized void update(final StemmerOverrideItem item) {
        try (StemmerOverrideUpdater updater = new StemmerOverrideUpdater(item)) {
            reload(updater);
        }
    }

    @Override

    public synchronized void insert(final CharMappingItem item) {
        try (MappingUpdater updater = new MappingUpdater(item)) {
            reload(updater);
        }
    }

    @Override
    public synchronized void update(final CharMappingItem item) {
        try (MappingUpdater updater = new MappingUpdater(item)) {
            reload(updater);
        }
    }

    @Override

    public synchronized void insert(final SynonymItem item) {
        try (SynonymUpdater updater = new SynonymUpdater(item)) {
            reload(updater);
        }
    }

    @Override
    public synchronized void update(final SynonymItem item) {
        try (SynonymUpdater updater = new SynonymUpdater(item)) {
            reload(updater);
        }
    }

    @Override

                updater.virtualFileSystemContentsChanged(removed, added, newRoot)
            }
            return newRoot
        }
    }

    List<File> movedPaths = []
    AbstractFileWatcherUpdater.MovedDirectoryHandler movedWatchedDirectoriesSupplier = { SnapshotHierarchy vfsRoot -> movedPaths }

    def setup() {
        updater = createUpdater(watcher, watchableHierarchies)
    }

		prevCfg := proxy.PrevSidecarScope.DestinationRuleByName(updatedDr.Name, updatedDr.Namespace)
		if prevCfg == nil {
			log.Debugf("Prev DestinationRule form PrevSidecarScope is missing for %s/%s", updatedDr.Namespace, updatedDr.Name)
			return nil, nil
		}
		dr := prevCfg.Spec.(*networking.DestinationRule)
		services = append(services, proxy.SidecarScope.ServicesForHostname(host.Name(dr.Host))...)
	} else {

        then:
        1 * watcher.startWatching({ equalIgnoringOrder(it, [firstDir]) })
        0 * _

        when:
        updater.triggerWatchProbe(watchProbeFor(secondDir).absolutePath)
        updater.triggerWatchProbe(watchProbeFor(firstDir).absolutePath)
        updater.triggerWatchProbe(watchProbeFor(directoryWithinFirst).absolutePath)
        then:
        0 * _

        when:
        buildFinished()

	updateMin := 0
	if set.Spec.UpdateStrategy.RollingUpdate != nil {
		updateMin = int(*set.Spec.UpdateStrategy.RollingUpdate.Partition)
	}
	// we terminate the Pod with the largest ordinal that does not match the update revision.
	for target := len(replicas) - 1; target >= updateMin; target-- {

			}
		}

		// if the Pod is not dirty, do nothing
		if consistent {
			return nil
		}

		attemptedUpdate = true
		// commit the update, retrying on conflicts

		updateErr := spc.objectMgr.UpdatePod(pod)
		if updateErr == nil {
			return nil
		}

		if updated, err := spc.objectMgr.GetPod(set.Namespace, pod.Name); err == nil {
			// make a copy so we don't mutate the shared cache

    if (id == 'show-from') param = 'sf';

    // We update on mouseenter so middle-click/right-click work properly.
    elem.addEventListener('mouseenter', updater);
    elem.addEventListener('touchstart', updater);

    function updater() {
      // The selection can be in one of two modes: regexp-based or
      // list-based.  Construct regular expression depending on mode.
      let re = regexpActive

		}
		if currDS.Status.CollisionCount == nil {
			currDS.Status.CollisionCount = new(int32)
		}
		*currDS.Status.CollisionCount++
		_, updateErr := dsc.kubeClient.AppsV1().DaemonSets(ds.Namespace).UpdateStatus(ctx, currDS, metav1.UpdateOptions{})
		if updateErr != nil {
			return nil, updateErr
		}