Restores the temporarily overridden default error handling mechanism back to the default.
509660
public function restore()
    {
        if ($this->intStoredErrorLevel !== null) {
            if ($this->intStoredErrorLevel != -1) {
                error_reporting($this->intStoredErrorLevel);
            }
            restore_error_handler();
            $this->intStoredErrorLevel = null;
        }
    }
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;
}
1015343
def reset(cls):
        
        cls.debug = False
        cls.disabled = False
        cls.overwrite = False
        cls.playback_only = False
        cls.recv_timeout = 5
        cls.recv_endmarkers = []
        cls.recv_size = None
998843
def cleanup(self):
    
    # Move any existing errors to global errors
    self.global_errors.extend(self.errors)
    self.errors = []

    # Make the previous module's output available to the next module
    self.input = self.output
    self.output = []
1033818
public void reset() {

        this.pp.setIndex(0);
        this.pp.setErrorIndex(-1);
        this.errorMessage = "";
        this.warning = false;
        this.rawValues = null;

    }
1290369
private DialogInterface.OnClickListener createRestoreDefaultsListener() {
        return new DialogInterface.OnClickListener() {

            @Override
            public void onClick(final DialogInterface dialog, final int which) {
                restoreDefaults();
            }

        };
    }
233714
def reset(self):
        
        self.operations = []
        self._last_overflow = 'WRAP'
        self.overflow(self._default_overflow or self._last_overflow)
362709
public Try<V> recover(Function<Throwable, V> recoverFunction) {
        if (isFailure()) {
            return succeeded(recoverFunction.apply(throwable));
        }
        return this;
    }
1050976
public function restore()
	{
		$this->master->params()->rollback();
		$this->slave->params()->rollback();

		// We should also save these so we know any changes have been fully reversed
		$this->master->save();
		$this->slave->save();
	}
288837
public static function resetTrap()
    {
        if (!self::$registered) {
            throw new RuntimeException('Signal handler has not been registered');
        }
        if (!pcntl_signal_dispatch()) {
            throw new RuntimeException(
                sprintf('Call to pcntl_signal_dispatch() failed (PHP error: "%s")', @error_get_last()['message'])
            );
        }
        if (!pcntl_signal(SIGINT, SIG_DFL)) {
            throw new RuntimeException(
                sprintf(
                    'Could not relinquish control to PHP by registering default signal handler (PHP error: "%s")',
                    @error_get_last()['message']
                )
            );
        }

        self::$registered = false;
    }
605687
async def restore_default_configuration(self):
        
        self._data = await self._handler.restore_default_configuration(
            system_id=self.system_id)
57740
function() {
		var e = this.originalEvent;
		this.defaultPrevented = true;
    this.isDefaultPrevented = returnTrue;
		if ( e && e.preventDefault ){ e.preventDefault(); }
	}
118307
def restore_default_configuration():
    

    def restore(target, default_value):
        if target == default_value:
            return default_value

        if not isinstance(target, RedirectBuffer):
            return target

        try:
            target.active = False
            target.close()
        except Exception:
            pass

        return default_value

    sys.stdout = restore(sys.stdout, sys.__stdout__)
    sys.stderr = restore(sys.stderr, sys.__stderr__)
212129
private void restoreBackupIncremental() {

        try {
            if (fa.isStreamElement(fileName + ".backup")) {
                RAShadowFile.restoreFile(fileName + ".backup",
                                         fileName + ".data");
            } else {
/*
                // this is to ensure file has been written fully but it is not necessary
                // as semantics dictate that if a backup does not exist, the file
                // was never changed or was fully written to
                if (FileUtil.exists(cacheFileName)) {
                    int flags = DataFileCache.getFlags(cacheFileName);

                    if (!BitMap.isSet(flags, DataFileCache.FLAG_ISSAVED)) {
                        FileUtil.delete(cacheFileName);
                    }
                }
*/
            }

            deleteBackup();
        } catch (IOException e) {
            throw Error.error(ErrorCode.FILE_IO_ERROR, fileName + ".backup");
        }
    }
716263
private void restoreBackup() {

        if (incBackup) {
            restoreBackupIncremental();

            return;
        }

        // in case data file cannot be deleted, reset it
        DataFileCache.deleteOrResetFreePos(database, fileName + ".data");

        try {
            FileArchiver.unarchive(fileName + ".backup", fileName + ".data",
                                   database.getFileAccess(),
                                   FileArchiver.COMPRESSION_ZIP);
        } catch (Exception e) {
            throw Error.error(ErrorCode.FILE_IO_ERROR,
                              ErrorCode.M_Message_Pair, new Object[] {
                fileName + ".backup", e.toString()
            });
        }
    }
543292
public final void restoreDefaults() {
        SharedPreferences sharedPreferences = getPreferenceManager().getSharedPreferences();

        if (getPreferenceScreen() != null) {
            restoreDefaults(getPreferenceScreen(), sharedPreferences);
        }
    }
634356
private static function restoreIni()
    {
        foreach (self::$origIniSettings as $settingName => $settingValue) {
            switch ($settingName) {
                case 'error_reporting':
                    error_reporting($settingValue);
                    break;
                default:
                    ini_set($settingName, $settingValue);
            }
        }
    }