Start a move to an existing mirror that may or may not have once been primary.
480838
Delta newMoveRestart(Storage src, Storage dest) {
        // If the destination used to be the initial primary for the group, it's consistent and ready to promote
        // but lacking the MIRROR_CONSISTENT marker attribute which is the prereq for promotion.  Add one.
        Delta consistentMarker = dest.isConsistent() ?
                Deltas.conditional(Conditions.isUndefined(), Deltas.literal(now())) :
                Deltas.noop();
        return Deltas.mapBuilder()
                .update(STORAGE.key(), Deltas.mapBuilder()
                        .update(src.getUuidString(), Deltas.mapBuilder()
                                .put(Storage.MOVE_TO.key(), dest.getUuidString())
                                .build())
                        .update(dest.getUuidString(), Deltas.mapBuilder()
                                // Clean slate: clear 'moveTo' plus all markers for promotion states and later.
                                .update(StorageState.MIRROR_CONSISTENT.getMarkerAttribute().key(), consistentMarker)
                                .remove(Storage.MOVE_TO.key())
                                .remove(Storage.PROMOTION_ID.key())
                                .remove(StorageState.PRIMARY.getMarkerAttribute().key())
                                .remove(StorageState.MIRROR_EXPIRING.getMarkerAttribute().key())
                                .remove(StorageState.MIRROR_EXPIRED.getMarkerAttribute().key())
                                .build())
                        .build())
                .build();
    }
350844
function tryRepairConnectionStart(moved, other, newDocking, points) {
  return _tryRepairConnectionSide(moved, other, newDocking, points);
}
981111
def start(self, id):
        
        path = partial(_path, self.adapter)
        path = path(id)
        return self._put(path)
796255
private void moveToPrevious() {
        if (controller != null) {
            currentItemIndex = controller.previousItem(this, currentItemIndex);
        } else {
            currentItemIndex = defaultController.previousItem(this, currentItemIndex);
        }
    }
175376
def rebase(image)
      new_path = @router.baseline_dir(image.name)

      create_path_for_file(new_path)
      FileUtils.move(image.path, new_path)

      Monet::Image.new(new_path)
    end
172461
def start(self, key=None, **params):
		""""""
		self.params.update(**params)
		key = key or self.stack_key
		if key is not None:
			self.current_times[key] = time()
1046937
def replace(self, source, dest):
        """"""
        for i, broker in enumerate(self.replicas):
            if broker == source:
                self.replicas[i] = dest
                return
109579
private void moveOldStructure() throws Exception
   {
      ExtendedSession session = (ExtendedSession)service.getStorageSession();
      try
      {
         if (session.itemExists(storagePathOld))
         {
            return;
         }
         else
         {
            session.move(service.getStoragePath(), storagePathOld, false);
            session.save();
         }
      }
      finally
      {
         session.logout();
      }
   }
421005
def migrateUp(self):
        
        te = self.store.findFirst(TimedEvent, sort=TimedEvent.time.descending)
        if te is not None:
            self._transientSchedule(te.time, None)
1116667
def moveDown(self, entry):
        
        if not entry:
            return
        
        entries = self.entries()
        next = entries[entries.index(entry) + 1]
        
        entry_q = entry.query()
        next_q  = next.query()
        
        next.setQuery(entry_q)
        entry.setQuery(next_q)
1369837
def refresh(self, key):
        """"""
        s0 = self[key]
        s = self.backtrack(key)
        s.persist(**s0.metadata['persist_kwargs'])
474252
def _replace_old_image(self):
        ''' 
        '''
        try:
            old_obj = self.__class__.objects.get(pk=self.pk)
            if old_obj.image.path != self.image.path:
                path = old_obj.image.path
                default_storage.delete(path)
        except self.__class__.DoesNotExist:
            pass
603821
def move_item(self, item, origin, destination):
        
        if self.equality:
            item_index = 0
            for i, element in enumerate(origin):
                if self.equality(element, item):
                    item_index = i
                    break
        else:
            item_index = origin.index(item)

        destination.append(origin.pop(item_index))
903512
private void moveToNext() {
        if (controller != null) {
            currentItemIndex = controller.nextItem(this, currentItemIndex);
        } else {
            currentItemIndex = defaultController.nextItem(this, currentItemIndex);
        }
    }
1059492
def replace(self, replacements):
        

        for old_var, new_var in replacements.items():
            old_var_id = id(old_var)
            if old_var_id in self._object_mapping:
                # FIXME: we need to check if old_var still exists in the storage
                old_so = self._object_mapping[old_var_id]  # type: StoredObject
                self._store(old_so.start, new_var, old_so.size, overwrite=True)

        return self
664116
def new_run(self):
        """"""
        self.current_run += 1
        self.runs.append(RunData(self.current_run + 1))
139225
function moveToPrevious(priv) {
  moveTo(priv, (priv.toIndex - 1 + priv.slides.length) % priv.slides.length);
}