Java JsonValue.getValueType方法代码示例

import javax.json.JsonValue; //导入方法依赖的package包/类
/**
 * Looks up a {@link JsonValue} which is referenced by a given JSON pointer.
 * @param pointer the JSON pointer which refers to a {@link JsonValue}.
 * @return the {@link JsonValue} if found, {@code null} otherwise. 
 * @exception IllegalArgumentException if specified pointer is {@code null}.
 */
public JsonValue getValueByPointer(JsonPointer pointer) {
	if (pointer == null) {
		throw new IllegalArgumentException();
	}
	JsonValue current = getRootValue();
	for (Object token: pointer) {
		if (current == null) {
			break;
		}
		JsonValue.ValueType type = current.getValueType();
		if (type == JsonValue.ValueType.ARRAY) {
			if ((token instanceof Integer)) {
				int index = ((Integer)token).intValue();
				current = ((JsonArray)current).get(index);
			} else {
				current = null;
			}
		} else if (type == JsonValue.ValueType.OBJECT) {
			current = ((JsonObject)current).get(token);
		} else {
			break;
		}
	}
	return current;
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
private static String readAdapterNotes(JsonObject root) {
    if (root.containsKey("adapterNotes")) {
        JsonValue notes = root.get("adapterNotes");
        if (notes.getValueType() == ValueType.STRING) {
            // Return unquoted string
            return ((JsonString)notes).getString();
        } else {
            return notes.toString();
        }
    }
    return "";
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
JwksResponse(JsonObject jsonObject)
{
    JsonValue keys = jsonObject.get("keys");

    if (keys.getValueType() != JsonValue.ValueType.ARRAY)
    {
        _keys = Collections.emptyList();
    }
    else
    {
        _keys = Stream.of((JsonArray)keys)
                .filter(it -> it.getValueType() == JsonValue.ValueType.OBJECT)
                .map(it -> (JsonObject) it)
                .map(JsonWebKey::new)
                .collect(Collectors.toList());
    }
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
/**
 * Converts a {@link JsonValue} to its corresponding Java object. Values of type {@link
 * JsonObject} or {@link JsonArray} are converted as specified by {@link #toJavaMap} and {@link
 * #toJavaList}, respectively.
 */
@Nullable
public static Object toJavaObject(JsonValue value) {
  switch (value.getValueType()) {
    case ARRAY:
      return toJavaList((JsonArray) value);
    case FALSE:
      return Boolean.FALSE;
    case NULL:
      return null;
    case NUMBER:
      JsonNumber number = (JsonNumber) value;
      return number.isIntegral() ? number.intValue() : number.doubleValue();
    case OBJECT:
      return toJavaMap((JsonObject) value);
    case STRING:
      return ((JsonString) value).getString();
    case TRUE:
      return Boolean.TRUE;
    default:
      throw new VerifyException("Json value with unknown type: " + value);
  }
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
public static Object unbox(JsonValue value, Function<JsonStructure, Object> convert) throws JsonException {
    switch (value.getValueType()) {
        case ARRAY:
        case OBJECT:
            return convert.apply((JsonStructure) value);
        case FALSE:
            return Boolean.FALSE;
        case TRUE:
            return Boolean.TRUE;
        case NULL:
            return null;
        case NUMBER:
            JsonNumber number = (JsonNumber) value;
            return number.isIntegral() ? number.longValue() : number.doubleValue();
        case STRING:
            return ((JsonString) value).getString();
        default:
            throw new JsonException("Unknow value type");
    }
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
public IpGroup parseIpGroup(JsonObject obj) {
    IpGroup retVal = new IpGroup();

    if (obj.containsKey("id")) {
        retVal.setId(Long.valueOf(obj.getString("id")));
    }
    retVal.setDisplayName(obj.getString("name", null));
    retVal.setDescription(obj.getString("description", null));
    retVal.setPersistedGroupAlias(obj.getString("alias", null));

    JsonArray rangeArray = obj.getJsonArray("ranges");
    for (JsonValue range : rangeArray) {
        if (range.getValueType() == JsonValue.ValueType.ARRAY) {
            JsonArray rr = (JsonArray) range;
            retVal.add(IpAddressRange.make(IpAddress.valueOf(rr.getString(0)),
                    IpAddress.valueOf(rr.getString(1))));

        }
    }

    return retVal;
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
private static void compareJsonValue(JsonValue actual, JsonValue expected) {
	assertNotNull(actual);
	assertNotNull(expected);
	assertThat(actual.getValueType(), is(expected.getValueType()));
	JsonValue.ValueType type = actual.getValueType();
	if (type == JsonValue.ValueType.OBJECT) {
		JsonObject actualObject = (JsonObject)actual;
		JsonObject expectedObject = (JsonObject)expected;
		assertThat(actualObject.size(), equalTo(expectedObject.size()));
		for (String key: actualObject.keySet()) {
			 compareJsonValue(actualObject.get(key), expectedObject.get(key));
		}
	} else if (type == JsonValue.ValueType.ARRAY) {
		JsonArray actualArray = (JsonArray)actual;
		JsonArray expectedArray = (JsonArray)expected;
		assertThat(actualArray.size(), equalTo(expectedArray.size()));
		for (int i = 0; i < actualArray.size(); i++) {
			compareJsonValue(actualArray.get(i), expectedArray.get(i));
		}
	} else {
		assertTrue(actual.equals(expected));
	}
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
private Object plainifyJsonValue(final JsonValue jval) {
    switch (jval.getValueType()) {
    case ARRAY:
        return plainifyJsonArray((JsonArray) jval);
    case FALSE:
        return Boolean.FALSE;
    case TRUE:
        return Boolean.TRUE;
    case NULL:
        return null;
    case NUMBER:
        return ((JsonNumber) jval).bigDecimalValue();
    case OBJECT:
        return plainifyJsonObject((JsonObject) jval);
    case STRING:
        return ((JsonString) jval).getString();
    default:
        throw new RuntimeException("unexpected json type");
    }
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
private Object map( JsonValue v )
{
    switch( v.getValueType() ) {
        case STRING:
            return ((JsonString) v).getString();

        case NUMBER:
            return ((JsonNumber) v).bigDecimalValue();

        case TRUE:
            return true;

        case FALSE:
            return false;

        case OBJECT:
            return MapBuilder.fromJsonObject( (JsonObject) v );

        case ARRAY:
            return CollectionBuilder.fromJsonArray( (JsonArray) v );

        case NULL:
        default:
            return null;
    }
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
private Map<String, String> jsonToMap(JsonObject jsonOutput) {
	Map<String, String> resultMap = new HashMap<>();
	for(String key:jsonOutput.keySet()) {
		JsonValue value = jsonOutput.get(key);
		if(value.getValueType() == ValueType.STRING) {
			resultMap.put(key, jsonOutput.getString(key));
		} else if (!value.getValueType().equals(ValueType.OBJECT)&&!value.getValueType().equals(ValueType.ARRAY)) {
			resultMap.put(key, jsonOutput.getString(key).toString());
		}
	}
	return resultMap;
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
public static String getString( JsonObject o, String n, String defaultValue )
{
    JsonValue v = o.get( n );
    if( v == null ) {
        return defaultValue;
    }
    switch( v.getValueType() ) {
        case NUMBER:
            JsonNumber jn = (JsonNumber) v;
            return jn.toString();
        case STRING:
            JsonString s = (JsonString) v;
            return s.getString();
        case TRUE:
            return "true";
        case FALSE:
            return "false";
        case NULL:
            return defaultValue;
        default:
            return v.toString();
    }
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
public static LocalTime getLocalTime( JsonObject o, String n )
{
    JsonValue v = o.get( n );
    if( v == null ) {
        return null;
    }
    switch( v.getValueType() ) {
        case STRING:
            return TimeUtils.getLocalTime( ((JsonString) v).getString() );

        case NUMBER:
            return TimeUtils.getLocalTime( ((JsonNumber) v).longValue() );
        default:
            return null;
    }
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
public static Date getDate( JsonValue v )
{
    if( v == null ) {
        return null;
    }
    switch( v.getValueType() ) {
        case NUMBER:
            return new Date( ((JsonNumber) v).longValue() );
        case STRING:
            return Date.valueOf( ((JsonString) v).getString() );
        case TRUE:
        case FALSE:
        case NULL:
            return null;
        default:
            return Date.valueOf( v.toString() );
    }
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
public static Time getTime( JsonValue v )
{
    if( v == null ) {
        return null;
    }
    switch( v.getValueType() ) {
        case NUMBER:
            return new Time( ((JsonNumber) v).longValue() );
        case STRING:
            return Time.valueOf( ((JsonString) v).getString() );
        case TRUE:
        case FALSE:
        case NULL:
            return null;
        default:
            return Time.valueOf( v.toString() );
    }
}
 

import javax.json.JsonValue; //导入方法依赖的package包/类
private ImmutableList<CallArgument> processScriptArguments(JsonArray args) {
  ImmutableList.Builder<CallArgument> argsBuilder = ImmutableList.builder();
  for (JsonValue arg : args) {
    if (ValueType.OBJECT.equals(arg.getValueType())) {
      JsonObject jsonArg = (JsonObject) arg;
      if (jsonArg.containsKey("ELEMENT")) {
        NodeId n = new NodeId(Integer.parseInt(jsonArg.getString("ELEMENT").split("_")[1]));
        RemoteWebElement rwep = new RemoteWebElement(n, this);
        argsBuilder.add(callArgument().withObjectId(rwep.getRemoteObject().getId()));
      } else {
        log.info("JsonObject without ELEMENT tag" + jsonArg);
      }
    } else if (ValueType.ARRAY.equals(arg.getValueType())) {
      JsonObject array = getScriptResponse("return " + arg + ";");
      argsBuilder.add(callArgument().withObjectId(getResponseBody(array).getString("objectId")));
    } else if (ValueType.FALSE.equals(arg.getValueType())) {
      argsBuilder.add(callArgument().withValue(false));
    } else if (ValueType.TRUE.equals(arg.getValueType())) {
      argsBuilder.add(callArgument().withValue(true));
    } else if (ValueType.NUMBER.equals(arg.getValueType())) {
      argsBuilder.add(callArgument().withValue(((JsonNumber) arg).longValue()));
    } else if (ValueType.STRING.equals(arg.getValueType())) {
      argsBuilder.add(callArgument().withValue(((JsonString) arg).getString()));
    } else {
      throw new WebDriverException("Unsupported argument type: " + arg.getValueType());
    }
  }
  return argsBuilder.build();
}