reload_global `plname`

        Reload the *global* plugin named `plname`.  You should close
        all instances of the plugin before attempting to reload.
352428
def cmd_reload_global(self, plname):
        
        gpmon = self.fv.gpmon
        p_info = gpmon.get_plugin_info(plname)
        gpmon.stop_plugin(p_info)
        self.fv.update_pending(0.5)
        self.fv.mm.load_module(plname)
        gpmon.reload_plugin(plname)
        self.fv.start_global_plugin(plname)
        return True
1069310
def reload(self):
        
        if not isinstance(self.filename, string_types):
            raise ReloadError()

        filename = self.filename
        current_options = {}
        for entry in OPTION_DEFAULTS:
            if entry == 'configspec':
                continue
            current_options[entry] = getattr(self, entry)

        configspec = self._original_configspec
        current_options['configspec'] = configspec

        self.clear()
        self._initialise(current_options)
        self._load(filename, configspec)
16661
def reload_target!(options = {})
      old_options = @target_load_options || {}
      options = (@target_load_options || {}).merge(options)
      if options[:skip_first_time] && @target_load_count == 1
        @target_load_count += 1
      else
        load_target!(options.merge(reload: true))
      end
    end
283131
def unload_plugin(name)
      p = get_plugin(name)

      p.unload if p.respond_to?(:unload)
      Capistrano.remove_plugin(name)
    end
144057
def reload(self):
        
        # Get reload mode
        reload_mode = self._reload_mode

        # If reload mode is `exec`
        if self._reload_mode == self.RELOAD_MODE_V_EXEC:
            # Call `reload_using_exec`
            self.reload_using_exec()

        # If reload mode is `spawn_exit`
        elif self._reload_mode == self.RELOAD_MODE_V_SPAWN_EXIT:
            # Call `reload_using_spawn_exit`
            self.reload_using_spawn_exit()

        # If reload mode is `spawn_wait`
        elif self._reload_mode == self.RELOAD_MODE_V_SPAWN_WAIT:
            # Call `reload_using_spawn_wait`
            self.reload_using_spawn_wait()

        # If reload mode is none of above
        else:
            # Get error message
            error_msg = 'Invalid reload mode: {}.'.format(repr(reload_mode))

            # Raise error
            raise ValueError(error_msg)
362951
def reload_settings(*args, **kwargs):
    
    global settings
    setting, value = kwargs['setting'], kwargs['value']
    if setting == XRAY_NAMESPACE:
        settings = XRaySettings(value)
762863
def reload(self):
        

        if not self.fd.closed: self.fd.close()

        self.fd = open(self.fd.name, 'r')
        self.load()
84422
def _ensure_global(self, values=None):
        
        if self._gpayload is None:
            self._gpayload = values or {}
        self.enable()
933028
def reload(self):
        """"""
        for loader in self._loaders:
            loader.reload()

        self.varz = {}  # reset varz
        self._load()
576894
def make_module_reload_func(module_name=None, module_prefix='[???]', module=None):
    
    module = _get_module(module_name, module, register=False)
    if module_name is None:
        module_name = str(module.__name__)
    def rrr(verbose=True):
        """ Dynamic module reloading """
        if not __RELOAD_OK__:
            raise Exception('Reloading has been forced off')
        try:
            import imp
            if verbose and not QUIET:
                builtins.print('RELOAD: ' + str(module_prefix) + ' __name__=' + module_name)
            imp.reload(module)
        except Exception as ex:
            print(ex)
            print('%s Failed to reload' % module_prefix)
            raise
    # this doesn't seem to set anything on import *
    #_inject_funcs(module, rrr)
    return rrr
864909
def reload_source(self, name):
        

        src = self.roi.get_source_by_name(name)

        if hasattr(self.like.logLike, 'loadSourceMap'):
            self.like.logLike.loadSourceMap(str(name), True, False)
            srcmap_utils.delete_source_map(self.files['srcmap'], name)
            self.like.logLike.saveSourceMaps(str(self.files['srcmap']))
            self._scale_srcmap(self._src_expscale, check_header=False,
                               names=[name])
            self.like.logLike.buildFixedModelWts()
        else:
            self.write_xml('tmp')
            src = self.delete_source(name)
            self.add_source(name, src, free=True)
            self.load_xml('tmp')
501216
def reload!
      clear

      @mixins.each do |file|
        mixin(file)
      end

      @callbacks.each do |callback|
        callback.call(self)
      end
    end
893065
def reload_manifest(self, manifest):
        
        self._logger.debug("Reloading manifest for {}.".format(manifest.get("name", "Unnamed Plugin")))
        self._manifests.remove(manifest)
        self.load_manifest(manifest["path"])
        self._logger.debug("Manifest reloaded.")
1215194
public void reloadPlugin() {
        sendConsoleMessage(Level.INFO, "Starting up!");
        sendConsoleMessage(Level.INFO, "Loading the Configuration");
        config = new ConfigurationManager(serverCaller);
        mainConfig = config.loadFile(serverCaller.getDataFolder(), "config.yml");
        if (!mainConfig.has("System.Setup")) {
            initializeConfig();
        }
        if (!getMainConfig().has("System.Database.Prefix")) {
            getMainConfig().setValue("System.Database.Prefix", "cc3_");
        }

        languageManager = new LanguageManager(serverCaller, serverCaller.getDataFolder(), "lang.yml");
        loadLanguage();
        serverCaller.setCommandPrefix(languageManager.getString("command_prefix"));
        commandManager.setCurrentLevel(1);
        initialiseDatabase();
        updateDatabase();
        initializeCurrency();
        sendConsoleMessage(Level.INFO, getLanguageManager().getString("loading_default_settings"));
        loadDefaultSettings();
        sendConsoleMessage(Level.INFO, getLanguageManager().getString("default_settings_loaded"));
        startUp();
        sendConsoleMessage(Level.INFO, getLanguageManager().getString("ready"));

    }
972269
def reload_all_plugins(self, *args):
        
        for manifest in self._manifests[:]:
            if self.get_plugin(manifest["name"]) is not None:
                self.reload_plugin(manifest["name"], *args)
1344389
function globalReset (self) {
    // reset data for all instances
    _.each(global.__immutable_global__, instance => instance.reset())
    // reset internal data
    if (self) {
        global.__immutable_global__ = {}
    }
}
1016206
def reload(self):
        
        realData = self.load()
        self.clear()
        self.update(realData)