Gets called when config is activated/modified
327892
public static void setCustomProperties(Map<String, Object> d) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "setCustomProperties");
        }

        String ky;
        String propertyKey;

        // For comparison purposes we need the mixed case key strings coming from metatype.xml and server.xml to be in lower case.
        Set<String> newKeySet = new HashSet<String>();                                                
        for (String key:d.keySet()) {                                                                 
            newKeySet.add(key.toLowerCase());                                                         
        }                                                                                             

        // go through each entry that is in the set of keys that we are getting from metatype.xml and server.xml
        for (Map.Entry<String, Object> entry : d.entrySet()) {
            ky = entry.getKey();
            Object value = entry.getValue();
        
            // using the lower case value of short or long name that was configured
            // see if the string maps to one of the short names in our table.
            // if it matches then get the long name back.  otherwise keep the name as is.
            propertyKey = getStringKey(ky.toLowerCase());
            
            if (!ky.equalsIgnoreCase(propertyKey)) {
                // found in map - check existence of fully qualified prop as well
                // if we mapped to a new long name, see if it is already in the passed in data because
                // configured long names have priority, and if it is in the table elsewhere, then don't use
                // this mapped short name value, because the long name was set in server.xml
                if (newKeySet.contains(propertyKey)) {                                           
                    continue;
                }
            }
            
            // store all values as lower case, so as to read them later in a consistent fashion
            propertyKey =  propertyKey.toLowerCase();
            
            if (value instanceof String) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Key: " + propertyKey + "  type: String  value: " + value);
                }
                customProps.setProperty(propertyKey, (String) value);

            } else if (value instanceof Boolean) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Key: " + propertyKey + "  type: Boolean  value: " + ((Boolean) value).toString());
                }
                customProps.setProperty(propertyKey, ((Boolean) value).toString());

            } else if (value instanceof Integer) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Key: " + propertyKey + "  type: Integer  value: " + ((Integer) value).toString());
                }
                customProps.setProperty(propertyKey, ((Integer) value).toString());
            } else {
                // don't update, not a custom property we care about here
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Key not processed due to type, Key: " + propertyKey);
                }
            }
        }

        setCustomPropertyVariables(); //Need to update all the variables.

        setCustomizedDefaultValues(); //Customize default value depending on servlet level, initial size....etc..

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "setCustomProperties");
        }

    }
528574
function _handleConfigReset() {
    storage.removeDataByKey(savedConfigKey);

    let initString = getCurrentConfig();

    configEditor.setValue(prettifyInitString(initString));
}
1266349
function onConfigLoad() {
  var file = this._conf.get(ConfigName.LOGFILE);
  this._logger.level(this._conf.get(ConfigName.LOGLEVEL));
  //console.dir('config loaded.');
  if(file && !this._conf.get(ConfigName.DAEMONIZE)) {
    this._logger.stream(file);
  }
  if(this._conf.isDefault()) {
    this._logger.warning('no config file specified, using the default config');
  }

  // TODO: listen for log change events and toggle this
  this._scheduler.startDebugLog();

  this._scheduler.start(this._conf.get(ConfigName.HZ));
}
735863
protected void activate(BundleContext context, Map<String, Object> config) {
        bundleContext = context;
        this.config = config;
        modified(config);
    }
947269
protected function callConfiguratorsOnce()
    {
        if ($this->configuratorsCalled) {
            return;
        }

        foreach (static::$configurators as $listener) {
            call_user_func($listener, $this, $this->container);
        }

        $this->configuratorsCalled = true;
    }
852418
def on_load(self, event):
        ''''''
        dlg = wx.FileDialog(None, self.settings.get_title(), '', "", '*.*', wx.FD_OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            self.settings.load(dlg.GetPath())
        # update the controls with new values
        for label in self.setting_map.keys():
            setting = self.setting_map[label]
            ctrl = self.controls[label]
            value = ctrl.GetValue()
            if isinstance(value, str) or isinstance(value, unicode):
                ctrl.SetValue(str(setting.value))
            else:
                ctrl.SetValue(setting.value)
667904
@Activate
    protected void activate(ComponentContext context, Map<String, Object> config) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Activating ", config);
        }

        // handle config (such as TCP factory info) before registering
        // factories, as the register will trigger an automatic load of any
        // delayed configuration, and we need the config before that happens
        modified(config);

        this.chfw.registerFactory("TCPChannel", TCPChannelFactory.class);
        this.chfw.registerFactory("UDPChannel", UDPChannelFactory.class);

        instance.get().set(this); // required components have been activated
    }
1023690
public void finalizeConfig() {
        assert !configFinalized;

        try {
            retrieveEngine();
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
        configFinalized = true;
    }
491140
public function onConfigUpdated()
    {
        if ($this->pool) {
            $this->pool->config = $this->config;
            $this->pool->onConfigUpdated();
        }
    }
1353625
@Modified
    protected void modified(Map<String, Object> config) {
        if (null == config || config.isEmpty()) {
            return;
        }

        // config dictionaries are case-insensitive but case preserving per spec.
        // The default value type is String, unless a different type is indicated in metatype.

        setContextRootNotFoundMessage((String) config.get(PROP_VHOST_NOT_FOUND));

        enableWelcomePage(MetatypeUtils.parseBoolean(CONFIG_ALIAS,
                                                     PROP_ENABLE_WELCOME_PAGE,
                                                     config.get(PROP_ENABLE_WELCOME_PAGE),
                                                     true));

        setPadContextRootNotFoundMessage(MetatypeUtils.parseBoolean(CONFIG_ALIAS,
                                                                    PROP_PAD_VHOST_NOT_FOUND,
                                                                    config.get(PROP_PAD_VHOST_NOT_FOUND),
                                                                    false));

        origHeaderOrigin = MetatypeUtils.parseStringArray(CONFIG_ALIAS,
                                                          PROP_TRUSTED_PRIVATE_HEADER_ORIGIN,
                                                          config.get(PROP_TRUSTED_PRIVATE_HEADER_ORIGIN),
                                                          new String[] { "*" });

        origSensitiveHeaderOrigin = MetatypeUtils.parseStringArray(CONFIG_ALIAS,
                                                                   PROP_TRUSTED_SENSITIVE_HEADER_ORIGIN,
                                                                   config.get(PROP_TRUSTED_SENSITIVE_HEADER_ORIGIN),
                                                                   new String[] { "none" });

        parseTrustedPrivateHeaderOrigin(origHeaderOrigin, origSensitiveHeaderOrigin);
    }
1277524
protected function loadConfig()
    {
        $this->hook->trigger(self::HOOK_LOAD_CONFIG_BEFORE);
        $this->config->load();
        $this->hook->trigger(self::HOOK_LOAD_CONFIG_AFTER);
    }
570902
protected function initConfig()
    {
        if (isset($this->settings) || $this->settings->exists('config')) {
            $this->config->setDefinition($this->settings->get('config'));
        }
    }
458190
function (config) {
  events.EventEmitter.call(this);

  this.config = config;
  this.ignoreFiles = config.ignoreFiles || ['.codiusignore'];

  this._filesystem = Compiler.RealFilesystem;
}
823709
private void activate(ConfigKey key) {
        optionalValueOf(key).ifPresent((v) -> {
            this.properties.setProperty(key.name(), v.toString());
        }
266797
def on_config_value_changed(self, config_m, prop_name, info):
        
        config_key = info['args'][1]
        # config_value = info['args'][2]

        if config_key == "LIBRARY_PATHS":
            library_manager.refresh_libraries()
        elif config_key == "SHORTCUTS":
            self.refresh_shortcuts()
        elif config_key == "recently_opened_state_machines":
            self._update_recently_opened_state_machines()
691895
@Modified
    protected synchronized void modified(Map<String, Object> cfwConfiguration) {

        if (null == cfwConfiguration) {
            return;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Processing config", cfwConfiguration);
        }

        this.chfw.updateConfig(cfwConfiguration);
    }
930470
def reload(self):
        
        logging.debug('Reloading config file as files have been modified.')
        self.config.plugin, self.config.general = self.config.reload()
        logging.debug('Reloading plugins as files have been modified.')
        self.loader = plugin_manager.PluginLoader(
            self._plugin_path, self.config.plugin)
        self._plugin_mod_time = os.path.getmtime(self._plugin_path)
        self._config_mod_time = os.path.getmtime(self._config_file_path)