/* (non-Javadoc)
@see com.ibm.jaggr.core.config.IConfigListener#configLoaded(com.ibm.jaggr.core.config.IConfig, long)
4735
@Override
	public void configLoaded(IConfig config, long sequence) {
		final String sourceMethod = "configLoaded"; //$NON-NLS-1$
		final boolean isTraceLogging = log.isLoggable(Level.FINER);
		if (isTraceLogging) {
			log.entering(sourceClass, sourceMethod, new Object[] { aggregator });
		}
		// update the config property
		isIncludeAMDPaths = TypeUtil.asBoolean(
				config.getProperty(CSSModuleBuilder.INCLUDEAMDPATHS_CONFIGPARAM, Boolean.class)
		);
		if (isTraceLogging) {
			log.exiting(sourceClass, sourceMethod);
		}
	}
39501
private void configure(Map<String, Object> configuration) throws IOException {
        List<TaskConfig> configList = new ArrayList<TaskConfig>();
        configList.addAll(parseConfig(configuration));
        for (TaskConfig taskConfig : configList) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Task config " + this, taskConfig);
            }
            if (taskConfig.getEnabled()) {
                //Create the task, set the configuration and add it to the map if it's not already present.
                Task task = new TaskImpl();
                if (task != null) {
                    //Check if task already exist (by check if the source id is already in the taskMap)
                    //if not, we set the task with the new config and get appropriate handler based on the type of source
                    //else, we simply replace the config in the original task with the modified config
                    if (!taskMap.containsKey(taskConfig.sourceId())) {
                        task.setHandlerName(getHandlerName());
                        task.setConfig(taskConfig);
                        taskMap.putIfAbsent(taskConfig.sourceId(), task);
                    } else {
                        taskMap.get(taskConfig.sourceId()).setConfig(taskConfig);
                    }
                }
            }
        }
    }
901308
@Override
    public void setConfigs(List<String> configs) {
        configList.clear();
        if (configs != null) {
            configList.addAll(configs);
        }
    }
771554
public function onConfigUpdated()
    {
        if ($this->xmppclient) {
            $this->xmppclient->config = $this->config;
            $this->xmppclient->onConfigUpdated();
        }
    }
896691
function () {
        
            SimpleDialog.superclass.initDefaultConfig.call(this);
        
            // Add dialog config properties //
        
            /**
            * Sets the informational icon for the SimpleDialog
            * @config icon
            * @type String
            * @default "none"
            */
            this.cfg.addProperty(DEFAULT_CONFIG.ICON.key, {
                handler: this.configIcon,
                value: DEFAULT_CONFIG.ICON.value,
                suppressEvent: DEFAULT_CONFIG.ICON.suppressEvent
            });
        
            /**
            * Sets the text for the SimpleDialog
            * @config text
            * @type String
            * @default ""
            */
            this.cfg.addProperty(DEFAULT_CONFIG.TEXT.key, { 
                handler: this.configText, 
                value: DEFAULT_CONFIG.TEXT.value, 
                suppressEvent: DEFAULT_CONFIG.TEXT.suppressEvent, 
                supercedes: DEFAULT_CONFIG.TEXT.supercedes 
            });
        
        }
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);
    }
548546
@Override
    public void setConfigDynamically(Config viewConfig) {

        if(viewConfig instanceof MapViewConfig) {
            MapViewConfig newMapViewConfig = (MapViewConfig) viewConfig;
            updateMapViewConfig(newMapViewConfig);
        }
    }
602703
static public void loadConfigs(){
        IConfigLoader configLoader;
        Map<String, Object> startupConfig = Config.getInstance().getJsonMapConfig(STARTUP_CONFIG_NAME);
        if(startupConfig ==null || startupConfig.get(CONFIG_LOADER_CLASS) ==null){
            configLoader = new DefaultConfigLoader();
        }else{
            try {
                Class clazz = Class.forName((String) startupConfig.get(CONFIG_LOADER_CLASS));
                configLoader = (IConfigLoader) clazz.getConstructor().newInstance();
            } catch (Exception e) {
                throw new RuntimeException("configLoaderClass mentioned in startup.yml could not be found or constructed", e);
            }
        }
        configLoader.init();
    }
185361
private void initTemplateEngineCfg() {
        configuration = new Configuration();
        configuration.setDefaultEncoding("UTF-8");
        final ServletContext servletContext = AbstractServletListener.getServletContext();

        configuration.setServletContextForTemplateLoading(servletContext, "/plugins/" + dirName);
        LOGGER.log(Level.DEBUG, "Initialized template configuration");
    }
956519
@VisibleForTesting
  void addConfiguration(CombinedConfiguration combinedConfiguration,
      final Configuration configuration) {
    if (configuration instanceof AbstractConfiguration) {
      combinedConfiguration.addConfiguration((AbstractConfiguration) configuration);
    } else {
      combinedConfiguration.addConfiguration(setupConfiguration(new AbstractConfiguration() {

        @Override
        public boolean isEmpty() {
          return configuration.isEmpty();
        }

        @Override
        public Object getProperty(String key) {
          return configuration.getProperty(key);
        }

        @Override
        @SuppressWarnings("rawtypes") // No rawtype in class.
        public Iterator getKeys() {
          return configuration.getKeys();
        }

        @Override
        public boolean containsKey(String key) {
          return configuration.containsKey(key);
        }

        @Override
        protected void addPropertyDirect(String key, Object value) {
          configuration.addProperty(key, value);
        }
      }));
    }
  }
941376
@Override
	public synchronized void configChanged(Properties newConfig) {
		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug("Reloading Jawr configuration");
		}
		try {
			// Initialize the Thread local for the Jawr context
			ThreadLocalJawrContext.setJawrConfigMgrObjectName(JmxUtils.getMBeanObjectName(servletContext, resourceType,
					jawrConfig.getProperty(JawrConstant.JAWR_JMX_MBEAN_PREFIX)));

			// clears resource bundle cache for the refresh
			ResourceBundle.clearCache();
			StopWatch stopWatch = ThreadLocalJawrContext.getStopWatch();
			if (stopWatch != null && stopWatch.isRunning()) {
				stopWatch.stop();
			}

			Properties props = propertiesSource.getConfigProperties();
			// override the properties if needed
			if (this.overrideProperties != null) {
				props.putAll(overrideProperties);
			}
			props.putAll(newConfig);

			initializeJawrContext(props);

			if (LOGGER.isDebugEnabled()) {
				LOGGER.debug("Jawr configuration succesfully reloaded. ");
			}

		} catch (InterruptBundlingProcessException e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(resourceType + " bundling process Interrupted");
			}
		} catch (Exception e) {
			throw new BundlingProcessException("Error reloading Jawr config: " + e.getMessage(), e);
		} finally {

			// Reset the Thread local for the Jawr context
			ThreadLocalJawrContext.reset();
		}

	}
23181
private void parseLoggingConfig(final Node node, final ConfigSettings config)
	{

		String name;
		String value;
		Node nnode;
		NodeList list = node.getChildNodes();

		int length = list.getLength();
		for (int i = 0; i < length; i++) {
			nnode = list.item(i);

			name = nnode.getNodeName().toUpperCase();
			if (name.equals(KEY_ROOT_FOLDER)) {

				value = nnode.getChildNodes().item(0).getNodeValue();
				value = value.substring(1, value.length() - 1);

				config.setConfigParameter(
						ConfigurationKeys.LOGGING_PATH_DIFFTOOL, value);

			}
			else if (name.equals(SUBSUBSECTION_DIFF_TOOL)) {

				parseLoggerConfig(nnode, config, null,
						ConfigurationKeys.LOGGING_LOGLEVEL_DIFFTOOL);

			}
		}
	}
491107
@Override
	public void configure(Map configurationValues) {
		if ( gridDialect instanceof Configurable ) {
			( (Configurable) gridDialect ).configure( configurationValues );
		}
	}
963948
public static boolean isHavePathSelfConfig(IConfigKeyWithPath key) {
        String configAbsoluteClassPath = key.getConfigPath();
        return isSelfConfig(configAbsoluteClassPath, key);
    }
529387
protected boolean isConfigTrue(IConfigKey key) {
        String value = getConfig(key);
        if (value == null) {
            return false;
        }
        value = value.toLowerCase();
        return TRUE.equals(value);
    }
1022581
private void setParentIcon(boolean iconify) {
        if (rootParent instanceof JFrame) {
            JFrame frame = (JFrame) rootParent;
            int    state = frame.getExtendedState();

            ((JFrame) rootParent).setExtendedState(iconify ? state | Frame.ICONIFIED : state & ~Frame.ICONIFIED);
        }
    }
437773
protected void config() {
		objectMapper.configure(com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
		objectMapper.configure(com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER, true);
	}