batch process for {@link #getConfig(URI)} method
@param configKeyUris
@return
@throws ConfigStoreFactoryDoesNotExistsException
@throws ConfigStoreCreationException
@throws VersionDoesNotExistException
339606
public Map<URI, Config> getConfigs(Collection<URI> configKeyUris)
      throws ConfigStoreFactoryDoesNotExistsException, ConfigStoreCreationException, VersionDoesNotExistException {
    if (configKeyUris == null || configKeyUris.size() == 0)
      return Collections.emptyMap();

    Map<URI, Config> result = new HashMap<>();
    Multimap<ConfigStoreAccessor, ConfigKeyPath> partitionedAccessor = ArrayListMultimap.create();

    // map contains the mapping between ConfigKeyPath back to original URI , partitioned by ConfigStoreAccessor
    Map<ConfigStoreAccessor, Map<ConfigKeyPath, URI>> reverseMap = new HashMap<>();

    // partitioned the ConfigKeyPaths which belongs to the same store to one accessor
    for (URI u : configKeyUris) {
      ConfigStoreAccessor accessor = this.getConfigStoreAccessor(u);
      ConfigKeyPath configKeypath = ConfigClientUtils.buildConfigKeyPath(u, accessor.configStore);
      partitionedAccessor.put(accessor, configKeypath);

      if (!reverseMap.containsKey(accessor)) {
        reverseMap.put(accessor, new HashMap<ConfigKeyPath, URI>());
      }
      reverseMap.get(accessor).put(configKeypath, u);
    }

    for (Map.Entry<ConfigStoreAccessor, Collection<ConfigKeyPath>> entry : partitionedAccessor.asMap().entrySet()) {
      Map<ConfigKeyPath, Config> batchResult = entry.getKey().valueInspector.getResolvedConfigs(entry.getValue());

      for (Map.Entry<ConfigKeyPath, Config> resultEntry : batchResult.entrySet()) {
        // get the original URI from reverseMap
        URI orgURI = reverseMap.get(entry.getKey()).get(resultEntry.getKey());
        result.put(orgURI, resultEntry.getValue());
      }
    }

    return result;
  }
642961
@Override
  public Collection<ConfigKeyPath> getChildren(ConfigKeyPath configKey) {
    return this.cs.getChildren(configKey, this.version);
  }
336158
private URI getBaseURI(URI configKey) throws URISyntaxException {
    return new URI(configKey.getScheme(), configKey.getAuthority(), null, configKey.getQuery(), configKey.getFragment());
  }
598253
public static KeyManagerFactory keyManagerFactory(AbstractConfig config, String key) {
    final String keyManagerFactoryType = config.getString(key);
    try {
      return KeyManagerFactory.getInstance(keyManagerFactoryType);
    } catch (NoSuchAlgorithmException e) {
      ConfigException exception = new ConfigException(
          key,
          keyManagerFactoryType,
          "Unknown Algorithm."
      );
      exception.initCause(e);
      throw exception;
    }
  }
100529
public ConverterServerBuilder baseUri(String baseUri) {
        checkNotNull(baseUri);
        this.baseUri = URI.create(baseUri);
        return this;
    }
197565
public Config getConfig(String configKeyStr) throws ConfigStoreFactoryDoesNotExistsException,
      ConfigStoreCreationException, VersionDoesNotExistException, URISyntaxException {
    return getConfig(configKeyStr, Optional.<Config>absent());
  }
711524
@Override
  public Collection<ConfigKeyPath> getChildren(ConfigKeyPath configKey) {
    try {
      return this.childrenMap.get(configKey, () -> this.fallback.getChildren(configKey));
    } catch (ExecutionException ee) {
      throw new RuntimeException(ee);
    }
  }
729313
private Configuration getConfigurationInternal(final String[] keys) {

		Configuration conf = new Configuration();

		synchronized (this.confData) {

			final Iterator<String> it = this.confData.keySet().iterator();

			while (it.hasNext()) {

				final String key = it.next();
				boolean found = false;
				if (keys != null) {
					for (int i = 0; i < keys.length; i++) {
						if (key.equals(keys[i])) {
							found = true;
							break;
						}
					}

					if (found) {
						conf.setString(key, this.confData.get(key));
					}
				} else {
					conf.setString(key, this.confData.get(key));
				}
			}
		}

		return conf;
	}
1107925
public Object getConfigParameter(final ConfigurationKeys configParameter)
		throws ConfigurationException
	{


		Object o = this.config.getConfigParameter(configParameter);
		if (o != null) {
			return o;
		}
		//return standard values for some of the parameters if they
		//are not set in the configuration
		//this is only done for uncritical settings, e.g. debug or logging
		//For other parameters, missing settings will produce an exception
		else if(configParameter==ConfigurationKeys.LIMIT_SQL_ARCHIVE_SIZE){
			return Long.MAX_VALUE;
		}
		else if (configParameter==ConfigurationKeys.LIMIT_SQL_FILE_SIZE){
			return Long.MAX_VALUE;
		}
		else if (configParameter==ConfigurationKeys.MODE_STATISTICAL_OUTPUT){
			return false;
		}
		else if (configParameter==ConfigurationKeys.MODE_DEBUG_OUTPUT){
			return false;
		}
		else if (configParameter==ConfigurationKeys.VERIFICATION_ENCODING){
			return false;
		}
		else if (configParameter==ConfigurationKeys.VERIFICATION_DIFF){
			return false;
		}
		else if (configParameter==ConfigurationKeys.LOGGING_PATH_DEBUG){
			return "";
		}
		else if (configParameter==ConfigurationKeys.NAMESPACES_TO_KEEP){
			return new HashSet<Integer>();
		}
		else if (configParameter==ConfigurationKeys.MODE_DATAFILE_OUTPUT){
			return false;
		}
		else{
			throw ErrorFactory
					.createConfigurationException(
							ErrorKeys.CONFIGURATION_CONFIGURATIONMANAGER_UNKNOWN_CONFIG_PARAMETER,
							configParameter.toString());
		}
	}
1216198
public ServiceCall<Configuration> getConfiguration(GetConfigurationOptions getConfigurationOptions) {
    Validator.notNull(getConfigurationOptions, "getConfigurationOptions cannot be null");
    String[] pathSegments = { "v1/environments", "configurations" };
    String[] pathParameters = { getConfigurationOptions.environmentId(), getConfigurationOptions.configurationId() };
    RequestBuilder builder = RequestBuilder.get(RequestBuilder.constructHttpUrl(getEndPoint(), pathSegments,
        pathParameters));
    builder.query("version", versionDate);
    Map<String, String> sdkHeaders = SdkCommon.getSdkHeaders("discovery", "v1", "getConfiguration");
    for (Entry<String, String> header : sdkHeaders.entrySet()) {
      builder.header(header.getKey(), header.getValue());
    }
    builder.header("Accept", "application/json");
    return createServiceCall(builder.build(), ResponseConverterUtils.getObject(Configuration.class));
  }
1159524
public static List<ConfigProperty> getConfiguration(AlluxioConfiguration conf, Scope scope) {
    ConfigurationValueOptions useRawDisplayValue =
        ConfigurationValueOptions.defaults().useDisplayValue(true).useRawValue(true);

    List<ConfigProperty> configs = new ArrayList<>();
    List<PropertyKey> selectedKeys =
        conf.keySet().stream()
            .filter(key -> GrpcUtils.contains(key.getScope(), scope))
            .filter(key -> key.isValid(key.getName()))
            .collect(toList());

    for (PropertyKey key : selectedKeys) {
      ConfigProperty.Builder configProp = ConfigProperty.newBuilder().setName(key.getName())
          .setSource(conf.getSource(key).toString());
      if (conf.isSet(key)) {
        configProp.setValue(conf.get(key, useRawDisplayValue));
      }
      configs.add(configProp.build());
    }
    return configs;
  }
14068
public static String getClientConfigurationUri(final OidcRegisteredService registeredService,
                                                   final String serverPrefix) throws URISyntaxException {
        return new URIBuilder(serverPrefix
            .concat('/' + OidcConstants.BASE_OIDC_URL + '/' + OidcConstants.CLIENT_CONFIGURATION_URL))
            .addParameter(OidcConstants.CLIENT_REGISTRATION_CLIENT_ID, registeredService.getClientId())
            .build()
            .toString();
    }
1153011
protected RepositoryConfig createRepositoryConfiguration() throws ConfigurationException, IOException {

        final File jcrHome = getOuterRule().getRoot();
        final URL cfgUrl = this.getConfigUrl();
        assertNotNull("No Repository Configuration found", cfgUrl);

        return RepositoryConfig.create(cfgUrl.openStream(), jcrHome.getAbsolutePath());
    }
811472
public ConnectionOptions withUri(URI uri)
    throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException
  {
     factory.setUri(Assert.notNull(uri, "URI"));
     return this;
  }
169689
private URI createFileSystemURI(URI configKey) throws URISyntaxException, IOException {
    // Validate the scheme
    String configKeyScheme = configKey.getScheme();
    if (!configKeyScheme.startsWith(getSchemePrefix())) {
      throw new IllegalArgumentException(
          String.format("Scheme for configKey \"%s\" must begin with \"%s\"!", configKey, getSchemePrefix()));
    }

    if (Strings.isNullOrEmpty(configKey.getAuthority())) {
      return new URI(getPhysicalScheme(), getDefaultStoreFsLazy().getUri().getAuthority(), "", "", "");
    }
    String uriPhysicalScheme = configKeyScheme.substring(getSchemePrefix().length(), configKeyScheme.length());
    return new URI(uriPhysicalScheme, configKey.getAuthority(), "", "", "");
  }
475462
public ConfigurationStore getStore() throws ConfigException {
    if (store != null) {
      return store;
    }

    String uriStr = getConfigUri();

    if (uriStr == null) {
      getPfile();

      String configPname = getConfigPname();

      if (configPname == null) {
        throw new ConfigException("Either a uri or property name must be specified");
      }

      uriStr = pfile.getProperty(configPname);
      if (uriStr == null) {
        /* If configPname ends with ".confuri" we'll take the 
           preceding segment as a possible directory
         */
        if (configPname.endsWith(".confuri")) {
          final int lastDotpos = configPname.length() - 8;
          final int pos = configPname
                  .lastIndexOf('.', lastDotpos - 1);
          if (pos > 0) {
            uriStr = configPname.substring(pos + 1, lastDotpos);
          }
        }
      }
      
      if (uriStr == null) {
        throw new ConfigException("No property with name \"" +
                                          configPname + "\"");
      }
    }

    try {
      URI uri= new URI(uriStr);

      String scheme = uri.getScheme();

      if (scheme == null) {
        // Possible non-absolute path
        String path = uri.getPath();

        File f = new File(path);
        if (!f.isAbsolute() && configBase != null) {
          path = configBase + path;
        }

        uri= new URI(path);
        scheme = uri.getScheme();
      }

      if ((scheme == null) || (scheme.equals("file"))) {
        String path = uri.getPath();

        if (getPathSuffix() != null) {
          if (!path.endsWith(File.separator)) {
            path += File.separator;
          }

          path += getPathSuffix() + File.separator;
        }

        store = new ConfigurationFileStore(path);
        return store;
      }

      throw new ConfigException("Unsupported ConfigurationStore: " + uri);
    } catch (URISyntaxException use) {
      throw new ConfigException(use);
    }
  }
911746
public static configstatus[] get(nitro_service service) throws Exception{
		configstatus obj = new configstatus();
		configstatus[] response = (configstatus[])obj.get_resources(service);
		return response;
	}