Used by instances of {@link ConfigDynamicMBean} to emit values back to the config system.

@param configName full configuration name from the descriptor
@param valueOpt   the value to be emitted (if different from last emission)
497383
@Override
    public void fireEvent(String configName, Optional<String> valueOpt)
    {
        this.emitEvent(configName, valueOpt);
    }
158717
public boolean optionMatches(String namePattern, String valuePattern) {
    Matcher nameMatcher = Pattern.compile(namePattern).matcher("");
    Matcher valueMatcher = Pattern.compile(valuePattern).matcher("");
    for (Map.Entry<ProtoMember, Object> entry : map.entrySet()) {
      if (nameMatcher.reset(entry.getKey().member()).matches()
          && valueMatcher.reset(String.valueOf(entry.getValue())).matches()) {
        return true;
      }
    }
    return false;
  }
1084439
@Override
    public void setConfiguration(
                    final Properties config
                    )
    throws ValidityException
    {
        String  pattern = config.getProperty( "pattern" );
        if (pattern == null) {
            throw new ValidityException( "no 'pattern' parameter" );
        }

        try {
            _formatter = new SimpleDateFormat( pattern );
                         //throws IllegalArgumentException
        } catch (Exception ex) {
            throw new ValidityException( "invalid 'pattern' parameter: "
                            + ex.getMessage() );
        }
    }
227262
private void addConfigParam(String name, Object value) throws ConfigurationException {
        if (isModuleName(name)) {
            Utils.require(value instanceof Map,
                          "Value for module '%s' should be a map: %s", name, value.toString());
            updateMap(m_params, name, value);
        } else {
            setLegacyParam(name, value);
        }
    }
901457
@Override
	public void setValueMap(Map<java.util.Locale, String> valueMap) {
		_cpDefinitionSpecificationOptionValue.setValueMap(valueMap);
	}
680686
public void setConfiguredProperties(BeanConfiguration configuration) {
        boolean changed = false;
        final Set<ConfiguredPropertyDescriptor> properties = getDescriptor().getConfiguredProperties();
        for (ConfiguredPropertyDescriptor property : properties) {
            final Object value = configuration.getProperty(property);
            final boolean changedValue = setConfiguredPropertyIfChanged(property, value);
            if (changedValue) {
                changed = true;
            }
        }
        if (changed) {
            onConfigurationChanged();
        }
    }
1337637
@ShellMethod(key = "decrypt-value", value = "Encrypt a CAS property value/setting via Jasypt")
    public void decryptValue(
        @ShellOption(value = {"value"},
            help = "Value to encrypt") final String value,
        @ShellOption(value = {"alg"},
            help = "Algorithm to use to encrypt") final String alg,
        @ShellOption(value = {"provider"},
            help = "Security provider to use to encrypt") final String provider,
        @ShellOption(value = {"password"},
            help = "Password (encryption key) to encrypt") final String password,
        @ShellOption(value = {"iterations"},
            help = "Key obtention iterations to encrypt") final String iterations) {

        val cipher = new CasConfigurationJasyptCipherExecutor(this.environment);
        cipher.setAlgorithm(alg);
        cipher.setPassword(password);
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.addProvider(new BouncyCastleProvider());
        }
        cipher.setProviderName(provider);
        cipher.setKeyObtentionIterations(iterations);
        val encrypted = cipher.decryptValue(value);
        LOGGER.info("==== Decrypted Value ====\n{}", encrypted);

    }
1206583
private void setCommandLineParam(String cmdArgName, String cmdArgValue) throws ConfigurationException {
        int dotInx = cmdArgName.indexOf('.');
        if (dotInx < 0 && isModuleName(cmdArgName)) {
            Map<String, Object> paramMap = parseSerialParams(cmdArgValue);
            updateMap(m_params, cmdArgName, paramMap);
        } else {
            String moduleName = dotInx <= 0 ? null : cmdArgName.substring(0, dotInx);
            String paramName = dotInx <= 0 ? cmdArgName : cmdArgName.substring(dotInx + 1);
            String[] values = cmdArgValue.split(",");
            Object paramValue = values.length <= 1 ? cmdArgValue : Arrays.asList(values); 
            if (moduleName == null) {
                setLegacyParam(cmdArgName, paramValue);
            } else {
                setModuleParam(moduleName, paramName, paramValue);
            }
        }
    }
1293976
@Override
    public void setConf(Configuration conf) {
        super.setConf(conf);
        numFeatures = conf.getInt(NUM_FEATURES, -1);
        if (numFeatures < 0)
            numFeatures = conf.getInt(NUM_ATTRIBUTES, -1);
        if (numFeatures < 0)
            throw new UnsupportedOperationException("numFeatures must be set in configuration");
        appendLabel = conf.getBoolean(APPEND_LABEL, true);
        multilabel = conf.getBoolean(MULTILABEL, false);
        zeroBasedIndexing = conf.getBoolean(ZERO_BASED_INDEXING, true);
        zeroBasedLabelIndexing = conf.getBoolean(ZERO_BASED_LABEL_INDEXING, false);
        numLabels = conf.getInt(NUM_LABELS, -1);
        if (multilabel && numLabels < 0)
            throw new UnsupportedOperationException("numLabels must be set in confirmation for multilabel problems");
    }
81074
public void setConfig(Map<String, ? extends CacheConfig> config) {
        this.configMap = (Map<String, CacheConfig>) config;
    }
863685
public void setValueOptions(java.util.Collection<String> valueOptions) {
        if (valueOptions == null) {
            this.valueOptions = null;
            return;
        }

        this.valueOptions = new com.amazonaws.internal.SdkInternalList<String>(valueOptions);
    }
1063201
public final <T> ConfigurationModule set(final Param<List> opt, final List implList) {
    final ConfigurationModule c = deepCopy();
    c.processSet(opt);
    c.setParamLists.put(opt, implList);
    return c;
  }
270293
public static void parseAndSetOptions(
      Configuration conf, String optionKey) {
    String optionValue = conf.get(optionKey);
    if (optionValue != null) {
      RaidNode.LOG.info("Parsing option " + optionKey);
      // Parse the option value to get key:value pairs.
      String[] keyValues = optionValue.trim().split(",");
      for (String keyValue: keyValues) {
        String[] fields = keyValue.trim().split(":");
        String key = fields[0].trim();
        String value = fields[1].trim();
        conf.set(key, value);
      }
    } else {
      RaidNode.LOG.error("Option " + optionKey + " not found");
    }
  }
1096153
public <T> void set(Option<T> option, T value) {
        findOption(option).setValue(value);
    }
242612
public static <K, V> ConfigurationOptionBuilder<Map<K, V>> mapOption(ValueConverter<K> keyConverter, ValueConverter<V> valueConverter) {
		return new ConfigurationOptionBuilder<Map<K, V>>(new MapValueConverter<K, V>(keyConverter, valueConverter), Map.class)
				.defaultValue(Collections.<K, V>emptyMap());
	}
1202325
@Override
    public void bind(DynamicConfiguration config) {
      Injections.addBinding(
              Injections.newFactoryBinder(this).to(type).in(Singleton.class),
              config);
      Injections.addBinding(
              Injections.newBinder(this).to(ValueFactoryProvider.class),
              config);
    }
1274334
def on_config_value_changed(self, config_m, prop_name, info):
        
        config_key = info['args'][1]
        # config_value = info['args'][2]

        if config_key in ["ENABLE_CACHING", "SHOW_ABORTED_PREEMPTED", "SHOW_DATA_FLOWS",
                          "SHOW_DATA_FLOW_VALUE_LABELS", "SHOW_NAMES_ON_DATA_FLOWS", "ROTATE_NAMES_ON_CONNECTION"]:
            self.update_view()