Restores any found saved settings
543698
public void restoreSavedSettings() {
        if (mCallbacks.loadExtensionSetting(SETTING_PROXY) != null) {
            jCheckBoxProxy.setSelected(getSetting(SETTING_PROXY));
        }
        if (mCallbacks.loadExtensionSetting(SETTING_REPEATER) != null) {
            jCheckBoxRepeater.setSelected(getSetting(SETTING_REPEATER));
        }
        if (mCallbacks.loadExtensionSetting(SETTING_SCANNER) != null) {
            jCheckBoxScanner.setSelected(getSetting(SETTING_SCANNER));
        }
        if (mCallbacks.loadExtensionSetting(SETTING_INTRUDER) != null) {
            jCheckBoxIntruder.setSelected(getSetting(SETTING_INTRUDER));
        }
        if (mCallbacks.loadExtensionSetting(SETTING_SEQUENCER) != null) {
            jCheckBoxSequencer.setSelected(getSetting(SETTING_SEQUENCER));
        }
        if (mCallbacks.loadExtensionSetting(SETTING_SPIDER) != null) {
            jCheckBoxSpider.setSelected(getSetting(SETTING_SPIDER));
        }
        if (mCallbacks.loadExtensionSetting(SETTING_EXTENDER) != null) {
            jCheckBoxExtender.setSelected(getSetting(SETTING_EXTENDER));
        }
    }
1209622
def save(self, filename, verbose=False):
        
        with open(filename, 'w') as fid:
            json.dump(self._conf, fid, indent=4)
        if verbose:
            print('Saved settings in ' + filename)
43946
private void restoreData() {
		Map<String, ?> map = preferenceUtils.getAll();
		Set<String> strings = map.keySet();

		for (String string : strings) {
			if (string.startsWith(SharedPreferenceUtils.keyTestMode)) {
				preferenceUtils.restoreKey(string);
			}
		}

		refreshKeyValues();

	}
523566
def _restore(self, value):
        """"""

        items, subs = value
        self.clear()
        for key, value in items:
            self[key] = value
            if key in subs:
                value.sub_frames._restore(subs[key])
747480
function restore() {
    var data = store.get() || {};
    addEvent('load', function () {
      //console.log('scrolling to', data.y);
      window.scrollTo(data.x, data.y);
    });
  }
354916
def restore
      return unless File.exist?(Setting[:histfile])

      File.readlines(Setting[:histfile]).reverse_each { |l| push(l.chomp) }
    end
991359
protected function resetSettings()
    {
        $this->controlAccess('module_edit');
        $this->module->setSettings('frontend', array());
        $this->redirect('', $this->text('Settings have been reset to default values'), 'success');
    }
675702
public void restoreAttributes()
    {
        String attrName = getScopedName( STORED_ATTRS_ATTR );
        Map savedAttrs = ( Map ) getSession().getAttribute( attrName );

        if ( savedAttrs != null )
        {
            setAttributeMap( savedAttrs );
        }
    }
851664
public void restoreAfterSafeModeRestart() {
    // Put the sessionsToCtxFromDisk entries into their respective
    // SessionNotifierThreads instances
    for (Map.Entry<String, SessionNotificationCtx> entry :
          sessionsToCtxFromDisk.entrySet()) {
      // The conf and the conf related properties are missing in the
      // sessionsToCtx objects
      entry.getValue().setConf(conf);
      handleToNotifier(entry.getKey()).sessionsToCtx.put(entry.getKey(),
                                                          entry.getValue());
      sessionsToCtxFromDisk.remove(entry);
    }

    // Put the deletedSessions into the the respective SessionNotifierThreads
    for (String deletedSessionHandle : deletedSessionsFromDisk) {
      SessionNotifierThread notifierThread =
        handleToNotifier(deletedSessionHandle);
      if (notifierThread.sessionsToCtx.get(deletedSessionHandle) != null) {
        notifierThread.deletedSessions.put(deletedSessionHandle,
                                            notifierThread);
      }
      deletedSessionsFromDisk.remove(deletedSessionHandle);
    }

    // We can now start the notifier threads
    for (int i = 0; i < numNotifierThreads; i++) {
      notifierThreads[i].start();
    }
  }
667439
def restore_state(self):
        """"""
        # restore last source path
        last_source_path = setting(
            'lastSourceDir', self.default_directory, expected_type=str)
        self.source_directory.setText(last_source_path)

        # restore path pdf output
        last_output_dir = setting(
            'lastOutputDir', self.default_directory, expected_type=str)
        self.output_directory.setText(last_output_dir)

        # restore default output dir combo box
        use_default_output_dir = bool(setting(
            'useDefaultOutputDir', True, expected_type=bool))
        self.scenario_directory_radio.setChecked(
            use_default_output_dir)
406741
def restore(self):
        
        setattr(self, self.get_deleted_at_column(), None)

        self.set_exists(True)

        result = self.save()

        return result
487500
function reset() {
  const oldOptions = options()
  options({
    wishes: [],
    noWishMerge: true,
    previousId: 0,
    enteredMagicWords: {},
    context: _defaultContext,
    previousContext: _defaultContext,
    enabled: true,
  })
  return oldOptions
}
1336728
function restore() {
    if (isOriginal) return;
    else isOriginal = true;
    ['log', 'debug', 'info', 'warn', 'error'].forEach((item) => {
        console[item] = originalConsoleFunctions[item];
    });
}
500777
def opt_restore(prefix, opts):
    

    return {prefix + name: value for name, value in opts.items()}
919493
public function reset(){
    	$originalSettings = $this->settings;
    	$this->settings = array();
    	if(file_put_contents($this->cacheFileName, "{}") === FALSE){
    		$this->settings = $originalSettings;
    		return FALSE;
    	}
    	return TRUE;
    }
1242229
def _reset_changes(self):
        """"""
        self._original = {}
        if self.last_updated is not None:
            self._original['last_updated'] = self.last_updated
867543
def restoreSettings(self, settings):
        
        key     = self.objectName()
        value   = unwrapVariant(settings.value('%s/profile' % key))
        
        if not value:
            self.reset(force = True)
            return False
            
        profile = value
        
        # restore the view type settings
        for viewType in self.viewTypes():
            viewType.restoreGlobalSettings(settings)
        
        # restore the profile
        self.restoreProfile(XViewProfile.fromString(profile))
        
        if not self.views():
            self.reset(force = True)
        
        return True