@Override public ClientTypeSignatureParameter deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JsonNode node = jp.getCodec().readTree(jp); ParameterKind kind = MAPPER.readValue(MAPPER.treeAsTokens(node.get("kind")), ParameterKind.class); JsonParser jsonValue = MAPPER.treeAsTokens(node.get("value")); Object value; switch (kind) { case TYPE: value = MAPPER.readValue(jsonValue, ClientTypeSignature.class); break; case NAMED_TYPE: value = MAPPER.readValue(jsonValue, NamedTypeSignature.class); break; case LONG: value = MAPPER.readValue(jsonValue, Long.class); break; default: throw new UnsupportedOperationException(format("Unsupported kind [%s]", kind)); } return new ClientTypeSignatureParameter(kind, value); } }
return readValue(treeAsTokens(n), valueType); } catch (JsonProcessingException e) { throw e;
@SuppressWarnings("unchecked") public <T> T getListWith(ObjectMapper mapper, TypeReference<T> t) throws IOException { if (opaque != null) { Type c = t.getType(); if (c instanceof ParameterizedType) { c = ((ParameterizedType)c).getRawType(); } if ( c.equals(opaque.getClass())) { return (T) opaque; } else { throw new IOException(String.format("Attempted to retrieve a list with type of %s. However, the JSON " + "options carried an opaque value of type %s.", t.getType(), opaque.getClass().getName())); } } if (root == null) { return null; } return mapper.treeAsTokens(root).readValueAs(t); }
ObjectMapper mapper = new ObjectMapper(); JsonNode accounts = given().when().expect().statusCode(expectedResponseCode) .get("accounts/" + newClub.getOwner().getCustId() + "/clubs") .as(JsonNode.class); //Jackson's use of generics here are completely unsafe, but that's another issue List<Account> accountList = mapper.readValue( mapper.treeAsTokens(accounts), new TypeReference<List<Account>>(){} ); assertThat(accountList.get(0).getId()).isEqualTo(expectedId);
private Object constructResponseObject(Type returnType, ObjectNode jsonObject) throws IOException { JsonParser returnJsonParser = mapper.treeAsTokens(jsonObject.get(RESULT)); JavaType returnJavaType = mapper.getTypeFactory().constructType(returnType); return mapper.readValue(returnJsonParser, returnJavaType); }
public static <T> /*@Nullable*/ T getConfig(ObjectNode rootObjectNode, String key, TypeReference<T> typeReference) { JsonNode node = rootObjectNode.get(key); if (node == null) { return null; } try { return mapper.readValue(mapper.treeAsTokens(node), typeReference); } catch (IOException e) { logger.error("error parsing config json node '{}': ", key, e); return null; } }
private Object[] convertJsonToParameters(Method m, List<JsonNode> params) throws IOException { Object[] convertedParams = new Object[params.size()]; Type[] parameterTypes = m.getGenericParameterTypes(); for (int i = 0; i < parameterTypes.length; i++) { JsonParser paramJsonParser = mapper.treeAsTokens(params.get(i)); JavaType paramJavaType = mapper.getTypeFactory().constructType(parameterTypes[i]); convertedParams[i] = mapper.readerFor(paramJavaType) .with(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY) .readValue(paramJsonParser); } return convertedParams; }
/** * Reads a JSON-PRC response from the server. This blocks until a response * is received. * * @param returnType the expected return type * @param ips the {@link InputStream} to read from * @return the object returned by the JSON-RPC response * @throws Throwable on error */ private <T> T readResponse(Type returnType, InputStream ips) throws Throwable { JsonNode response = mapper.readTree(new NoCloseInputStream(ips)); logger.debug("JSON-PRC Response: {}", response); if (!response.isObject()) { throw new JsonRpcClientException(0, "Invalid JSON-RPC response", response); } ObjectNode jsonObject = ObjectNode.class.cast(response); if (jsonObject.has(ERROR) && jsonObject.get(ERROR) != null && !jsonObject.get(ERROR).isNull()) { throw exceptionResolver.resolveException(jsonObject); } if (jsonObject.has(RESULT) && !jsonObject.get(RESULT).isNull() && jsonObject.get(RESULT) != null) { JsonParser returnJsonParser = mapper.treeAsTokens(jsonObject.get(RESULT)); JavaType returnJavaType = mapper.getTypeFactory().constructType(returnType); return mapper.readValue(returnJsonParser, returnJavaType); } return null; }
public static <T> List<T> map(final ObjectMapper mapper, final List<JsonNode> xs, final TypeReference<T> resultType) throws IOException { final List<T> result = new ArrayList<>(); for (final JsonNode x : xs) { final T tmp = mapper.<T> readValue(mapper.treeAsTokens(x), resultType); result.add(tmp); } return result; }
public static <T> List<T> map(final ObjectMapper mapper, final List<JsonNode> xs, final TypeReference<T> resultType) throws IOException { final List<T> result = new ArrayList<>(); for (final JsonNode x : xs) { final T tmp = mapper.<T> readValue(mapper.treeAsTokens(x), resultType); result.add(tmp); } return result; }
private BiFunction<JsonNode, Type, Object> makeDeserialiser(ObjectMapper mapper) { final TypeFactory typeFactory = mapper.getTypeFactory(); return (node, type) -> { JavaType javaType = typeFactory.constructType(type); try { final JsonParser jsonParser = mapper.treeAsTokens(node); final ObjectCodec codec = jsonParser.getCodec(); return codec.readValue(jsonParser, javaType); } catch (IOException e) { throw new RuntimeException(e); } }; }
private BiFunction<JsonNode, Type, Object> makeDeserialiser(ObjectMapper mapper) { final TypeFactory typeFactory = mapper.getTypeFactory(); return (node, type) -> { JavaType javaType = typeFactory.constructType(type); try { final JsonParser jsonParser = mapper.treeAsTokens(node); final ObjectCodec codec = jsonParser.getCodec(); return codec.readValue(jsonParser, javaType); } catch (IOException e) { throw new RuntimeException(e); } }; }
private BiFunction<JsonNode, Type, Object> makeDeserialiser(ObjectMapper mapper) { final TypeFactory typeFactory = mapper.getTypeFactory(); return (node, type) -> { JavaType javaType = typeFactory.constructType(type); try { final JsonParser jsonParser = mapper.treeAsTokens(node); final ObjectCodec codec = jsonParser.getCodec(); return codec.readValue(jsonParser, javaType); } catch (IOException e) { throw new RuntimeException(e); } }; } }
private BiFunction<JsonNode, Type, Object> makeDeserialiser(ObjectMapper mapper) { final TypeFactory typeFactory = mapper.getTypeFactory(); return (node, type) -> { JavaType javaType = typeFactory.constructType(type); try { final JsonParser jsonParser = mapper.treeAsTokens(node); final ObjectCodec codec = jsonParser.getCodec(); return codec.readValue(jsonParser, javaType); } catch (IOException e) { throw new RuntimeException(e); } }; } }
/** Get the value of specified column safely cast to type specifed via {@code typeReference}. */ public <T> T get(String columnName, TypeReference<T> typeReference) { ObjectMapper mapper = BatfishObjectMapper.mapper(); JsonNode node = get(columnName); try { return mapper.readValue(mapper.treeAsTokens(node), typeReference); } catch (IOException e) { throw new ClassCastException( String.format( "Cannot cast row element in column '%s' given the provided TypeReference: %s", columnName, Throwables.getStackTraceAsString(e))); } }
public Event deserialize(String value) throws IOException { JsonNode jsonNode = objectMapper.readTree(value); String type = jsonNode.path("type").asText(); EventDTO dto = objectMapper.readValue( objectMapper.treeAsTokens(jsonNode), retrieveDTOClass(type)); return dto.toEvent(); }
/** * Deserializes a <a href="http://jsonapi.org/format/#document-meta">JSON-API meta object</a> to a {@code Map} * keyed by the member names. Because {@code meta} objects contain arbitrary information, the values in the * map are of unknown type. * * @param metaNode a JsonNode representing a meta object * @return a Map of the meta information, keyed by member name. */ private Map<String, Object> mapMeta(JsonNode metaNode) { JsonParser p = objectMapper.treeAsTokens(metaNode); MapType mapType = TypeFactory.defaultInstance() .constructMapType(HashMap.class, String.class, Object.class); try { return objectMapper.readValue(p, mapType); } catch (IOException e) { // TODO: log? No recovery. } return null; }
@SuppressWarnings("unchecked") public <T> T getListWith(ObjectMapper mapper, TypeReference<T> t) throws IOException { if (opaque != null) { Type c = t.getType(); if (c instanceof ParameterizedType) { c = ((ParameterizedType)c).getRawType(); } if ( c.equals(opaque.getClass())) { return (T) opaque; } else { throw new IOException(String.format("Attempted to retrieve a list with type of %s. However, the JSON " + "options carried an opaque value of type %s.", t.getType(), opaque.getClass().getName())); } } if (root == null) { return null; } return mapper.treeAsTokens(root).readValueAs(t); }
@SuppressWarnings("unchecked") public <T> T getListWith(ObjectMapper mapper, TypeReference<T> t) throws IOException { if (opaque != null) { Type c = t.getType(); if (c instanceof ParameterizedType) { c = ((ParameterizedType)c).getRawType(); } if ( c.equals(opaque.getClass())) { return (T) opaque; } else { throw new IOException(String.format("Attempted to retrieve a list with type of %s. However, the JSON " + "options carried an opaque value of type %s.", t.getType(), opaque.getClass().getName())); } } if (root == null) { return null; } return mapper.treeAsTokens(root).readValueAs(t); }
@SuppressWarnings("unchecked") public static <T extends MessageOrBuilder> List<T> writeAndReadBack(ObjectMapper mapper, List<T> values) { if (values.isEmpty()) { return Collections.emptyList(); } Class<T> messageType = (Class<T>) values.get(0).getClass(); JsonParser parser = mapper.treeAsTokens(toTree(mapper, values)); try { return Lists.newArrayList(mapper.readValues(parser, messageType)); } catch (IOException e) { throw new RuntimeException(e); } }