Use {@link #getPathConfigsMap()} instead.
960024
@java.lang.Deprecated
  public java.util.Map<java.lang.String, alluxio.grpc.ConfigProperties> getPathConfigs() {
    return getPathConfigsMap();
  }
1085176
public Map<String, CmsXmlContentProperty> getPropertyConfigurationAsMap() {

        Map<String, CmsXmlContentProperty> result = new LinkedHashMap<String, CmsXmlContentProperty>();
        for (CmsPropertyConfig propConf : getPropertyConfiguration()) {
            result.put(propConf.getName(), propConf.getPropertyData());
        }
        return result;
    }
1201195
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.String> getMarks() {
    return getMarksMap();
  }
1524
public <K, V> MapPath<K, V, PathBuilder<V>> getMap(String property, Class<K> key, Class<V> value) {
        return this.<K, V, PathBuilder<V>>getMap(property, key, value, PathBuilder.class);
    }
142131
@java.lang.Deprecated
  public java.util.Map<java.lang.String, com.google.protobuf.Value> getSourceProperties() {
    return getSourcePropertiesMap();
  }
778457
public static Map<String, DataSource> getDataSourceMap(final Map<String, DataSourceConfiguration> dataSourceConfigurationMap) {
        Map<String, DataSource> result = new LinkedHashMap<>(dataSourceConfigurationMap.size(), 1);
        for (Entry<String, DataSourceConfiguration> entry : dataSourceConfigurationMap.entrySet()) {
            result.put(entry.getKey(), entry.getValue().createDataSource());
        }
        return result;
    }
1353056
@SuppressWarnings("unchecked")
  protected <T> T map(Config config, String path, String name, Class<T> clazz) {
    T instance = newInstance(config, name, clazz);

    // Map config property names to bean properties.
    Map<String, String> propertyNames = new HashMap<>();
    for (Map.Entry<String, ConfigValue> configProp : config.root().entrySet()) {
      String originalName = configProp.getKey();
      String camelName = toCamelCase(originalName);
      // if a setting is in there both as some hyphen name and the camel name,
      // the camel one wins
      if (!propertyNames.containsKey(camelName) || originalName.equals(camelName)) {
        propertyNames.put(camelName, originalName);
      }
    }

    // First use setters and then fall back to fields.
    mapSetters(instance, clazz, path, name, propertyNames, config);
    mapFields(instance, clazz, path, name, propertyNames, config);

    // If any properties present in the configuration were not found on config beans, throw an exception.
    if (!propertyNames.isEmpty()) {
      checkRemainingProperties(propertyNames.keySet(), describeProperties(instance), toPath(path, name), clazz);
    }
    return instance;
  }
395590
protected void populateFaxActionType2ReponseDataPathMappings(FaxActionType[] faxActionTypes,Enum<?>[] configurationKeys)
    {
        //populate map
        String path=null;
        for(int index=0;index<faxActionTypes.length;index++)
        {
            //get next path
            path=this.getConfigurationValue(configurationKeys[index]);
            if(path!=null)
            {
                this.faxActionType2ReponseDataPathMap.put(faxActionTypes[index],path);
            }
        }
    }
769018
public Object getConfigParameter(final ConfigurationKeys configParameter)
	{
		if (this.parameterMap.containsKey(configParameter)) {
			return this.parameterMap.get(configParameter);
		}

		return null;
	}
317574
private List<ConfigurationHelper.ConfigurationInfo<String>>
      getFilePathConfigurationListWithDefault(@Nullable List<String> filePaths,
       String defaultFilePath) {
    List<ConfigurationHelper.ConfigurationInfo<String>> defaultConfigList =
        ConfigurationHelper.newList(true, defaultFilePath);
    List<ConfigurationHelper.ConfigurationInfo<String>> filePathConfigList =
        ConfigurationHelper.newList(filePaths, true);
    if (defaultConfigList != null) {
      if (filePathConfigList == null) {
        filePathConfigList = defaultConfigList;
      } else {
        filePathConfigList.addAll(defaultConfigList);
      } 
    }
    return filePathConfigList;
  }
1162371
@Override
  public List<ConfigKeyPath> getOwnImports(ConfigKeyPath configKey) {
    return getOwnImports(configKey, Optional.<Config>absent());
  }
1344769
@Override
  public HashMap<String, String> getValuesMap() {
    if (optionsHolder == null ) return null;
    else return optionsHolder.getOptionsMap();
  }
651013
public static ConfigKeyPath getConfigKeyPath(String input) {
    ConfigKeyPath result = SingleLinkedListConfigKeyPath.ROOT;
    String[] paths = input.split("/");
    for (String p : paths) {
      // in case input start with "/", some elements could be "", which should be skip
      if (p.equals("")) {
        continue;
      }
      result = result.createChild(p);
    }
    return result;
  }
1154110
private static PathMapping pathStringMapping(String pathPrefix, Method method,
                                                 Set<Annotation> methodAnnotations) {
        pathPrefix = ensureAbsolutePath(pathPrefix, "pathPrefix");
        if (!pathPrefix.endsWith("/")) {
            pathPrefix += '/';
        }

        final String pattern = findPattern(method, methodAnnotations);
        final PathMapping mapping = PathMapping.of(pattern);
        if ("/".equals(pathPrefix)) {
            // pathPrefix is not specified or "/".
            return mapping;
        }

        if (pattern.startsWith(EXACT)) {
            return PathMapping.ofExact(concatPaths(
                    pathPrefix, pattern.substring(EXACT.length())));
        }

        if (pattern.startsWith(PREFIX)) {
            return PathMapping.ofPrefix(concatPaths(
                    pathPrefix, pattern.substring(PREFIX.length())));
        }

        if (pattern.startsWith(GLOB)) {
            final String glob = pattern.substring(GLOB.length());
            if (glob.startsWith("/")) {
                return PathMapping.ofGlob(concatPaths(pathPrefix, glob));
            } else {
                // NB: We cannot use PathMapping.ofGlob(pathPrefix + "/**/" + glob) here
                //     because that will extract '/**/' as a path parameter, which a user never specified.
                return new PrefixAddingPathMapping(pathPrefix, mapping);
            }
        }

        if (pattern.startsWith(REGEX)) {
            return new PrefixAddingPathMapping(pathPrefix, mapping);
        }

        if (pattern.startsWith("/")) {
            // Default pattern
            return PathMapping.of(concatPaths(pathPrefix, pattern));
        }

        // Should never reach here because we validated the path pattern.
        throw new Error();
    }
545847
@ReadOperation
    public Map<String, Object> configuration() {
        val configuredLoggers = new HashSet<Object>();
        getLoggerConfigurations().forEach(config -> {
            val loggerMap = new HashMap<String, Object>();
            loggerMap.put("name", StringUtils.defaultIfBlank(config.getName(), LOGGER_NAME_ROOT));
            loggerMap.put("state", config.getState());
            if (config.getPropertyList() != null) {
                loggerMap.put("properties", config.getPropertyList());
            }
            loggerMap.put("additive", config.isAdditive());
            loggerMap.put("level", config.getLevel().name());
            val appenders = new HashSet<Object>();
            config.getAppenders().keySet().stream().map(key -> config.getAppenders().get(key)).forEach(appender -> {
                val builder = new ToStringBuilder(this, ToStringStyle.JSON_STYLE);
                builder.append("name", appender.getName());
                builder.append("state", appender.getState());
                builder.append("layoutFormat", appender.getLayout().getContentFormat());
                builder.append("layoutContentType", appender.getLayout().getContentType());
                if (appender instanceof FileAppender) {
                    builder.append(FILE_PARAM, ((FileAppender) appender).getFileName());
                    builder.append(FILE_PATTERN_PARAM, "(none)");
                }
                if (appender instanceof RandomAccessFileAppender) {
                    builder.append(FILE_PARAM, ((RandomAccessFileAppender) appender).getFileName());
                    builder.append(FILE_PATTERN_PARAM, "(none)");
                }
                if (appender instanceof RollingFileAppender) {
                    builder.append(FILE_PARAM, ((RollingFileAppender) appender).getFileName());
                    builder.append(FILE_PATTERN_PARAM, ((RollingFileAppender) appender).getFilePattern());
                }
                if (appender instanceof MemoryMappedFileAppender) {
                    builder.append(FILE_PARAM, ((MemoryMappedFileAppender) appender).getFileName());
                    builder.append(FILE_PATTERN_PARAM, "(none)");
                }
                if (appender instanceof RollingRandomAccessFileAppender) {
                    builder.append(FILE_PARAM, ((RollingRandomAccessFileAppender) appender).getFileName());
                    builder.append(FILE_PATTERN_PARAM, ((RollingRandomAccessFileAppender) appender).getFilePattern());
                }
                appenders.add(builder.build());
            });
            loggerMap.put("appenders", appenders);
            configuredLoggers.add(loggerMap);
        });
        val responseMap = new HashMap<String, Object>();
        responseMap.put("loggers", configuredLoggers);

        val loggers = getActiveLoggersInFactory();
        responseMap.put("activeLoggers", loggers.values());

        return responseMap;
    }
631071
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.Long> getMetricCosts() {
    return getMetricCostsMap();
  }
1032964
@SuppressWarnings({
			"unchecked", "rawtypes"
	})
	public Map<String, String> getStringMap(final Class<? extends Map> clazz) {
		try {
			final Map<String, String> map = clazz.newInstance();
			final int len = getVInt();
			for (int i = 0; i < len; i++) {
				map.put(getString(), getString());
			}
			return map;
		} catch (InstantiationException e) {
			throw new IllegalArgumentException("Invalid class", e);
		} catch (IllegalAccessException e) {
			throw new IllegalArgumentException("Invalid class", e);
		}
	}