Reverts to the latest state in the undo stack.<p>
509484
public void undo() {

        if (hasUndo()) {
            ChangeType type = m_current.getType();
            String entityId = m_current.getEntityId();
            String attributeName = m_current.getAttributeName();
            int valueIndex = m_current.getValueIndex();
            m_redo.push(m_current);
            m_current = m_undo.pop();
            changeEntityContentValues(m_current.getEntityData(), entityId, attributeName, valueIndex, type);
            fireStateChange();
        }
    }
361040
private static void handleUndoLog(List<UndoAction> undoLog, boolean undo) {
        if (undoLog == null) {
            return;
        }

        if (undo) {
            undoLog = Lists.reverse(undoLog);
        }
        for (UndoAction action : undoLog) {
            if (undo) {
                action.undo();
            } else {
                action.release();
            }
        }
        if (undo) {
            undoLog.clear();
        }
    }
925861
public void goBack() {
		sleeper.sleep();
		try {
			inst.sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);
			sleeper.sleep();
		} catch (Throwable ignored) {}
	}
758608
public boolean revert() {
        try {
            setWrongValueMessage(null);
            setValue(propInfo.getPropertyValue(target));
            updateValue();
            return true;
        } catch (Exception e) {
            setWrongValueException(e);
            return false;
        }
    }
577855
public void
restore() {
	if (saved_pos < 0) {
		throw new IllegalStateException("no previous state");
	}
	byteBuffer.position(saved_pos);
	byteBuffer.limit(saved_end);
	saved_pos = -1;
	saved_end = -1;
}
456973
def redo(self):
        ''' 
        '''
        if self.canredo():
            undoable = self._redos.pop()
            with self._pausereceiver():
                try:
                    undoable.do()
                except:
                    self.clear()
                    raise
                else:
                    self._undos.append(undoable)
            self.docallback()
170655
@Override
	public void reset() {
		this.priorityElements = Lists.newArrayList(originalElements);
		Collections.shuffle(priorityElements);
		this.currentElements = Lists.newArrayListWithExpectedSize(2 * originalElements.size());
		this.currentElements.addAll(originalElements);
	}
352483
def back(self):
        
        if self._index <= 0:
            return None
        undone = self.current_item
        self._index -= 1
        self._check_index()
        return undone
1034933
def restore_button_state(self):
        """"""
        self.parent.pbnNext.setEnabled(self.next_button_state)
        self.parent.pbnBack.setEnabled(self.back_button_state)
738069
@Override
  public boolean undo() {
    if (destTopologyFile != null) {
      LOG.info("Clean uploaded jar");
      File file = new File(destTopologyFile);
      return file.delete();
    }
    return true;
  }
1367779
public function revert()
    {
        $this->order = $this->order == 'ASC' ? 'DESC' : 'ASC';
        $this->index = array_reverse($this->index);

        // revert order in all sub-sets
        foreach ($this->sets as $set) {
            if ($this->order != $set->get_parameters('ORDER')) {
                $set->revert();
            }
        }
    }
524545
private void resetState() {

        // clear all members so the tag object may be reused
        m_type = null;
        m_name = null;
        m_param = null;
        m_maxElements = null;
        m_tag = null;
        m_tagClass = null;
        m_detailView = false;
        m_detailOnly = false;
        m_width = null;
        m_editableBy = null;
        m_bodyContent = null;
        m_hasModelGroupAncestor = false;
        // reset the current element
        CmsJspStandardContextBean cmsContext = CmsJspStandardContextBean.getInstance(pageContext.getRequest());
        cmsContext.setElement(m_parentElement);
        cmsContext.setContainer(m_parentContainer);
        m_parentElement = null;
        m_parentContainer = null;
    }
1107341
def undo(self):
        
        _, _, undo_state = self._undo_stack.back()

        # Retrieve the initial spike_cluster structure.
        spike_clusters_new = self._spike_clusters_base.copy()

        # Loop over the history (except the last item because we undo).
        for spike_ids, cluster_ids, _ in self._undo_stack:
            # We update the spike clusters accordingly.
            if spike_ids is not None:
                spike_clusters_new[spike_ids] = cluster_ids

        # What are the spikes affected by the last changes?
        changed = np.nonzero(self._spike_clusters !=
                             spike_clusters_new)[0]
        clusters_changed = spike_clusters_new[changed]

        up = self._do_assign(changed, clusters_changed)
        up.history = 'undo'
        # Add the undo_state object from the undone object.
        up.undo_state = undo_state

        self.emit('cluster', up)
        return up
322600
function undo() {
		if ($this->flag) {
			if ($this->count)
				$this->count--;
			return $this->restore($this->count);
		}
		return $this;
	}
358435
@Override
    public void backward() {
        modInX.getOutputAdj().elemAdd(yAdj);
        modInW.getOutputAdj().elemSubtract(yAdj);
    }
53323
void rollback()
	{
		switch (data_type)
		{
		case Tango_DEV_BOOLEAN :
			bool_val = old_bool_val;
			break;
		
		case Tango_DEV_SHORT :
			short_val = old_short_val;
			break;
		
		case Tango_DEV_LONG :
			long_val = old_long_val;
			break;
		
		case Tango_DEV_LONG64 :
			long64_val = old_long64_val;
			break;
		
		case Tango_DEV_DOUBLE :
			double_val = old_double_val;
			break;
		
		case Tango_DEV_STRING :
			str_val = old_str_val;
			break;
		}
	}
1097519
public void redo() {

        // If there is at least one command to redo
        if (this.undoneStack.size() > 0) {
            // add the last undone command on the command stack
            this.commandStack.add(this.undoneStack.get(this.undoneStack.size() - 1));
            // remove the command to redo of the undone stack.
            this.undoneStack.remove(this.undoneStack.size() - 1);
            // Call Redo method
            this.commandStack.get(this.commandStack.size() - 1)
                             .run(WBuilder.wave().addDatas(WBuilder.waveData(UndoRedoWaves.UNDO_REDO, false)));
        } else {
            // End of stack, do nothing
            LOGGER.info("No more command to redo, end of stack");
        }
    }