Set the baseEntryname from the configuration. The configuration
should have only 1 baseEntry

@param configProps Map containing the configuration information
for the baseEntries.
@throws WIMException Exception is thrown if no baseEntry is set.
541209
private void setBaseEntry(Map<String, Object> configProps) throws WIMException {
/*
 * Map<String, List<Map<String, Object>>> configMap = Nester.nest(configProps, BASE_ENTRY);
 *
 * for (Map<String, Object> entry : configMap.get(BASE_ENTRY)) {
 * baseEntryName = (String) entry.get(BASE_ENTRY_NAME);
 * }
 */
        baseEntryName = (String) configProps.get(BASE_ENTRY);

        if (baseEntryName == null) {
            throw new WIMApplicationException(WIMMessageKey.MISSING_BASE_ENTRY, Tr.formatMessage(tc, WIMMessageKey.MISSING_BASE_ENTRY,
                                                                                                 WIMMessageHelper.generateMsgParms(reposId)));
        }
    }
675255
@Override
	public void configure(ConfigParams config) throws ConfigException {
		ConfigParams dependencies = config.getSection("dependencies");
		for (String name : dependencies.keySet()) {
			String locator = dependencies.get(name);
			if (locator == null)
				continue;

			try {
				Descriptor descriptor = Descriptor.fromString(locator);
				if (descriptor != null)
					_dependencies.put(name, descriptor);
				else
					_dependencies.put(name, locator);
			} catch (Exception ex) {
				_dependencies.put(name, locator);
			}
		}
	}
232574
public static void setInputColumnFamily(Configuration conf, String keyspace, String columnFamily, boolean widerows)
    {
        if (keyspace == null)
            throw new UnsupportedOperationException("keyspace may not be null");

        if (columnFamily == null)
            throw new UnsupportedOperationException("columnfamily may not be null");

        conf.set(INPUT_KEYSPACE_CONFIG, keyspace);
        conf.set(INPUT_COLUMNFAMILY_CONFIG, columnFamily);
        conf.set(INPUT_WIDEROWS_CONFIG, String.valueOf(widerows));
    }
692626
protected void addOnSetup(Map<String, Object> configMap) {
        Set<SortEntry> addOnSorts = Sets.newTreeSet();
        for (String key : configMap.keySet()) {
            if (key.startsWith(ADDON_CONF_PREFIX)) {
                String className = (String) configMap.get(key);
                if (StringUtils.isNotBlank(className)) {
                    String name = key.substring(ADDON_CONF_PREFIX.length());

                    int sortSp = name.lastIndexOf(">");
                    Integer sortPriority = 1000;
                    if (sortSp != -1) {
                        String sortStr = name.substring(sortSp + 1);
                        if (sortStr.equalsIgnoreCase("last")) {
                            sortPriority = Integer.MAX_VALUE;
                        } else {
                            sortPriority = Ints.tryParse(sortStr);
                            if (sortPriority == null || sortPriority < 0 || sortPriority > Integer.MAX_VALUE) {
                                throw new ConfigErrorException(
                                        Messages.get("info.addon.key.priority.error", Integer.MAX_VALUE, key)
                                );
                            }
                        }
                    }

                    if (sortSp != -1) {
                        name = name.substring(0, sortSp);
                    }

                    addOnSorts.add(new SortEntry(sortPriority, className, name, key));
                }
            }
        }

        for (SortEntry entry : addOnSorts) {
            logger.debug(Messages.get("info.addon.register.item", entry.key, entry.className));
            try {
                Class addOnClass = ClassUtils.getClass(entry.className);
                if (Addon.class.isAssignableFrom(addOnClass)) {
                    Addon addon = (Addon) addOnClass.newInstance();
                    if (addon.isEnabled(this) && addons.add(addon)) {
                        addon.setup(this);
                    }
                } else {
                    throw new ConfigErrorException(Messages.get("info.addon.register.error.interface", entry.name, entry.key));
                }
            } catch (ClassNotFoundException e) {
                throw new ConfigErrorException(Messages.get("info.addon.register.error.not.found", entry.name, entry.key));
            } catch (InstantiationException | IllegalAccessException e) {
                throw new ConfigErrorException(Messages.get("info.addon.register.error.init", entry.name, entry.key));
            } catch (Exception e) {
                logger.error(Messages.get("info.addon.register.error", entry.name, entry.key), e);
            }
        }
    }
1129848
public void setProperties(Properties properties) throws ConfigurationException {
//		initialRequest = application.getCurrentRequest();
		autoReload = Boolean.valueOf(properties.getProperty("autoreload", "true"));

		defaultMappingName = properties.getProperty("defaultmapping", defaultMappingName);

/*		strict = section.getValue("strict", new GenericValue(strict), "abort mapping loading on errors").toBoolean().booleanValue();
        Environment.System.out.println("checking mapping strictly: " + strict);*/

		mappingFilesMap = PropertiesSupport.getSubsection(properties, "mapping");
	}
929473
@Reference(service = RepertoireConfigService.class, cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC, target = "(id=*)")
    protected synchronized void setRepertoire(RepertoireConfigService config) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Adding repertoire: " + config.getAlias());
        }
        Map<String, Object> properties = config.getProperties();
        repertoireMap.put(config.getAlias(), config);
        repertoirePIDMap.put(config.getPID(), config.getAlias());
        repertoirePropertiesMap.put(config.getAlias(), properties);
        addKeyStores(true, config.getKeyStore(), config.getTrustStore());

    }
1048883
public void initialize(Map<String, Object> configProps) throws WIMException {
        reposId = (String) configProps.get(KEY_ID);
        reposRealm = (String) configProps.get(REALM);

        if (String.valueOf(configProps.get(ConfigConstants.CONFIG_PROP_SUPPORT_CHANGE_LOG)).equalsIgnoreCase(ConfigConstants.CONFIG_SUPPORT_CHANGE_LOG_NATIVE)) {
            //Construct a change handler depending on the type of LDAP repository
            changeHandler = ChangeHandlerFactory.getChangeHandler(iLdapConn);
        }

        iLdapConfigMgr = new LdapConfigManager();
        iLdapConfigMgr.initialize(configProps);

        iLdapConn = new LdapConnection(iLdapConfigMgr);
        iLdapConn.initialize(configProps);

        isActiveDirectory = iLdapConfigMgr.isActiveDirectory();
    }
1000018
public Map<String, List<String>> getBaseEntriesForRepos(String[] realmBaseEntries) throws WIMException {
        Map<String, List<String>> reposBaseEntries = new HashMap<String, List<String>>();
        for (String baseEntryName : realmBaseEntries) {
            String reposId = getRepositoryIdByUniqueName(baseEntryName);
            List<String> baseEntryList = reposBaseEntries.get(reposId);
            if (baseEntryList == null)
                baseEntryList = new ArrayList<String>();
            baseEntryList.add(baseEntryName);
            reposBaseEntries.put(reposId, baseEntryList);
        }
        return reposBaseEntries;
    }
581638
private static void setConfigurationFromSystemProperties(Configuration configuration,
      PropertyKey[] propertyNames) {
    for (PropertyKey propertyName : propertyNames) {
      setConfigurationFromSystemProperty(configuration, propertyName.toString());
    }
  }
1327212
public void setPrefixConfig(final PrefixConfig config) {
		lock.writeLock().lock();
		try {
			if (config == null) {
				prefixes = EmptyPrefix.INSTANCE;
			} else {
				prefixes = config;
			}
		} finally {
			lock.writeLock().unlock();
		}
	}
851608
void setBaseValues(CatalogMap<? extends CatalogType> parentMap, String name) {
        if (name == null) {
            throw new CatalogException("Null value where it shouldn't be.");
        }
        m_parentMap = parentMap;
        m_typename = name;
    }
466498
public void setEntryId(String v) {
    if (ResourceEntry_Type.featOkTst && ((ResourceEntry_Type)jcasType).casFeat_entryId == null)
      jcasType.jcas.throwFeatMissing("entryId", "de.julielab.jules.types.ResourceEntry");
    jcasType.ll_cas.ll_setStringValue(addr, ((ResourceEntry_Type)jcasType).casFeatCode_entryId, v);}
868495
private void initializeContextManager(Map<String, Object> configProps) throws WIMException {

        iContextManager = new ContextManager();

        /*
         * Set SSL configuration
         */
        iContextManager.setSSLAlias((String) configProps.get("sslRef"));
        iContextManager.setSSLEnabled((Boolean) configProps.get(CONFIG_PROP_SSL_ENABLED));

        /*
         * Set the primary server.
         */
        iContextManager.setPrimaryServer((String) configProps.get(CONFIG_PROP_HOST), (Integer) configProps.get(CONFIG_PROP_PORT));

        /*
         * Set fail-over servers and fail-over behavior.
         */
        for (Map<String, Object> serverConfig : Nester.nest(FAILOVER_SERVERS, configProps)) {
            List<Map<String, Object>> servers = Nester.nest(SERVER2, serverConfig);
            for (Map<String, Object> server : servers) {
                iContextManager.addFailoverServer((String) server.get(CONFIG_PROP_HOST), (Integer) server.get(CONFIG_PROP_PORT));
            }
        }
        iContextManager.setWriteToSecondary(Boolean.getBoolean((String) configProps.get(CONFIG_PROP_ALLOW_WRITE_TO_SECONDARY_SERVERS)));
        iContextManager.setReturnToPrimary((Boolean) configProps.get(CONFIG_PROP_RETURN_TO_PRIMARY_SERVER));
        iContextManager.setQueryInterval((Integer) configProps.get(CONFIG_PROP_PRIMARY_SERVER_QUERY_TIME_INTERVAL) * 60);

        /*
         * Set the simple authentication credentials.
         */
        iContextManager.setSimpleCredentials((String) configProps.get(CONFIG_PROP_BIND_DN), (SerializableProtectedString) configProps.get(CONFIG_PROP_BIND_PASSWORD));

        /*
         * Set the connection timeout.
         */
        iContextManager.setConnectTimeout((Long) configProps.get(CONFIG_PROP_CONNECT_TIMEOUT));

        /*
         * Set the connection timeout.
         */
        iContextManager.setReadTimeout((Long) configProps.get(CONFIG_PROP_READ_TIMEOUT));

        /*
         * Determine referral handling behavior. Initially the attribute was spelled missing an 'r' so
         * for backwards compatibility, support customers who might still be using it. The "referal"
         * attribute has no default so unless it is set we won't use it.
         */
        String referal = (String) configProps.get(CONFIG_PROP_REFERAL);
        String referral = (String) configProps.get(CONFIG_PROP_REFERRAL);
        referral = referal != null ? referal : referral;
        iContextManager.setReferral(referral.toLowerCase());

        /*
         * Set binary attribute names.
         */
        iContextManager.setBinaryAttributeNames(getBinaryAttributes());

        /*
         * Configure the context pool.
         */
        boolean enableContextPool = true;

        List<Map<String, Object>> poolConfigs = Nester.nest(CONFIG_CONTEXT_POOL, configProps);

        Map<String, Object> poolConfig = null;
        if (!poolConfigs.isEmpty()) {
            poolConfig = poolConfigs.get(0);
        }

        /*
         * Enable the context pool if the context pool is enabled and the
         * stand-alone LDAP property reuseConnection has not been set to false.
         */
        boolean reuseConn = (Boolean) configProps.get(CONFIG_REUSE_CONNECTION);
        if (tc.isDebugEnabled()) {
            Tr.debug(tc, "Set reuseConnection as [" + reuseConn + "]");
        }
        if (poolConfig != null) {
            enableContextPool = (Boolean) poolConfig.get(CONFIG_PROP_ENABLED);
        }
        if (!reuseConn) {
            enableContextPool = false;
        }

        Integer initPoolSize = null;
        Integer maxPoolSize = null;
        Integer prefPoolSize = null;
        Long poolTimeOut = null;
        Long poolWaitTime = null;

        if (enableContextPool) {
            if (poolConfig != null) {
                if (poolConfig.get(CONFIG_PROP_INIT_POOL_SIZE) != null) {
                    initPoolSize = (Integer) poolConfig.get(CONFIG_PROP_INIT_POOL_SIZE);
                }
                if (poolConfig.get(CONFIG_PROP_MAX_POOL_SIZE) != null) {
                    maxPoolSize = (Integer) poolConfig.get(CONFIG_PROP_MAX_POOL_SIZE);
                }
                if (poolConfig.get(CONFIG_PROP_PREF_POOL_SIZE) != null) {
                    prefPoolSize = (Integer) poolConfig.get(CONFIG_PROP_PREF_POOL_SIZE);
                }

                if (poolConfig.get(CONFIG_PROP_POOL_TIME_OUT) != null) {
                    poolTimeOut = (Long) poolConfig.get(CONFIG_PROP_POOL_TIME_OUT);

                    /**
                     * The metatype is set to long for this property and all
                     * values will be passed as milliseconds.
                     * A value of 0 means no timeout, leave at 0
                     * Between 0 and 1000ms, round up to 1s
                     * Otherwise round to nearest second
                     */
                    if (poolTimeOut > 0 && poolTimeOut <= 1000) {
                        poolTimeOut = 1l; // override to 1 second
                    } else {
                        poolTimeOut = roundToSeconds(poolTimeOut);
                    }
                }
                if (poolConfig.get(CONFIG_PROP_POOL_WAIT_TIME) != null) {
                    poolWaitTime = (Long) poolConfig.get((CONFIG_PROP_POOL_WAIT_TIME));
                }
            }
        }

        /*
         * Set the configuration on the ContextManager.
         */
        iContextManager.setContextPool(enableContextPool, initPoolSize, prefPoolSize, maxPoolSize, poolTimeOut, poolWaitTime);

        /*
         * Initialize the ContextManager.
         *
         * Only need to check for missing password as the configuration for LDAP would catch a missing
         * primary server. The password is optional and only required when the bind DN is configured.
         */
        InitializeResult result = iContextManager.initialize();
        if (result == InitializeResult.MISSING_PASSWORD) {
            String msg = Tr.formatMessage(tc, WIMMessageKey.MISSING_INI_PROPERTY, WIMMessageHelper.generateMsgParms(CONFIG_PROP_BIND_PASSWORD));
            throw new MissingInitPropertyException(WIMMessageKey.MISSING_INI_PROPERTY, msg);
        }
    }
1030144
public void setConfig(String configName, String configValue)
  {
    if (config == null)
    {
      config = new Properties();
    }

    if(configValue == null)
    {
      config.remove(configName);
    }
    else
    {
      config.setProperty(configName, configValue);
    }
  }
274705
public static void setSpecificInputContext(Configuration conf, String inputName, int inputId) {
    for (Map.Entry<String, String> entries : conf) {
      String confKey = entries.getKey();
      String confValue = entries.getValue();
      if (confKey.startsWith(MI_PREFIX + inputName + "." + inputId + CONF)) {
        // Specific context key, value found
        String contextKey = confKey.substring((MI_PREFIX + inputName + "." + inputId + CONF + ".").length(), confKey
            .length());
        conf.set(contextKey, confValue);
      }
    }
  }
1130630
public static void loadUserConfigProps() {
        userProps = new Properties();
        try {
            LOG.info("Loading the properties as proj root /src:");
            loadProps(userProps, mRunPropertiesFile);
        } catch (IOException e) {
            LOG.info("context", e);
            try {
                LOG.info("No prop file found, trying load the properties as proj root /src:");
                loadProps(userProps, iRunPropertiesFile);
            } catch (IOException e1) {
                LOG.error("IOException", e1);
            }
        }
    }
68100
public static void addToSystemConfig(String prefix, Properties prop) {
		for (Entry<Object, Object> entry : prop.entrySet()) {
			String key = prefix.concat(entry.getKey().toString());
			String value = entry.getValue().toString();
			System.setProperty(key, value);
		}
	}