throws IOException, JsonProcessingException { ObjectCodec oc = jp.getCodec(); JsonNode node = oc.readTree(jp); if (node.isObject()) { String id = node.get("id").asText(); String name = node.get("name").asText(); String symbol = node.get("symbol").asText(); ObjectMapper mapper = new ObjectMapper(); SimpleModule module = new SimpleModule(); module.addDeserializer( CoinMarketCapQuote.class, new CoinMarketCapQuote.CoinMarketCapQuoteDeserializer()); mapper.registerModule(module); Iterator<Map.Entry<String, JsonNode>> it = node.get("quotes").fields(); while (it.hasNext()) { Map.Entry<String, JsonNode> pair = it.next(); quotes.put(pair.getKey(), mapper.treeToValue(pair.getValue(), CoinMarketCapQuote.class));
private List readQueryResultArrayFromString(String str) throws Exception { List result = new ArrayList(); JsonParser jp = mapper.getFactory().createParser(str); if (jp.nextToken() != JsonToken.START_ARRAY) { throw new IAE("not an array [%s]", str); } ObjectCodec objectCodec = jp.getCodec(); while (jp.nextToken() != JsonToken.END_ARRAY) { result.add(objectCodec.readValue(jp, toolChest.getResultTypeReference())); } return result; }
@Override public void writeObject(Object pojo) throws IOException { if (delegateCopyMethods) { delegate.writeObject(pojo); return; } if (pojo == null) { writeNull(); } else { ObjectCodec c = getCodec(); if (c != null) { c.writeValue(this, pojo); return; } _writeSimpleObject(pojo); } }
@Override public Choice.Builder deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { final JsonNode node = jsonParser.getCodec().readTree(jsonParser); return Choice.builder() .nextStateName(node.get(PropertyNames.NEXT).asText()) .condition(conditionDeserializer.deserializeCondition(node)); }
public Message<T> deserialize(JsonParser jsonParser, DeserializationContext arg1) throws IOException, JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); ObjectCodec oc = jsonParser.getCodec(); JsonNode node = oc.readTree(jsonParser); JsonNode timeStamp = node.get("time"); Timestamp time = mapper.readValue(timeStamp, Timestamp.class); JsonNode restAction = node.get("action"); RestAction action = mapper.readValue(restAction, RestAction.class); String type = node.get("type").getTextValue(); Class<?> clz = Class.forName(type); JsonNode list = node.get("data"); JavaType listType = mapper.getTypeFactory().constructCollectionType(List.class, clz); List <T> data = mapper.readValue(list, listType); Message<T> message = new Message<T>; message.setTime(time); message.setAction(action); message.setType(type); message.setData(data); return message; }
@Override public CoinMarketCapArrayData<CoinMarketCapTicker> deserialize( JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { ObjectCodec oc = jp.getCodec(); JsonNode node = oc.readTree(jp); if (node.isObject()) { List<CoinMarketCapTicker> tickers = new LinkedList<>(); ObjectMapper mapper = new ObjectMapper(); SimpleModule module = new SimpleModule(); module.addDeserializer( CoinMarketCapTicker.class, new CoinMarketCapTicker.CoinMarketCapTickerDeserializer()); mapper.registerModule(module); for (JsonNode child : node.get("data")) { tickers.add(mapper.treeToValue(child, CoinMarketCapTicker.class)); } return new CoinMarketCapArrayData<>(tickers); } return null; } }
private ObjectNode parseJsonTree(final InputStream stream) throws IOException, DeserializerException { ObjectMapper objectMapper = new ObjectMapper(); objectMapper.configure(DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY, true); JsonParser parser = new JsonFactory(objectMapper).createParser(stream); final JsonNode tree = parser.getCodec().readTree(parser); if (tree == null || !tree.isObject()) { throw new DeserializerException("Invalid JSON syntax.", DeserializerException.MessageKeys.JSON_SYNTAX_EXCEPTION); } return (ObjectNode) tree; }
@Override public YoBitTrades deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { Map<String, List<YoBitTrade>> trades = new HashMap<>(); ObjectCodec oc = p.getCodec(); JsonNode node = oc.readTree(p); if (node.isObject()) { Iterator<Entry<String, JsonNode>> priceEntryIter = node.fields(); while (priceEntryIter.hasNext()) { Entry<String, JsonNode> priceEntryNode = priceEntryIter.next(); JsonNode priceNode = priceEntryNode.getValue(); String ccyPair = priceEntryNode.getKey(); List<YoBitTrade> res = new ArrayList<>(); trades.put(ccyPair, res); if (priceNode.isArray()) { for (JsonNode jsonNode : priceNode) { ObjectMapper jsonObjectMapper = new ObjectMapper(); res.add(jsonObjectMapper.convertValue(jsonNode, YoBitTrade.class)); } } } } return new YoBitTrades(trades); } }
@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); } }
@Override public RowMap deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { ObjectNode node = jsonParser.getCodec().readTree(jsonParser); JsonNode encrypted = node.get("encrypted"); if (encrypted != null) { String iv = encrypted.get("iv").textValue(); String bytes = encrypted.get("bytes").textValue(); throw new IOException(e); JsonNode decrypted = mapper.readTree(decryptedData); if (!(decrypted instanceof ObjectNode)) { throw new ParseException("`encrypted` must be an object after decrypting."); node.setAll((ObjectNode) decrypted); JsonNode type = node.get("type"); if (type == null) { throw new ParseException("`type` is required and cannot be null.");
@Override public Map<String, Object> deserialize(final JsonParser jsonParser, final DeserializationContext ctxt) throws IOException { final JsonNode node = jsonParser.getCodec().readTree(jsonParser); if (node.asText().equals(ClientHelper.EMPTY_RESULT)) { return new HashMap<String, Object>(); } final JavaType type = new ObjectMapper().getTypeFactory().constructMapType( HashMap.class, String.class, Object.class); return new ObjectMapper().readerFor(type).readValue(node.asText()); } }
@Override public Paths deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { Paths result = new Paths(); JsonNode node = jp.getCodec().readTree(jp); ObjectNode objectNode = (ObjectNode)node; Map<String, Object> extensions = new LinkedHashMap<>(); for (Iterator<String> it = objectNode.fieldNames(); it.hasNext(); ) { String childName = it.next(); JsonNode child = objectNode.get(childName); // if name start with `x-` consider it an extesion if (childName.startsWith("x-")) { extensions.put(childName, Json.mapper().convertValue(child, Object.class)); } else { result.put(childName, Json.mapper().convertValue(child, PathItem.class)); } } if (!extensions.isEmpty()) { result.setExtensions(extensions); } return result; } }
@Override public List<String> deserialize(final JsonParser jsonParser, final DeserializationContext ctxt) throws IOException { final JsonNode node = jsonParser.getCodec().readTree(jsonParser); if (node.toString().equals(ClientHelper.EMPTY_RESULT)) { return new ArrayList<String>(); } final JavaType type = new ObjectMapper().getTypeFactory().constructCollectionType( List.class, String.class); return new ObjectMapper().readerFor(type).readValue(node.toString()); } }
@Nullable @Override public HttpHeaders deserialize(JsonParser p, DeserializationContext ctx) throws IOException { final JsonNode tree = p.getCodec().readTree(p); if (!tree.isObject()) { ctx.reportInputMismatch(HttpHeaders.class, "HTTP headers must be an object."); return null; } final ObjectNode obj = (ObjectNode) tree; final HttpHeaders headers = HttpHeaders.of(); for (final Iterator<Entry<String, JsonNode>> i = obj.fields(); i.hasNext();) { final Entry<String, JsonNode> e = i.next(); final AsciiString name = HttpHeaderNames.of(e.getKey()); final JsonNode values = e.getValue(); if (!values.isArray()) { // Values is a single item, so add it directly. addHeader(ctx, headers, name, values); } else { final int numValues = values.size(); for (int j = 0; j < numValues; j++) { final JsonNode v = values.get(j); addHeader(ctx, headers, name, v); } } } return headers.asImmutable(); }
@Override public BitmexFee deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException, JsonProcessingException { ObjectCodec oc = jsonParser.getCodec(); JsonNode node = oc.readTree(jsonParser); BigDecimal volume = new BigDecimal(node.path(0).asText()); BigDecimal fee = new BigDecimal(node.path(1).asText()); return new BitmexFee(volume, fee); } }
@Override public SlackEvent deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { ObjectCodec codec = p.getCodec(); JsonNode node = codec.readTree(p); SlackEventType type = SlackEventType.get(node.get(TYPE_FIELD).asText()); // Messages can have subtypes that we need to handle if (type == SlackEventType.MESSAGE && node.has(SUBTYPE_FIELD)) { SlackMessageSubtype subtype = SlackMessageSubtype.get(node.get(SUBTYPE_FIELD).asText()); return codec.treeToValue(node, subtype.getMessageClass()); } return codec.treeToValue(node, type.getEventClass()); } }
@Override public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { ObjectNode node = jp.readValueAsTree(); JsonNode kind = node.get("kind"); if (kind == null) { throw new JsonParseException(jp, "No `kind` property!"); } Class kindClass = kinds.get(kind.asText()); if (kindClass == null) { throw ctxt.mappingException("Unknown kind: " + kind); } else { return (Step) jp.getCodec().treeToValue(node, kindClass); } } }
@Override public LedgerType deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException, JsonProcessingException { ObjectCodec oc = jsonParser.getCodec(); JsonNode node = oc.readTree(jsonParser); String ledgerTypeString = node.textValue(); return fromString(ledgerTypeString); } }
@Override public Item deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { ObjectCodec codec = jp.getCodec(); ObjectNode treeNode = codec.readTree(jp); String type = treeNode.get("itemType").textValue(); Class<? extends Item> objectClass = classes.get(type); if (objectClass == null) { objectClass = CustomItem.class; } else { treeNode.remove("itemType"); } Item item = codec.treeToValue(treeNode, objectClass); item.setItemId(treeNode.get("itemId").asText()); return item; } }