Revert changes to ledger (uncommitted) and state made by any requests
        that have not been ordered.
170805
def revert_unordered_batches(self):
        
        i = 0
        for key in sorted(self.batches.keys(), reverse=True):
            if compare_3PC_keys(self.last_ordered_3pc, key) > 0:
                ledger_id, discarded, _, prevStateRoot, len_reqIdr = self.batches.pop(key)
                discarded = invalid_index_serializer.deserialize(discarded)
                self.logger.debug('{} reverting 3PC key {}'.format(self, key))
                self.revert(ledger_id, prevStateRoot, len_reqIdr - len(discarded))
                i += 1
            else:
                break
        return i
220043
def revert_wire(options = {})
      response = JSON.parse(@client.patch("items/#{send(:id)}/revert_wire", options).body)
      @attributes = response['items']
      true
    end
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;
		}
	}
924429
def can_revert(self):
        

        if self.can_publish:
            with self.published_context():
                return self.count(Q._uid == self._uid) > 0

        return False
1282274
public void revert() {
		for (Iterator i = children.iterator(); i.hasNext();) {
			((FormModel) i.next()).revert();
		}
		// this will cause all buffered value models to revert
		commitTrigger.revert();
		// this will then go back and revert all unbuffered value models
		for (Iterator i = mediatingValueModels.values().iterator(); i.hasNext();) {
			((DirtyTrackingValueModel) i.next()).revertToOriginal();
		}
	}
1206690
def cleanup_request(request):
        
        for method_type in ('GET', 'PUT', 'POST', 'DELETE'):
            block = getattr(request, method_type, { })

            if True in [ k.startswith("oauth_") for k in block.keys() ]:
                sanitized = block.copy()

                for k in sanitized.keys():
                    if k.startswith("oauth_"):
                        sanitized.pop(k)

                setattr(request, method_type, sanitized)

        return request
816247
def undo_changes!
      Petra.current_transaction.current_section.log_attribute_change_veto(object,
                                                                          attribute:      attribute,
                                                                          external_value: external_value)
    end
1060908
def rollback(self):
        
        logger.info('Rolling back changes')

        config_text = self.compare_config(other=self.original_config)

        if len(config_text) > 0:
            return self._commit(config_text, force=True, reload_original_config=False)
751179
def delete(self):
        """"""
        try:
            self.revert()
        except errors.ChangelistError:
            pass

        self._connection.run(['change', '-d', str(self._change)])
299719
def rollback(self):
        
        if hasattr(self.local, 'tx') and self.local.tx:
            tx = self.local.tx.pop()
            tx.rollback()
            self._flush_tables()
1142244
def reverseCommit(self):
        
        self.baseClass.setText(self.oldText)
        self.qteWidget.SCISetStylingEx(0, 0, self.style)
716392
def rollback(self):
        """"""
        commands = []
        commands.append('configure replace flash:rollback-0')
        commands.append('write memory')
        self.device.run_commands(commands)
922101
def revert(self, snapshot: Tuple[Hash32, UUID]) -> None:
        
        state_root, account_snapshot = snapshot

        # first revert the database state root.
        self._account_db.state_root = state_root
        # now roll the underlying database back
        self._account_db.discard(account_snapshot)
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();
            }
        }
    }
788683
public synchronized void removeMPReadTransactions() {
        TransactionTask  task = m_backlog.peekFirst();
        while (task != null && task.getTransactionState().isReadOnly()) {
            task.getTransactionState().setDone();
            flush(task.getTxnId());
            task = m_backlog.peekFirst();
        }
    }
1337127
def revert(self):
        """"""
        index = self.get_stack_index()
        finfo = self.data[index]
        filename = finfo.filename
        if finfo.editor.document().isModified():
            self.msgbox = QMessageBox(
                    QMessageBox.Warning,
                    self.title,
                    _("All changes to <b>%s</b> will be lost."
                      "<br>Do you want to revert file from disk?"
                      ) % osp.basename(filename),
                    QMessageBox.Yes | QMessageBox.No,
                    self)
            answer = self.msgbox.exec_()
            if answer != QMessageBox.Yes:
                return
        self.reload(index)
1009662
def _reset_model(self, response):
        """"""

        # pylint: disable=no-member

        # Reset the model to the initial state
        self._provision_done = False    # Set back the provision flag
        self._changes.clear()           # Clear the changes

        # Process the raw data from the update response
        fields = self.process_raw_data(response)
        # Update the current model representation
        self._set_fields(fields)

        # Lock the current model
        self._provision_done = True