if (json.containsKey("name")) { final Object value = json.get("name"); if (value instanceof JsonString) { final String valueString = ((JsonString) value).getString(); displayName = valueString; dependency.setName(valueString); if (json.containsKey("license")) { final Object value = json.get("license"); if (value instanceof JsonString) { final StringBuilder sb = new StringBuilder(); boolean addComma = false; for (int x = 0; x < array.size(); x++) { if (!array.isNull(x)) { if (addComma) { sb.append(", "); addComma = true; if (ValueType.STRING == array.get(x).getValueType()) { sb.append(array.getString(x)); } else {
private static String asString(JsonValue value) { if (JsonValue.ValueType.STRING.equals(value.getValueType())) { return ((JsonString) value).getString(); } return value.toString(); } }
if (patch.getValueType() != JsonValue.ValueType.OBJECT) { return patch; if (target.getValueType() != JsonValue.ValueType.OBJECT) { target = JsonValue.EMPTY_JSON_OBJECT; JsonObject targetJsonObject = target.asJsonObject(); JsonObjectBuilder builder = Json.createObjectBuilder(targetJsonObject); patch.asJsonObject().forEach((key, value) -> { if (value == JsonValue.NULL) { if (targetJsonObject.containsKey(key)) { builder.remove(key); } else if (targetJsonObject.containsKey(key)) { builder.add(key, mergePatch(targetJsonObject.get(key), value)); } else {
/** * Transform from json to object. * * @param jsonValue json value * @return object most correct for the type, or string value if not understood (e.g. json object) */ public static Object toObject(JsonValue jsonValue) { switch (jsonValue.getValueType()) { case ARRAY: return jsonValue.toString(); case OBJECT: return jsonValue.toString(); case STRING: return ((JsonString) jsonValue).getString(); case NUMBER: return ((JsonNumber) jsonValue).numberValue(); case TRUE: return true; case FALSE: return false; case NULL: return null; default: return jsonValue.toString(); } }
@Override public Optional<Function<JsonValue, Stream<ValidationResult.ValidationError>>> create(final ValidationContext model) { if (model.getSchema().getString("type", "object").equals("number")) { return Optional.ofNullable(model.getSchema().get("exclusiveMinimum")) .filter(v -> v.getValueType() == JsonValue.ValueType.NUMBER) .map(m -> new Impl(model.toPointer(), model.getValueProvider(), JsonNumber.class.cast(m).doubleValue())); } return Optional.empty(); }
private boolean hasValidAudience(JsonObject claims) throws RealmUnavailableException { if (this.audiences.isEmpty()) return true; JsonValue audience = claims.get("aud"); if (audience == null) { log.debug("Token does not contain an audience claim"); return false; } JsonArray audClaimArray; if (JsonValue.ValueType.STRING.equals(audience.getValueType())) { audClaimArray = Json.createArrayBuilder().add(audience).build(); } else { audClaimArray = (JsonArray) audience; } boolean valid = audClaimArray.stream() .map(jsonValue -> (JsonString) jsonValue) .anyMatch(audience1 -> audiences.contains(audience1.getString())); if (!valid) { log.debugf("Audience check failed. Provided [%s] but was expected [%s].", audClaimArray.toArray(), this.audiences); } return valid; }
payloadBuilder.add("name", packageJson.getString("name")); payloadBuilder.add("version", packageJson.getString("version")); final JsonValue jsonValue = packageJson.get("requires"); if (jsonValue.getValueType() != JsonValue.ValueType.OBJECT) { final JsonObjectBuilder requiresBuilder = Json.createObjectBuilder(); final JsonObject dependencies = packageJson.getJsonObject("dependencies");
checkContextForValue(); switch (value.getValueType()) { case ARRAY: JsonArray array = (JsonArray)value; JsonObject object = (JsonObject)value; writeStartObject(); for(Map.Entry<String, JsonValue> member: object.entrySet()) { write(member.getKey(), member.getValue()); case STRING: JsonString str = (JsonString)value; write(str.getString()); break; case NUMBER: JsonNumber number = (JsonNumber)value; writeValue(number.toString()); popFieldContext(); break;
private static boolean areEqualsIgnoringOrder(final JsonValue oldValue, final JsonValue newValue) { if (!oldValue.getValueType().equals(newValue.getValueType())) { return false; switch (oldValue.getValueType()) { case STRING: return JsonString.class.cast(oldValue).getString().equals(JsonString.class.cast(newValue).getString()); case NUMBER: return JsonNumber.class.cast(oldValue).doubleValue() == JsonNumber.class.cast(newValue).doubleValue(); case OBJECT: final JsonObject oldObject = oldValue.asJsonObject(); final JsonObject newObject = newValue.asJsonObject(); if (!oldObject.keySet().equals(newObject.keySet())) { return false; .keySet() .stream() .map(key -> areEqualsIgnoringOrder(oldObject.get(key), newObject.get(key))) .reduce(true, (a, b) -> a && b); case ARRAY: final JsonArray oldArray = oldValue.asJsonArray(); final JsonArray newArray = newValue.asJsonArray(); if (oldArray.size() != newArray.size()) { return false; if (oldArray.isEmpty()) { return true;
@Override public Optional<Function<JsonValue, Stream<ValidationResult.ValidationError>>> create(final ValidationContext model) { if (model.getSchema().getString("type", "object").equals("string")) { return Optional.ofNullable(model.getSchema().get("maxLength")) .filter(v -> v.getValueType() == JsonValue.ValueType.NUMBER) .map(m -> new Impl(model.toPointer(), model.getValueProvider(), JsonNumber.class.cast(m).intValue())); } return Optional.empty(); }
/** * Gets the value of the specified key from the {@link javax.json.JsonObject} * * @param name the key whose value is to be retrieved. * @param jsonObject the JSON object representing headers or claims set. * @return the value of the specified key. */ public static String getValue(String name, JsonObject jsonObject) { JsonValue value = jsonObject.get(name); if (value != null) { if (ARRAY.equals(value.getValueType())) { JsonArray array = (JsonArray) value; for (JsonValue jsonValue : array) { return getValue(jsonValue); } } else if (STRING.equals(value.getValueType())) { return ((JsonString) value).getString(); } else if (NUMBER.equals(value.getValueType())) { return ((JsonNumber) value).bigDecimalValue().toPlainString(); } else if (TRUE.equals(value.getValueType()) || FALSE.equals(value.getValueType())) { return value.toString(); } } return null; } }
private static String getJsonString(JsonObject obj, String prop) throws ChaincodeCollectionConfigurationException { JsonValue ret = obj.get(prop); if (ret == null) { throw new ChaincodeCollectionConfigurationException(format("property %s missing", prop)); } if (ret.getValueType() != JsonValue.ValueType.STRING) { throw new ChaincodeCollectionConfigurationException(format("property %s wrong type expected string got %s", prop, ret.getValueType().name())); } return obj.getString(prop); }
private List<Speaker> extractSpeakerList(JsonObject talkObject, String code, String title) { List<Speaker> speakerList = new ArrayList<>(); String mainSpeakerName = talkObject.getString("mainSpeaker"); if (Arrays.asList(IGNORED_SPEAKER_NAMES).contains(mainSpeakerName)) { return speakerList; } speakerList.add(getSpeakerOrCreateOneIfNull(code, title, mainSpeakerName)); if (talkObject.containsKey("secondarySpeaker")) { String secondarySpeakerName = talkObject.getString("secondarySpeaker"); speakerList.add(getSpeakerOrCreateOneIfNull(code, title, secondarySpeakerName)); } if (talkObject.containsKey("otherSpeakers")) { JsonArray otherSpeakersArray = talkObject.getJsonArray("otherSpeakers"); for (JsonValue otherSpeakerName : otherSpeakersArray) { speakerList.add(getSpeakerOrCreateOneIfNull(code, title, otherSpeakerName.toString().replaceAll("\"", ""))); } } return speakerList; }
for (int i = 1; i < s; i++) { switch (value.getValueType()) { case OBJECT: JsonObject object = (JsonObject) value; references[s-i-1] = NodeReference.of(object, tokens[i]); if (i < s-1) { value = object.get(tokens[i]); if (value == null) { references[s-i-1] = NodeReference.of(array, index); if (i < s-1 && index != -1) { if (index >= array.size()) { throw new JsonException(JsonMessages.NODEREF_ARRAY_INDEX_ERR(index, array.size())); value = array.get(index); throw new JsonException(JsonMessages.POINTER_REFERENCE_INVALID(value.getValueType()));
/** * Map a field value to a string, either directly or via the symbolic map. * * @param field the object field to examine * * @return the resulting string, or null if invalid */ @Nullable protected String desymbolize(@Nonnull final JsonValue field) { switch (field.getValueType()) { case STRING: return ((JsonString) field).getString(); case NUMBER: return symbolics.inverse().get(((JsonNumber) field).intValueExact()); default: return null; } }
@Override public Optional<Function<JsonValue, Stream<ValidationResult.ValidationError>>> create(final ValidationContext model) { if (model.getSchema().getString("type", "object").equals("string")) { return Optional.ofNullable(model.getSchema().get("pattern")) .filter(val -> val.getValueType() == JsonValue.ValueType.STRING) .map(pattern -> new Impl(model.toPointer(), model.getValueProvider(), predicateFactory.apply(JsonString.class.cast(pattern).getString()))); } return Optional.empty(); }
private static JsonObject getJsonObject(JsonObject object, String propName) { JsonObject obj = null; JsonValue val = object.get(propName); if (val != null && val.getValueType() == ValueType.OBJECT) { obj = val.asJsonObject(); } return obj; }
@Override public void serialize(JsonValue value, ObjectWriter writer, Context ctx) { ValueType type = value.getValueType(); if (ValueType.STRING == type) writer.writeValue(((JsonString) value).getString()); else if (ValueType.ARRAY == type) writeArray((JsonArray) value, writer, ctx); else if (ValueType.OBJECT == type) writeObject((JsonObject) value, writer, ctx); else if (ValueType.NULL == type) writer.writeNull(); else if (ValueType.NUMBER == type) { JsonNumber num = (JsonNumber) value; if (num.isIntegral()) writer.writeValue(num.longValue()); else writer.writeValue(num.bigDecimalValue()); } else if (ValueType.FALSE == type) writer.writeValue(false); else if (ValueType.TRUE == type) writer.writeValue(true); else { throw new IllegalStateException("Unknown ValueType " + type); } }
@Test public void serializeMapWithMixedKeysAsJsonArrayOfEntryObjects() { Map<Object, String> map = new LinkedHashMap<>(); map.put( "foo", "bar" ); map.put( newSomeValue( "baz" ), "bazar" ); JsonValue json = jsonSerialization.toJson( map ); assertThat( json.getValueType(), is( JsonValue.ValueType.ARRAY ) ); JsonArray jsonArray = (JsonArray) json; JsonObject fooEntry = jsonArray.getJsonObject( 0 ); JsonObject bazEntry = jsonArray.getJsonObject( 1 ); assertThat( fooEntry.getString( "key" ), equalTo( "foo" ) ); assertThat( fooEntry.getString( "value" ), equalTo( "bar" ) ); assertThat( bazEntry.getJsonObject( "key" ).getString( "foo" ), equalTo( "baz" ) ); assertThat( bazEntry.getString( "value" ), equalTo( "bazar" ) ); }
public static JsonObject getDeploymentByName(String path, String name, URL url) throws IOException { JsonObject deploymentJSON = getPageAsJSONObject(path, url); JsonArray deployments = deploymentJSON.getJsonArray(BDAS); JsonObject result = null; for (int i = 0; i < deployments.size(); i++) { String bdaId = deployments.getJsonObject(i).get(BDA_ID).toString(); if (bdaId.contains(name)) { result = deployments.getJsonObject(i); } } return result; }