Java ConfigValue.unwrapped方法代码示例

import com.typesafe.config.ConfigValue; //导入方法依赖的package包/类
/**
 * Creates a new custom tag mappings object from the given configuration. The keys of the
 * configuration are well-known tag names, and the values are the custom tag names.
 *
 * @param config config holding custom tags
 * @throws IllegalArgumentException if any configuration value is not a string or is empty
 */
public CustomTagMappings(Config config) {
  ImmutableMap.Builder<String, String> b = ImmutableMap.builder();

  if (config != null) {
    for (Map.Entry<String,ConfigValue> e : config.entrySet()) {
      String key = e.getKey();
      ConfigValue value = e.getValue();
      switch (value.valueType()) {
        case STRING:
          String customTagName = (String) value.unwrapped();
          if (customTagName.isEmpty()) {
            throw new IllegalArgumentException("Tag mapping " + key + " is empty");
          }
          b.put(key, customTagName);
          break;
        default:
          throw new IllegalArgumentException("Tag mapping " + key + " is not a string: " + value);
      }
    }
  }

  customTagNames = b.build();
}
 

import com.typesafe.config.ConfigValue; //导入方法依赖的package包/类
private Object checkValue(String k, ConfigValue value, ConfigPropertyType<?> t) {
    Object v = value.unwrapped();
    switch (value.valueType()) {
        case STRING:
            // allow auto-conversion from string
            return t.check(k, value.unwrapped(), value.origin());
        case NUMBER:
            if (t.getBaseType() != ConfigPropertyType.INT && t.getBaseType() != ConfigPropertyType.FLOAT) {
                throw invalidValue(value, k, v, t.getBaseType());
            }
            if (t.getBaseType() == ConfigPropertyType.INT) {
                Number n = (Number) value.unwrapped();
                if (n.intValue() != n.doubleValue()) {
                    throw invalidValue(value, k, v, t.getBaseType());
                }
            }
            return t.check(k, v, null);
        case BOOLEAN:
            if (t.getBaseType() != ConfigPropertyType.BOOLEAN) {
                throw invalidValue(value, k, v, t.getBaseType());
            }
            return value.unwrapped();
        default:
            return t.check(k, v, value.origin());
    }
}
 

import com.typesafe.config.ConfigValue; //导入方法依赖的package包/类
protected JsonNode currentNumericNode() throws JsonParseException {
    ConfigValue configValue = currentNode();
    if ((configValue == null) || (configValue.valueType() != ConfigValueType.NUMBER)) {
        JsonToken t = (configValue == null) ? null : ConfigNodeCursor.forConfigValue(configValue);
        throw _constructError("Current token ("+t+") not numeric, can not use numeric value accessors");
    }
    Number value = (Number) configValue.unwrapped();
    if (value instanceof Double) {
        return JsonNodeFactory.instance.numberNode((Double) value);
    }
    if (value instanceof Long) {
        return JsonNodeFactory.instance.numberNode((Long) value);
    }
    if (value instanceof Integer) {
        return JsonNodeFactory.instance.numberNode((Integer) value);
    }
    // only possible if Config has since added more numeric types
    throw _constructError(value.getClass() + " is not a supported numeric config type");
}
 

import com.typesafe.config.ConfigValue; //导入方法依赖的package包/类
public List<Variable> getVariables() {
    List<Variable> variables = new ArrayList<>();
    File file = new File(jythonPath);

    String[] packages = file.list();

    if (packages == null) {
        // No workflow packages deployed, return empty list
        return variables;
    }

    for (String packageName : packages) {
        File packageDir = new File(file.getAbsolutePath() + File.separator + packageName);

        if (packageDir.isDirectory()) {
            File workflowsDir = new File(packageDir.getAbsolutePath() + File.separator + "workflows");
            File confFile = new File(workflowsDir.getAbsolutePath() + File.separator + "workflows.conf");

            if (confFile.exists()) {
                Config config = ConfigFactory.parseFile(confFile);

                if (config.hasPath("variables")) {
                    for (ConfigValue value : config.getObject("variables").values()) {
                        Map map = (Map) value.unwrapped();
                        variables.add(new Variable(map.get("name").toString(), map.get("description").toString(),
                              map.get("actor").toString(), map.get("parameter").toString(), map.get("type").toString()));
                    }
                }

            }
        }
    }

    return variables;
}
 

import com.typesafe.config.ConfigValue; //导入方法依赖的package包/类
Optional<RouteHandlerBuilder> processActorDefinition(ConfigValue cvalue) {
    
    try {
        // extract actor definition
        Map<String, Object> map = (Map<String, Object>) cvalue.unwrapped();

        String actorRef   = (String) map.get("ref");
        String methodName = (String) map.get("call");
        String actorClass = (String) map.get("class");
        
        Optional<ActorRef> ref = Optional.empty();
        
        if (!StringUtils.isEmpty(actorRef)) {
            // get actor by reference supplied
            ref = factory.getLocalActorByRef(actorRef);
        }
        
        if (!StringUtils.isEmpty(actorClass)) {
            // create new actor using class specified
            ref = factory.getLocalActor(actorClass);
            
        }

        return Optional.ofNullable(
                RouteHandler.builder()
                            .withActorRef(ref)
                            .withMethodName(methodName)
        );
    }
    catch (Exception ex) {
        log.warn("Error parsing actor definition: "+cvalue.render());
    }
    
    return empty();
}
 

import com.typesafe.config.ConfigValue; //导入方法依赖的package包/类
static JsonToken forConfigValue(ConfigValue configValue) {
    ConfigValueType valueType = configValue.valueType();
    switch (valueType) {
        case NUMBER:
            if (configValue.unwrapped() instanceof Double) {
                return JsonToken.VALUE_NUMBER_FLOAT;
            } else {
                return JsonToken.VALUE_NUMBER_INT;
            }
        case BOOLEAN:
            if (configValue.unwrapped().equals(Boolean.TRUE)) {
                return JsonToken.VALUE_TRUE;
            } else {
                return JsonToken.VALUE_FALSE;
            }
        case NULL:
            return JsonToken.VALUE_NULL;
        case STRING:
            return JsonToken.VALUE_STRING;
        case OBJECT:
            return JsonToken.START_OBJECT;
        case LIST:
            return JsonToken.START_ARRAY;
        default:
            // not possible unless the set of enums changes on us later
            throw new IllegalArgumentException(valueType.name() + " is not a supported ConfigValueType");
    }
}
 

import com.typesafe.config.ConfigValue; //导入方法依赖的package包/类
@Override
public NumberType getNumberType() throws IOException, JsonParseException {
	ConfigValue n = currentNumericNode();
	if(n == null)
		return null;
	
	Number value = (Number) n.unwrapped();
	if(value instanceof Double) {
		return NumberType.DOUBLE;
	} else if(value instanceof Long) {
		return NumberType.LONG;
	} else {
		return NumberType.INT;
	}
}
 

import com.typesafe.config.ConfigValue; //导入方法依赖的package包/类
public Map<String,Object> getServiceParametersMap(String serviceName, String paramName, boolean quotedStrings)
{
	Map<String,Object> result = null;
	
	try
	{
		String rootPath = "ors.services." + serviceName + "." + paramName;
		ConfigObject configObj = _config.getObject(rootPath);
		
		result = new HashMap<String, Object>();
		
		for(String key : configObj.keySet())
		{
			Object value = null;
			ConfigValue paramValue = _config.getValue(rootPath + "." + key);

			switch(paramValue.valueType())
			{
			case NUMBER:
				value = paramValue.unwrapped();
				break;
			case OBJECT:
				Map<String,Object> map = getServiceParametersMap(serviceName, paramName + "." + key, quotedStrings);
				value = map;
				break;
			case LIST:
				value = paramValue.unwrapped();
				break;
			case STRING:
				if (quotedStrings)
					value = paramValue.render();
				else
					value = StringUtility.trim(paramValue.render(), '"');
				break;
			case BOOLEAN:
				value = paramValue.unwrapped();
			default:
				break;
			}
			
			result.put(key, value);
		}
	}
	catch(Exception ex)
	{}
	
	return result;
}
 

import com.typesafe.config.ConfigValue; //导入方法依赖的package包/类
public PluginMap(@Nonnull String category, @Nonnull Config config) {
    this.config = config;
    this.category = checkNotNull(category);
    classField = config.getString("_field");
    boolean errorMissing = config.getBoolean("_strict");
    if (config.hasPath("_class")) {
        String baseClassName = config.getString("_class");
        try {
            baseClass = Class.forName(baseClassName);
        } catch (ClassNotFoundException e) {
            log.error("could not find specified base class {} for category {}",
                      baseClassName, category);
            throw new RuntimeException(e);
        }
    } else {
        baseClass = null;
    }
    Set<String> labels = config.root().keySet();
    BiMap<String, Class<?>> mutableMap = HashBiMap.create(labels.size());
    Map<String, String> mutableAliasMap = new HashMap<>();
    Set<String> mutableInlinedAliasSet = new HashSet<>();
    for (String label : labels) {
        if (!((label.charAt(0) != '_') || "_array".equals(label) || "_default".equals(label))) {
            continue;
        }
        ConfigValue configValue = config.root().get(label);
        String className;
        if (configValue.valueType() == ConfigValueType.STRING) {
            className = (String) configValue.unwrapped();
        } else if (configValue.valueType() == ConfigValueType.OBJECT) {
            ConfigObject configObject = (ConfigObject) configValue;
            className = configObject.toConfig().getString("_class");
            if (configObject.toConfig().hasPath("_inline") &&
                    configObject.toConfig().getBoolean("_inline")) {
                mutableInlinedAliasSet.add(label);
            }
        } else if (configValue.valueType() == ConfigValueType.NULL) {
            continue;
        } else {
            throw new ConfigException.WrongType(configValue.origin(), label,
                                                "STRING OR OBJECT", configValue.valueType().toString());
        }
        if (labels.contains(className)) {
            // points to another alias
            mutableAliasMap.put(label, className);
        } else {
            try {
                Class<?> foundClass = findAndValidateClass(className);
                mutableMap.put(label, foundClass);
            } catch (ClassNotFoundException maybeSwallowed) {
                if (errorMissing) {
                    throw new RuntimeException(maybeSwallowed);
                } else {
                    log.warn("plugin category {} with alias {} is pointing to missing class {}",
                             category, label, className);
                }
            }
        }
    }
    map = Maps.unmodifiableBiMap(mutableMap);
    aliases = Collections.unmodifiableMap(mutableAliasMap);
    checkAliasesForCycles();
    inlinedAliases = Collections.unmodifiableSet(mutableInlinedAliasSet);
}