Merge in a configuration and return a ProcessingParameters object representing
the merged values

@param pConfig config to merge in
@return a new ProcessingParameters instance if the given config is not null. Otherwise this object
is returned.
167567
public ProcessingParameters mergedParams(Map<String, String> pConfig) {
        if (pConfig == null) {
            return this;
        } else {
            Map<ConfigKey,String> newParams = new HashMap<ConfigKey, String>();
            newParams.putAll(params);
            newParams.putAll(convertToConfigMap(pConfig));
            return new ProcessingParameters(newParams, pathInfo);
        }
    }
685887
protected void configurePlugins(ProcessEngineConfigurationImpl configuration, ProcessEngineXml processEngineXml, ClassLoader classLoader) {

    for (ProcessEnginePluginXml pluginXml : processEngineXml.getPlugins()) {
      // create plugin instance
      Class<? extends ProcessEnginePlugin> pluginClass = loadClass(pluginXml.getPluginClass(), classLoader, ProcessEnginePlugin.class);
      ProcessEnginePlugin plugin = createInstance(pluginClass);

      // apply configured properties
      Map<String, String> properties = pluginXml.getProperties();
      PropertyHelper.applyProperties(plugin, properties);

      // add to configuration
      configuration.getProcessEnginePlugins().add(plugin);
    }

  }
334132
public static FreeContext mergeFrom(FreePOptions.Builder optionsBuilder) {
    FreePOptions masterOptions = FileSystemOptions.freeDefaults(ServerConfiguration.global());
    FreePOptions.Builder mergedOptionsBuilder =
        masterOptions.toBuilder().mergeFrom(optionsBuilder.build());
    return create(mergedOptionsBuilder);
  }
340257
public static void checkCacheConfig(CacheConfig cacheConfig, CacheMergePolicyProvider mergePolicyProvider) {
        checkCacheConfig(cacheConfig.getInMemoryFormat(), cacheConfig.getEvictionConfig(), cacheConfig.getMergePolicy(),
                cacheConfig, mergePolicyProvider);
    }
366828
public ProcessingParameters getProcessingParameters(Map<String,String> pParams) {
        Map<ConfigKey,String> procParams = ProcessingParameters.convertToConfigMap(pParams);
        for (Map.Entry<ConfigKey,String> entry : globalConfig.entrySet()) {
            ConfigKey key = entry.getKey();
            if (key.isRequestConfig() && !procParams.containsKey(key)) {
                procParams.put(key,entry.getValue());
            }
        }
        return new ProcessingParameters(procParams,pParams.get(PATH_QUERY_PARAM));
    }
1133411
def config(param_map, mastercode=DEFAULT_MASTERCODE):
    """"""
    pmap = {Config.mastercode: mastercode}
    pmap.update(param_map)
    processed_params = dict(_process_params(pmap))
    return processed_params
623459
protected Server getServer(MuleAgentConfig pConfig) {
        Server newServer = new Server();

        Connector connector = createConnector(newServer);
        if (pConfig.getHost() != null) {
            ClassUtil.applyMethod(connector, "setHost", pConfig.getHost());
        }
        ClassUtil.applyMethod(connector,"setPort",pConfig.getPort());

        newServer.setConnectors(new Connector[]{connector});
        return newServer;
    }
115466
public function postProcessConfiguration(array $config): array
    {
        $config = $this->fixUpViewConfig($config);

        $processor = new ConfigurationProcessor($this->container, $this->extension->getAlias());
        foreach (array_keys($config) as $key) {
            if ($key === 'system' || !in_array($key, self::SITEACCCESS_AWARE_SETTINGS, true)) {
                continue;
            }

            is_array($config[$key]) ?
                $processor->mapConfigArray($key, $config, ContextualizerInterface::MERGE_FROM_SECOND_LEVEL) :
                $processor->mapSetting($key, $config);
        }

        $designList = array_keys($config['design_list']);
        foreach ($config['system'] as $scopeConfig) {
            $this->validateCurrentDesign($scopeConfig['design'], $designList);
        }

        return $config;
    }
1017973
public function merge_config($config, $localconfig) {

        if (!is_array($config) && !is_array($localconfig)) {
            return $localconfig;
        }

        // Local overrides also deeper default values.
        if (is_array($config) && !is_array($localconfig)) {
            return $localconfig;
        }

        foreach ($localconfig as $key => $value) {

            // If defaults are not as deep as local values let locals override.
            if (!is_array($config)) {
                unset($config);
            }

            // Add the param if it doesn't exists or merge branches.
            if (empty($config[$key])) {
                $config[$key] = $value;
            } else {
                $config[$key] = $this->merge_config($config[$key], $localconfig[$key]);
            }
        }

        return $config;
    }
564600
public static Configuration merge(final Configuration... configurations) {
    return Tang.Factory.getTang().newConfigurationBuilder(configurations).build();
  }
172324
function(config) {
			if (config.env && typeof config.env === "object") {
				return this.merge(this.createEnvironmentConfig(config.env), config);
			}

			return config;
		}
230950
function merge_config(top_config, base_config)
{
    for (var option in top_config)
    {
        if (Array.isArray(top_config[option])) // handle array elements in the same order
        {
            if (!Array.isArray(base_config[option]))
                base_config[option] = top_config[option];
            else
            {
                for(var i=0;i<top_config[option].length;i++)
                {
                    if (base_config[option].length <= i)
                        base_config[option].push(top_config[option][i]);
                    else
                        merge_config(top_config[option][i],base_config[option][i]);
                }
            } 
        }
        else if (typeof top_config[option] === "Object") // recurseively handle complex configurations
        {
            if (base_config[option] === undefined)
                base_config[option] = top_config[option];
            else
                merge_config(top_config[option], base_config[option]);
        }
        else
            base_config[option] = top_config[option];
    }

}
1349522
function (config) {
                if (typeof config !== 'object') {
                    throw new Error('You must provide a valid configuration object to the config setter.');
                }
                // combine config with default
                var mergedConfig = Object.assign({}, config);
                // add config to map
                this._config = new Map(Object.entries(mergedConfig));
            }
651664
void merge(final Config that) {
        that.entrySet().parallelStream().forEach(e -> props.setProperty(e.getKey(), e.getValue()));
        setMode(that.getMode());
    }
44842
final DynamoDBMapperConfig merge(final DynamoDBMapperConfig overrides) {
        return overrides == null || this == overrides ? this : builder().merge(this).merge(overrides).build();
    }
769018
public Object getConfigParameter(final ConfigurationKeys configParameter)
	{
		if (this.parameterMap.containsKey(configParameter)) {
			return this.parameterMap.get(configParameter);
		}

		return null;
	}
1211689
private void addJsr160DispatcherIfExternallyConfigured(Configuration pConfig) {
        String dispatchers = pConfig.get(ConfigKey.DISPATCHER_CLASSES);
        String jsr160DispatcherClass = "org.jolokia.jsr160.Jsr160RequestDispatcher";

        if (dispatchers == null || !dispatchers.contains(jsr160DispatcherClass)) {
            for (String param : new String[]{
                System.getProperty("org.jolokia.jsr160ProxyEnabled"),
                System.getenv("JOLOKIA_JSR160_PROXY_ENABLED")
            }) {
                if (param != null && (param.isEmpty() || Boolean.parseBoolean(param))) {
                    {
                        pConfig.updateGlobalConfiguration(
                            Collections.singletonMap(
                                ConfigKey.DISPATCHER_CLASSES.getKeyValue(),
                                (dispatchers != null ? dispatchers + "," : "") + jsr160DispatcherClass));
                    }
                    return;
                }
            }
            if (dispatchers == null) {
                // We add a breaking dispatcher to avoid silently ignoring a JSR160 proxy request
                // when it is now enabled
                pConfig.updateGlobalConfiguration(Collections.singletonMap(
                    ConfigKey.DISPATCHER_CLASSES.getKeyValue(),
                    Jsr160ProxyNotEnabledByDefaultAnymoreDispatcher.class.getCanonicalName()));
            }
        }
    }