Reverses all the TransitionControllers managed by this TransitionManager
19410
public void reverse() {
        for (int i = 0, size = mTransitionControls.size(); i < size; i++) {
            mTransitionControls.get(i).reverse();
        }
    }
279776
public static function rollback()
    {
        foreach (array_reverse(self::$migrationClasses) as $migrationClass) {
            /** @var Migration $instance */
            $instance = new $migrationClass;
            $instance->rollback();
        }
    }
846721
public static void stop(ServiceController<?> controller) {
        try {
            transition(controller, State.DOWN);
        } catch (StartException e) {
            // This can't happen
            throw new IllegalStateException(e);
        }
    }
966170
private void unregisterRemoteCommands()
   {
      if (rpcService != null)
      {
         rpcService.unregisterCommand(suspend);
         rpcService.unregisterCommand(resume);
         rpcService.unregisterCommand(requestForResponsibleForResuming);
      }
      
   }
297525
def reverse(self):
        
        for key in six.iterkeys(self._map):
            self._map[key].reverse()
        self._items.reverse()
        return self
811613
public function down()
    {
        // Drop created tables in reverse order

        // Lookup Keys
        Schema::dropIfExists('lookup');
        // System customizations
        Schema::dropIfExists('system_custom');
        // System Configuration
        Schema::dropIfExists('system_config');
        // File storage, public path designation
        Schema::dropIfExists('file_service_config');
        // Cache-able service configuration
        Schema::dropIfExists('service_cache_config');
        // JSON Web Token to system resources map
        Schema::dropIfExists('token_map');
        // App relationship for user
        Schema::dropIfExists('user_to_app_to_role');
        // Service Docs
        Schema::dropIfExists('service_doc');
        // Role Service Accesses
        Schema::dropIfExists('role_service_access');
        // Roles
        Schema::dropIfExists('role');
        // Email Templates
        Schema::dropIfExists('email_template');
        // Services
        Schema::dropIfExists('service');
        //Cors config table
        Schema::dropIfExists('cors_config');
        // App relationship for user
        Schema::dropIfExists('user_to_app_role');
        // Applications
        Schema::dropIfExists('app');
        //Password reset
        Schema::dropIfExists('password_resets');
        // User table
        Schema::dropIfExists('user');
    }
1250400
public function down()
    {
        // remove DB Table:
        $manager = $this->modx->getManager();

        // the class table object name
        $table_class = $this->blender->getBlendClassObject();
        //foreach ($this->blender_table_classes as $table_class) {
            if ($manager->removeObjectContainer($table_class)) {
                $this->blender->out($table_class.' table class has been dropped');

            } else {
                $this->blender->out($table_class.' table class was not dropped', true);
            }
        //}

        // remove events:
        foreach ($this->blender_events as $event_name) {
            $this->removeSystemEvents($event_name);
        }

        /** @var \LCI\Blend\Blendable\SystemSetting $systemSetting */
        $systemSetting = $this->blender->getBlendableLoader()->getBlendableSystemSetting('blend.version');
        $systemSetting
            ->setSeedsDir($this->getSeedsDir())
            ->revertBlend();

        foreach ($this->empty_settings as $key) {
            /** @var \LCI\Blend\Blendable\SystemSetting $systemSetting */
            $systemSetting = $this->blender->getBlendableLoader()->getBlendableSystemSetting($key);
            $systemSetting
                ->setSeedsDir($this->getSeedsDir())
                ->revertBlend();
        }

        $this->modx->cacheManager->refresh();
    }
1151316
@Override
    public void stopTransition() {
        //call listeners so they can perform their actions first, like modifying this adapter's transitions
        for (int i = 0, size = mListenerList.size(); i < size; i++) {
            mListenerList.get(i).onTransitionEnd(this);
        }

        for (int i = 0, size = mTransitionList.size(); i < size; i++) {
            mTransitionList.get(i).stopTransition();
        }
    }
247318
@Deprecated
    @Override
    @SuppressWarnings("deprecation")
    protected void rollbackRuntime(OperationContext context, ModelNode operation, ModelNode model, List<ServiceController<?>> controllers) {
        revertReload(context);
    }
158699
private void reverse(WritableDataStore<HashSetModifiableDBIDs> sampleNewHash, WritableDataStore<HashSetModifiableDBIDs> newReverseNeighbors, WritableDataStore<HashSetModifiableDBIDs> oldReverseNeighbors) {
    for(DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
      KNNHeap heap = store.get(iditer);
      HashSetDBIDs newNeighbors = sampleNewHash.get(iditer);
      for(DoubleDBIDListIter heapiter = heap.unorderedIterator(); heapiter.valid(); heapiter.advance()) {
        (newNeighbors.contains(heapiter) ? newReverseNeighbors : oldReverseNeighbors).get(heapiter).add(iditer);
      }
    }
  }
1153866
function() {
        if (bound) { self.unbind(transitionEnd, cb); }

        if (i > 0) {
          self.each(function() {
            this.style[support.transition] = (oldTransitions[this] || null);
          });
        }

        if (typeof callback === 'function') { callback.apply(self); }
        if (typeof nextCall === 'function') { nextCall(); }
      }
1304717
def backward_step(self):
        
        logger.debug("Executing backward step ...")
        self.run_to_states = []
        self.set_execution_mode(StateMachineExecutionStatus.BACKWARD)
41330
public final void revert() {

        if (tagged) {

            // Remove the added entries
            final Iterator<K> addedIt = added.keySet().iterator();
            while (addedIt.hasNext()) {
                final K key = addedIt.next();
                map.remove(key);
                addedIt.remove();
            }

            // Replace the changed entries
            final Iterator<K> changedIt = changed.keySet().iterator();
            while (changedIt.hasNext()) {
                final K key = changedIt.next();
                final V value = changed.get(key);
                map.put(key, value);
                changedIt.remove();
            }

            // Add the removed entries
            final Iterator<K> removedIt = removed.keySet().iterator();
            while (removedIt.hasNext()) {
                final K key = removedIt.next();
                final V value = removed.get(key);
                map.put(key, value);
                removedIt.remove();
            }

        }

    }
422799
@NonNull
    public TransitionSet removeTransition(@NonNull Transition transition) {
        mTransitions.remove(transition);
        transition.mParent = null;
        return this;
    }
468202
protected void reverse() {
    for(int i = 0, j = size - 1; i < j; i++, j--) {
      double tmpd = dists[j];
      dists[j] = dists[i];
      dists[i] = tmpd;
      int tmpi = ids[j];
      ids[j] = ids[i];
      ids[i] = tmpi;
    }
  }
767538
def close(self):
        
        self.stop_sync()
        [c.io.close() for c in self._controllers if c.io is not None]
184565
private static void reverse(int first, int last, Swapper swapper) {
	// no more needed since manually inlined
	while (first < --last) {
		swapper.swap(first++,last);
	}
}