DS method for runtime updates to configuration without stopping and
restarting the component.

@param config
436538
@Modified
    protected void modified(Map<String, Object> config) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Config modified: " + this);
        }

        if (null == config) {
            return;
        }
        final String ENC = "encoding.";
        final String CONV = "converter.";
        for (Map.Entry<String, Object> entry : config.entrySet()) {
            String key = entry.getKey();
            int len = key.length();
            try {
                if (len > ENC.length() && key.startsWith(ENC)) {
                    String value = (String) entry.getValue();
                    localeMap.put(key.substring(ENC.length()), value);
                } else if (len > CONV.length() && key.startsWith(CONV)) {
                    String value = (String) entry.getValue();
                    converterMap.put(key.substring(CONV.length()).toLowerCase(),
                                     value.toLowerCase());
                }
            } catch (Throwable t) {
                FFDCFilter.processException(t,
                                            "EncodingUtils.processConfig", "1",
                                            new Object[] { key, entry.getValue() });
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                    Tr.event(tc, "Invalid property: [" + key
                                 + "]=[" + config.get(key) + "]");
                }
            }
        } // loop on the entries
    }
745793
protected function configChanged() {
    if (self::$logger->isDebugEnabled()) {
      self::$logger->debug("Configuration is changed");
    }
    if (ObjectFactory::isConfigured()) {
      if (self::$logger->isDebugEnabled()) {
        self::$logger->debug("Emitting change event");
      }
      ObjectFactory::getInstance('eventManager')->dispatch(ConfigChangeEvent::NAME,
              new ConfigChangeEvent());
    }
  }
572954
public static void deploy(Config config) {
	if (!contextIsValid(config)) return;

	synchronized (config) {
	    Resource dir = config.getDeployDirectory();
	    if (!dir.exists()) dir.mkdirs();

	    Resource[] children = dir.listResources(ALL_EXT);
	    Resource child;
	    String ext;
	    for (int i = 0; i < children.length; i++) {
		child = children[i];
		try {
		    // Lucee archives
		    ext = ResourceUtil.getExtension(child, null);
		    if ("lar".equalsIgnoreCase(ext)) {
			// deployArchive(config,child,true);
			XMLConfigAdmin.updateArchive((ConfigImpl) config, child, true);
		    }

		    // Lucee Extensions
		    else if ("lex".equalsIgnoreCase(ext)) XMLConfigAdmin._updateRHExtension((ConfigImpl) config, child, true);

		    // Lucee core
		    else if (config instanceof ConfigServer && "lco".equalsIgnoreCase(ext)) XMLConfigAdmin.updateCore((ConfigServerImpl) config, child, true);
		}
		catch (Throwable t) {
		    ExceptionUtil.rethrowIfNecessary(t);
		    Log log = config.getLog("deploy");
		    log.error("Extension", t);
		}
	    }
	}
    }
1105439
function(config) {
			if (initialized) {
				error(new Error('Cannot set global configuration after application initialization'));
				return;
			}

			for (var prop in config) {
				if (config.hasOwnProperty(prop)) {
					globalConfig[prop] = config[prop];
				}
			}
		}
1172690
public static synchronized void update(Map<String, Object> newConfig) {
        if (newConfig == null)
            throw new NullPointerException("Updated config must not be null");

        boolean traceWasDisabled = !TraceComponent.isAnyTracingEnabled();

        // Update the logging configuration
        LogProviderConfig config = loggingConfig.get().get();
        if (config != null) {
            config.update(newConfig);

            Object o = newConfig.get("suppressSensitiveTrace");

            if (o != null) {
                if (o instanceof String) {
                    suppressSensitiveTrace = Boolean.parseBoolean((String) o);
                } else if (o instanceof Boolean) {
                    suppressSensitiveTrace = (Boolean) o;
                }
                if (suppressSensitiveTrace == true && safeLevelsIndex == null) {
                    setupSafeLevelsIndex();
                }
            }

            TraceSpecification newTs = setTraceSpec(config.getTraceString());

            // For updates only, warn if there are strings that we don't know
            if (defaultUpdated && newTs != null)
                newTs.warnUnmatchedSpecs();

            // we've updated the defaults from server.xml (we can set this a million times.. 
            // first pass through is the key.. 
            defaultUpdated = true;

            // Propagate updates to the delegate
            getDelegate().update(config);
        }

        // issue warning if trace has been enabled and there's no instrumentation agent
        if (!instrumentationAvailable && traceWasDisabled && TraceComponent.isAnyTracingEnabled()) {
            Tr.warning(TraceSpecification.getTc(), "INSTRUMENTATION_SERVICE_UNAVAILABLE");
        }
    }
696140
public static synchronized void configure(final ApiConfiguration config) {
		
		ApiConfiguration.Builder builder = ApiConfiguration.newBuilder();
		
		builder.apiUrl(config.getApiUrl());
		builder.apiKey(config.getApiKey());
		builder.application(config.getApplication());
		builder.environment(config.getEnvironment());
		
		if (config.getEnvDetail() == null)
		{
			builder.envDetail(EnvironmentDetails.getEnvironmentDetail(config.getApplication(), config.getEnvironment()));
		}
		else
		{
			builder.envDetail(config.getEnvDetail());
		}
		
		CONFIG = builder.build();
	}
781369
@Override
    public void init(final CONFIG config) throws InitializationException, InterruptedException {
        synchronized (CONFIG_LOCK) {
            try {
                if (config == null) {
                    throw new NotAvailableException("config");
                }
                currentScope = detectScope(config);
                try {
                    applyConfigUpdate(config);
                } catch (CouldNotPerformException ex) {
                    ExceptionPrinter.printHistory("Could not apply config update for " + this, ex, logger);
                    try {
                        if (JPService.getProperty(JPTestMode.class).getValue()) {
                            throw new FatalImplementationErrorException("Could not apply config update for " + this, this, ex);
                        }
                    } catch (JPNotAvailableException ex1) {
                        // to nothing if property could not be resovled.
                    }
                }
                super.init(currentScope);
            } catch (CouldNotPerformException ex) {
                throw new InitializationException(this, ex);
            }
        }
    }
1079865
@Override
	public void applyConfig(final ConfigSettings config)
	{
		Object o = config
				.getConfigParameter(ConfigurationKeys.COUNTER_FULL_REVISION);
		if (o != null) {
			this.fullRevisionField.setText(Integer.toString((Integer) o));
		}
		else {
			this.fullRevisionField.setText("");
		}

		o = config
				.getConfigParameter(ConfigurationKeys.VALUE_MINIMUM_LONGEST_COMMON_SUBSTRING);
		if (o != null) {
			this.minimumCommonSequenceField.setText(Integer
					.toString((Integer) o));
		}
		else {
			this.minimumCommonSequenceField.setText("");
		}
	}
674062
public void init(String name, Map<String,Object> config) {
        this.name = name;
        this.config = config;
        this.run = true;
        this.stopped = false;
    }
1071794
public static function setConfig(Config $config): void
    {
        if ($config->name() == 'application') {
            throw new ConfigException('Can\'t set config under \'application\' name; name \'application\' is not permitted because it shouldn\'t be possible to change those settings in runtime');
        }

        static::$configs[$config->name()] = $config;
    }
425143
void updateListenersWithNewConfiguration(T newConfiguration) {
        for (ConfigurationListener<T> listener : listeners) {
            try {
                listener.updated(newConfiguration);
            } catch (Exception e) {
                logger.error("Updating a listener with new configuration failed.", e);
            }
        }
    }
98774
protected final void set(M config) {
        ArrayList<WeakReference<ConfigListener<M,F>>> iterateOver;
        synchronized (this) {
            M old = instance.get();
            if (old == config || (old != null && old.equals(config))) {
                return;
            }

            instance.set(config);
            lastUpdateTimestamp.set(clock.millis());
            listeners.removeIf(ref -> ref.get() == null);
            iterateOver = new ArrayList<>(listeners);
        }
        iterateOver.forEach(ref -> {
            ConfigListener<M,F> listener = ref.get();
            if (listener != null) {
                try {
                    listener.onConfigChange(config);
                } catch (Exception ignore) {
                    // Ignored... TODO: At least log?
                }
            }
        });
    }
239485
public void setLynxConfig(LynxConfig lynxConfig) {
    validateLynxConfig(lynxConfig);
    boolean hasChangedLynxConfig = !this.lynxConfig.equals(lynxConfig);
    if (hasChangedLynxConfig) {
      this.lynxConfig = (LynxConfig) lynxConfig.clone();
      updateFilterText();
      updateAdapter();
      updateSpinner();
      presenter.setLynxConfig(lynxConfig);
    }
  }
157927
public void configure(ConfigParams config) {
		ConfigParams parameters = config.getSection("parameters");
		if (parameters.size() > 0) {
			_parameters = parameters;
		}
	}
313282
@Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);

        mTitleView = null;
        mSubtitleView = null;
        mTitleUpView = null;
        if (mTitleLayout != null && mTitleLayout.getParent() == this) {
            removeView(mTitleLayout);
        }
        mTitleLayout = null;
        if ((mDisplayOptions & ActionBar.DISPLAY_SHOW_TITLE) != 0) {
            initTitle();
        }

        if (mTabScrollView != null && mIncludeTabs) {
            ViewGroup.LayoutParams lp = mTabScrollView.getLayoutParams();
            if (lp != null) {
                lp.width = LayoutParams.WRAP_CONTENT;
                lp.height = LayoutParams.MATCH_PARENT;
            }
            mTabScrollView.setAllowCollapse(true);
        }
    }
631378
@Override
    public void reload(ResourceConfig configuration) {
        ApplicationHandler applicationHandler = new ApplicationHandler(configuration, null, locator);
        applicationHandlerDelegate = new DefaultApplicationHandlerDelegate(applicationHandler);
        getApplicationHandler().onReload(this);
        applicationHandler.onStartup(this);
    }
415715
@Override
    public void applyConfiguration(@NonNull Configuration configuration) {
        if (!wasInitialised.get()) {
            globalLock.writeLock().lock();

            this.configuration = configuration;

            globalLock.writeLock().unlock();
        }
    }