Java Code Examples for com.fasterxml.jackson.core.ObjectCodec#treeToValue()

/**
 * Convert raw data to {@code Node}
 * @param parser - JSON reader
 * @return path node
 * @throws IOException
 */
private Node toNode(JsonParser parser) throws IOException {
    ObjectCodec codec = parser.getCodec();
    TreeNode tree = parser.readValueAsTree();
    String tag = codec.treeToValue(tree.path(FieldName.TAG), String.class);
    Integer index = codec.treeToValue(tree.path(FieldName.INDEX), Integer.class);
    String innerText = codec.treeToValue(tree.path(FieldName.INNER_TEXT), String.class);
    String id = codec.treeToValue(tree.path(FieldName.ID), String.class);
    //noinspection unchecked
    Set<String> classes = codec.treeToValue(tree.path(FieldName.CLASSES), Set.class);
    //noinspection unchecked
    Map<String, String> attributes = codec.treeToValue(tree.path(FieldName.OTHER), Map.class);
    return new NodeBuilder()
            //TODO: fix attribute setting, because they override 'id' and 'classes' property
            .setAttributes(attributes)
            .setTag(tag)
            .setIndex(index)
            .setId(id)
            .addContent(innerText)
            .setClasses(classes)
            .build();
}
 

@Override
public T deserialize( JsonParser p, DeserializationContext ctxt ) throws IOException
{
    final ObjectCodec oc = p.getCodec();
    final JsonNode jsonNode;

    if ( oc instanceof XmlMapper )
    {
        jsonNode = createJsonNode( p, ctxt );
        return objectMapper.treeToValue( jsonNode, overrideClass );
    }
    else
    {
        jsonNode = oc.readTree( p );
        // original object mapper must be used since it may have different serialization settings
        return oc.treeToValue( jsonNode, overrideClass );
    }
}
 

@Override
public Node deserialize(JsonParser parser, DeserializationContext ctxt) throws IOException {
    ObjectCodec codec = parser.getCodec();
    TreeNode tree = parser.readValueAsTree();
    String tag = codec.treeToValue(tree.path(FieldName.TAG), String.class);
    Integer index = codec.treeToValue(tree.path(FieldName.INDEX), Integer.class);
    String innerText = codec.treeToValue(tree.path(FieldName.INNER_TEXT), String.class);
    String id = codec.treeToValue(tree.path(FieldName.ID), String.class);
    String classes = codec.treeToValue(tree.path(FieldName.CLASSES), String.class);
    Map<String, String> attributes = codec.treeToValue(tree.path(FieldName.OTHER), Map.class);
    attributes.put(FieldName.ID, id);
    attributes.put(FieldName.CLASS, classes);
    return new NodeBuilder()
            .setTag(tag)
            .setIndex(index)
            .addContent(innerText)
            .setAttributes(attributes)
            .build();
}
 

@Override
public RedmineComment deserialize(JsonParser parser,
		DeserializationContext context) throws IOException,
		JsonProcessingException {

	ObjectCodec oc = parser.getCodec();
	JsonNode node = oc.readTree(parser);

	RedmineComment comment = new RedmineComment();
	comment.setCommentId(getText(node, "id"));
	comment.setText(getText(node, "notes"));
	comment.setCreationTime(getDate(node, context, "created_on"));
	comment.setCreator(getText(node, "user", "name"));
	comment.setCreatorId(getInteger(node, "user", "id") );

	JsonNode detailsNode = node.get("details");
	if (null != detailsNode) {
		RedmineCommentDetails[] details = oc.treeToValue(detailsNode,
				RedmineCommentDetails[].class);
		for (RedmineCommentDetails d : details) {
			comment.getDetails().add(d);
		}
	}

	return comment;
}
 

@Override
public SourceForgeComment deserialize(JsonParser parser,
        DeserializationContext context) throws IOException,
        JsonProcessingException {
    
    ObjectCodec oc = parser.getCodec();
    JsonNode node = oc.readTree(parser);
    
    JsonNode attachmentsNode = node.path("attachments");
    SourceForgeAttachment[] attachments = oc.treeToValue(attachmentsNode, SourceForgeAttachment[].class);
    
    SourceForgeComment comment = new SourceForgeComment();
    comment.setSubject(getText(node, "subject"));
    comment.setText(getText(node, "text"));
    comment.setCreator(getText(node,"author"));
    comment.setAttachments(attachments);
    comment.setCommentId(getText(node, "slug"));
    comment.setCreationTime(getDate(node, SourceForgeConstants.RESPONSE_DATE_FORMATTER, "timestamp"));
    comment.setUpdateDate(getDate(node, SourceForgeConstants.RESPONSE_DATE_FORMATTER, "last_edited"));
    
    return comment;
}
 

@Override
public SourceForgeTopic deserialize(JsonParser parser,
        DeserializationContext context) throws IOException,
        JsonProcessingException {
    ObjectCodec oc = parser.getCodec();
    JsonNode node = oc.readTree(parser);

    node = node.get("topic");
    
    SourceForgeTopic topic = new SourceForgeTopic();
   
    String topicId = getText(node, "_id");

    topic.setTopicId(topicId);
    topic.setDiscussionId(getText(node, "discussion_id"));
    topic.setSubject(getText(node, "subject"));

    JsonNode articlesNode = node.path("posts");
    SourceForgeArticle[] articles = oc.treeToValue(articlesNode, SourceForgeArticle[].class);
    for (SourceForgeArticle article: articles) {
    	article.setMessageThreadId(topicId);
        topic.getArticles().add(article);
    }
    
    return topic;
}
 

@Override
public SourceForgeArticle deserialize(JsonParser parser,
        DeserializationContext context) throws IOException,
        JsonProcessingException {

    ObjectCodec oc = parser.getCodec();
    JsonNode node = oc.readTree(parser);
    
    JsonNode attachmentsNode = node.path("attachments");
    SourceForgeAttachment[] attachments = oc.treeToValue(attachmentsNode, SourceForgeAttachment[].class);
    
    SourceForgeArticle article = new SourceForgeArticle();
    article.setArticleNumber(articleNumber++);
    article.setSubject(getText(node, "subject"));
    article.setText(getText(node, "text"));
    article.setUser(getText(node,"author"));
    article.setAttachments(attachments);
    article.setArticleId(getText(node, "slug"));
    article.setDate(getDate(node, SourceForgeConstants.RESPONSE_DATE_FORMATTER, "timestamp"));
    article.setUpdateDate(getDate(node, SourceForgeConstants.RESPONSE_DATE_FORMATTER, "last_edited"));
    article.setReferences(new String[0]);
    return article;
}
 

@Override
public BlockElementAction deserialize(JsonParser p, DeserializationContext context) throws IOException {
  BlockElementAction.Builder builder = BlockElementAction.builder();
  ObjectCodec codec = p.getCodec();
  JsonNode node = codec.readTree(p);
  builder.setBlockId(node.get(BLOCK_ID_FIELD).asText());

  // select menu elements don't send a value field, they send a `selected_option` object that has a value field
  if (node.has("selected_option")) {
    builder.setSelectedValue(readOptionalString(node.get("selected_option"), VALUE_FIELD));
  } else {
    builder.setSelectedValue(readOptionalString(node, VALUE_FIELD));
  }

  // datepickers don't have a value field, but they have a "selected_date" field with a LocalDate-style string
  if (node.has("selected_date")) {
    readOptionalString(node, SELECTED_DATE_FIELD)
            .map(LocalDate::parse)
            .ifPresent(builder::setSelectedDate);
  }

  builder.setActionTs(readOptionalString(node, ACTION_TS_FIELD));
  BlockElement element = codec.treeToValue(node, BlockElement.class);
  builder.setElement(element);
  return builder.build();
}
 

@Override
public StateActionValue deserialize(JsonParser p, DeserializationContext context) throws IOException {
  final StateActionValue.Builder builder = StateActionValue.builder();

  ObjectCodec codec = p.getCodec();
  JsonNode node = codec.readTree(p);

  if (node.has("type")) {
    builder.setBlockElementType(node.get("type").asText());
  }

  if (node.has("value")) {
    builder.setBlockElementValue(node.get("value").asText());
  } else if (node.has("selected_option")) {
    final JsonNode selectedOption = node.get("selected_option");
    final Option option = codec.treeToValue(selectedOption, Option.class);
    builder.setBlockElementValue(option);
  } else if (node.has("selected_date")) {
    builder.setBlockElementValue(LocalDate.parse(node.get("selected_date").asText()));
  }

  return builder.build();
}
 

@Override
public ValueImpl deserialize(JsonParser jsonParser,
		DeserializationContext ctxt) throws IOException {

	ObjectCodec mapper = jsonParser.getCodec();
	JsonNode root = mapper.readTree(jsonParser);
	Class<? extends ValueImpl> valueClass = getValueClass(root, jsonParser);

	return mapper.treeToValue(root, valueClass);
}
 

@Override
public ImageBlockOrText deserialize(JsonParser p, DeserializationContext context) throws IOException {
  ObjectCodec codec = p.getCodec();
  JsonNode node = codec.readTree(p);

  String type = node.get(TYPE_FIELD).asText();
  if (Image.TYPE.equals(type)) {
    return codec.treeToValue(node, Image.class);
  }

  return codec.treeToValue(node, Text.class);
}
 

@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 BlockOrAttachment deserialize(JsonParser jsonParser, DeserializationContext context) throws IOException {
  ObjectCodec codec = jsonParser.getCodec();
  JsonNode node = codec.readTree(jsonParser);

  if (node.has(TYPE_FIELD)) {
    return codec.treeToValue(node, Block.class);
  } else {
    return codec.treeToValue(node, Attachment.class);
  }
}
 

Object deserialize(JsonNode node, String fieldName, Class targetClass, DeserializationContext ctxt) throws IOException {
    final String type = getFieldClassFQN(targetClass, type());
    try {
        final Class<?> fieldClass = Thread.currentThread().getContextClassLoader().loadClass(type);

        // check if we have embedded interface field, in which case the target field won't be declared on the target
        // class but rather on the class pointed to by the field
        // e.g. given:
        // trafficPolicy:
        //        loadBalancer:
        //          simple: ROUND_ROBIN
        // LoadBalancerSettings (loadBalancer field) doesn't have a `simple` field, this is just an unwrapped
        // implementation of the LbPolicy interface, so we need to check the type of the `simple` field and deserialize
        // the node as an instance of that class instead.
        final Optional<Field> field = getField(targetClass, fieldName);
        final ObjectCodec codec = ctxt.getParser().getCodec();
        if (field.isPresent()) {
            // if field is present, deserialize it with the specified field class
            return codec.treeToValue(getTargetNode(node, fieldName), fieldClass);
        } else {
            // otherwise, get the type of the field
            final Class<?> childFieldClass = fieldClass.getDeclaredField(fieldName).getType();
            // deserialize the field using that new class
            Object childObject = codec.treeToValue(getTargetNode(node, fieldName), childFieldClass);
            // finally, build the instance assigning it the deserialized child field
            // NOTE: this only works if the interface implementation only has one field (since otherwise, there won't
            // be a single-argument constructor accepting an instance of the newly created instance
            return fieldClass.getDeclaredConstructor(childFieldClass).newInstance(childObject);
        }
    } catch (ClassNotFoundException | JsonProcessingException | NoSuchFieldException | NoSuchMethodException |
            InstantiationException | IllegalAccessException | InvocationTargetException e) {
        throw new RuntimeException("Unsupported type '" + type + "' for field '" + fieldName + "' on '" + targetClass.getName() + "' class", e);
    }
}
 

@SuppressWarnings("unchecked")
public T deserialize(JsonParser jsonParser, DeserializationContext context) throws IOException {
  ObjectCodec objectCodec = jsonParser.getCodec();
  ObjectNode objectNode = objectCodec.readTree(jsonParser);

  String typeValue = null;
  JsonNode type = objectNode.get(TYPE_PROPERTY);
  if (type != null) {
    typeValue = type.asText();

    if (STRING_PROPERTY_VALUE.equals(typeValue)) {
      if (objectNode.get(ENUM_PROPERTY) != null) {
        typeValue = "enum";
      }
    }
  } else {
    if (objectNode.get(REF_PROPERTY) != null) {
      typeValue = "ref";
    }
  }

  if (typeValue == null) {
    throw new JsonParseException(jsonParser, "Unknown object type.");
  }

  DeserializationConfig config = context.getConfig();

  AnnotatedClass annotatedClass =
      AnnotatedClassResolver.resolveWithoutSuperTypes(config, handledType());
  List<NamedType> subtypes = config.getAnnotationIntrospector().findSubtypes(annotatedClass);

  for (NamedType namedType : subtypes) {
    if (typeValue.equals(namedType.getName())) {
      return (T) objectCodec.treeToValue(objectNode, namedType.getType());
    }
  }

  throw new JsonParseException(jsonParser, "Unknown object type " + typeValue + ".");
}
 

/**
 * {@inheritDoc}
 */
@Override
public CertPath deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {

    ObjectCodec oc = p.getCodec();
    ArrayNode node = oc.readTree(p);
    List<Certificate> list = new ArrayList<>();
    for (JsonNode item : node) {
        X509Certificate certificate = oc.treeToValue(item, X509Certificate.class);
        list.add(certificate);
    }
    return CertificateUtil.generateCertPath(list);
}
 

@Override
public StateBlock deserialize(JsonParser p, DeserializationContext context) throws IOException {
  ObjectCodec codec = p.getCodec();
  JsonNode node = codec.readTree(p);
  return codec.treeToValue(node.get(VALUES_FIELD), StateBlock.class);
}
 

@Override
public LSServerPostMapValuesList deserialize(JsonParser jp, DeserializationContext ctxt)
    throws IOException {
  ObjectCodec oc = jp.getCodec();
  JsonNode node = oc.readTree(jp);
  
  List<LSServerPostMapValues> mappersList = new ArrayList<>();
  for (JsonNode childNode : node) {
    List<LSServerMapField> mappers = new ArrayList<>();
    for (Iterator<Map.Entry<String, JsonNode>> i = childNode.fields(); i.hasNext();) {
      Map.Entry<String, JsonNode> mapperData = i.next();
      String mapperType = mapperData.getKey();
      JsonNode mapperProperties = mapperData.getValue();
      switch (mapperType) {
        case "map_date" :
          LSServerMapDate mapDate = oc.treeToValue(mapperProperties, LSServerMapDate.class);
          mappers.add(mapDate);
          break;
        case "map_field_name" :
          LSServerMapFieldName mapFieldName = oc.treeToValue(mapperProperties, LSServerMapFieldName.class);
          mappers.add(mapFieldName);
          break;
        case "map_field_value" :
          LSServerMapFieldValue mapFieldValue = oc.treeToValue(mapperProperties, LSServerMapFieldValue.class);
          mappers.add(mapFieldValue);
          break;
        case "map_field_copy" :
          LSServerMapFieldCopy mapFieldCopy = oc.treeToValue(mapperProperties, LSServerMapFieldCopy.class);
          mappers.add(mapFieldCopy);
          break;
        case "map_anonymize" :
          LSServerMapFieldAnonymize mapAnonymize = oc.treeToValue(mapperProperties, LSServerMapFieldAnonymize.class);
          mappers.add(mapAnonymize);
          break;
      }
    }
    
    LSServerPostMapValues lsServerPostMapValues = new LSServerPostMapValues();
    lsServerPostMapValues.setMappers(mappers);
    mappersList.add(lsServerPostMapValues);
  }
  
  LSServerPostMapValuesList lsServerPostMapValuesList = new LSServerPostMapValuesList();
  lsServerPostMapValuesList.setMappersList(mappersList);
  return lsServerPostMapValuesList;
}
 

@Override
public SourceForgeTicket deserialize(JsonParser parser,
        DeserializationContext context) throws IOException,
        JsonProcessingException {
    ObjectCodec oc = parser.getCodec();
    JsonNode node = oc.readTree(parser);
    
    node = node.get("ticket");
    
    SourceForgeTicket ticket = new SourceForgeTicket();
    
    JsonNode attachmentsNode = node.path("attachments");
    SourceForgeAttachment[] attachments = oc.treeToValue(attachmentsNode, SourceForgeAttachment[].class);
    
    JsonNode labelsNode = node.path("labels");
    String[] labels = oc.treeToValue(labelsNode, String[].class);
    
    String bugId = getText(node, "ticket_num");
       
    ticket.setBugId(bugId);
    ticket.setAssignee(getText(node, "assigned_to"));
    ticket.setAssigneeId(getText(node, "assigned_to_id"));
    ticket.setAttachments(attachments);
    ticket.setCommentsUrl(getText(node, "discussion_thread_url"));
    ticket.setCreationTime(getDate(node, SourceForgeConstants.RESPONSE_DATE_FORMATTER, "created_date"));
    ticket.setCreator(getText(node, "reported_by"));
    ticket.setCreatorId(getText(node, "reported_by_id"));
    ticket.setDescription(getText(node, "description"));
    ticket.setInternalId(getText(node, "_id"));
    ticket.setLabels(labels);
    ticket.setPrivate(getBoolean(node, "private"));
    ticket.setStatus(getText(node, "status"));
    ticket.setSummary(getText(node, "summary"));
    ticket.setUpdateDate(getDate(node, SourceForgeConstants.RESPONSE_DATE_FORMATTER, "mod_date"));
    ticket.setVotesDown(getInteger(node, "votes_down"));
    ticket.setVotesUp(getInteger(node, "votes_up"));
    
    JsonNode commentsNode = node.path("discussion_thread").path("posts");
    SourceForgeComment[] comments = oc.treeToValue(commentsNode, SourceForgeComment[].class);
    for (SourceForgeComment comment: comments) {
        comment.setBugId(bugId);
        ticket.getComments().add(comment);
    }
    
    return ticket;
}
 

@Override
public RedmineIssue deserialize(JsonParser parser,
		DeserializationContext context) throws IOException,
		JsonProcessingException {
	ObjectCodec oc = parser.getCodec();
	JsonNode node = oc.readTree(parser);

	RedmineIssue issue = new RedmineIssue();

	String bugId = getText(node, "id");

	issue.setBugId(bugId);
	issue.setCategory(getText(node, "category", "name"));
	issue.setCategoryId(getInteger(node, "category", "id"));
	issue.setCreationTime(getDate(node, context, "created_on"));
	issue.setCreator(getText(node, "author", "name"));
	issue.setCreatorId(getInteger(node, "author", "id"));
	issue.setDescription(getText(node, "description"));
	issue.setPriority(getText(node, "priority", "name"));
	issue.setPriorityId(getInteger(node, "priority", "id"));
	issue.setProject(getText(node, "project", "name"));
	issue.setProjectId(getInteger(node, "project", "id"));
	issue.setStatus(getText(node, "status", "name"));
	issue.setStatusId(getInteger(node, "status", "id"));
	issue.setSubject(getText(node, "subject"));
	issue.setTracker(getText(node, "tracker", "name"));
	issue.setTrackerId(getInteger(node, "tracker", "id"));
	issue.setUpdateDate(getDate(node, context, "updated_on"));

	JsonNode commentsNode = node.get("journals");
	if (null != commentsNode) {
		RedmineComment[] comments = oc.treeToValue(commentsNode,
				RedmineComment[].class);
		for (RedmineComment comment : comments) {
			issue.getComments().add(comment);
			comment.setBugId(bugId);
		}
	}

	return issue;
}