Best code snippets using com.fasterxml.jackson.databind.ObjectMapper(Showing top 20 results out of 13,842)

private boolean isAccumuloView(byte[] data)
    throws IOException
{
  // AccumuloView contains a 'data' node
  return mapper.reader().readTree(new String(data)).has("data");
}

 final String json = "{\"objects\" : [\"One\", \"Two\", \"Three\"]}";

final JsonNode arrNode = new ObjectMapper().readTree(json).get("objects");
if (arrNode.isArray()) {
  for (final JsonNode objNode : arrNode) {
    System.out.println(objNode);
  }
}

private static void apply(Object objectToSerialize, String str, ObjectMapper mapper) {
  final ObjectNode lhs = mapper.convertValue(objectToSerialize, ObjectNode.class);
  ObjectNode rhs = null;
  try {
    rhs = mapper.readValue(str, ObjectNode.class);
  } catch (IOException e) {
    LOGGER.error("Failed to read value", e);
  }
  if (!lhs.equals(new ObjectNodeComparator(), rhs)) {
    fail(String.format("Serialized object:\n%s\ndoes not equal to expected serialized string:\n%s", lhs, rhs));
  }
}

public static void convertSignalDefinitionsToJson(BpmnModel bpmnModel, ObjectNode propertiesNode) {
 if (bpmnModel.getSignals() != null) {
  ArrayNode signalDefinitions = objectMapper.createArrayNode();
  for (Signal signal : bpmnModel.getSignals()) {
   ObjectNode signalNode = signalDefinitions.addObject();
   signalNode.put(PROPERTY_SIGNAL_DEFINITION_ID, signal.getId());
   signalNode.put(PROPERTY_SIGNAL_DEFINITION_NAME, signal.getName());
   signalNode.put(PROPERTY_SIGNAL_DEFINITION_SCOPE, signal.getScope());
  }
  propertiesNode.set(PROPERTY_SIGNAL_DEFINITIONS, signalDefinitions);
 }
}

public static void convertMessagesToJson(BpmnModel bpmnModel, ObjectNode propertiesNode) {
 if (bpmnModel.getMessages() != null) {
  ArrayNode messageDefinitions = objectMapper.createArrayNode();
  for (Message message : bpmnModel.getMessages()) {
   ObjectNode messageNode = messageDefinitions.addObject();
   messageNode.put(PROPERTY_MESSAGE_DEFINITION_ID, message.getId());
   messageNode.put(PROPERTY_MESSAGE_DEFINITION_NAME, message.getName());
  }
  propertiesNode.set(PROPERTY_MESSAGE_DEFINITIONS, messageDefinitions);
 }
}

private ObjectNode objectSchema(JsonNode exampleObject) {
  ObjectNode schema = this.objectMapper.createObjectNode();
  schema.put("type", "object");
  ObjectNode properties = this.objectMapper.createObjectNode();
  for (Iterator<String> iter = exampleObject.fieldNames(); iter.hasNext();) {
    String property = iter.next();
    properties.set(property, schemaFromExample(exampleObject.get(property)));
  }
  schema.set("properties", properties);
  return schema;
}

private JsonNode mergeArrayItems(JsonNode exampleArray) {
  ObjectNode mergedItems = this.objectMapper.createObjectNode();
  for (JsonNode item : exampleArray) {
    if (item.isObject()) {
      mergeObjectNodes(mergedItems, (ObjectNode) item);
    }
  }
  return mergedItems;
}

/**
 *  Example to readJson using TreeModel
 */
private static void readJson() throws IOException {
  ObjectMapper mapper = new ObjectMapper();
  JsonNode rootNode = mapper.readValue("{\"message\":\"Hi\",\"place\":{\"name\":\"World!\"}}", JsonNode.class);
  String message = rootNode.get("message").asText(); // get property message
  JsonNode childNode =  rootNode.get("place"); // get object Place
  String place = childNode.get("name").asText(); // get property name
  System.out.println(message + " " + place); // print "Hi World!"
}

public static ObjectNode createPositionNode(double x, double y) {
 ObjectNode positionNode = objectMapper.createObjectNode();
 positionNode.put(EDITOR_BOUNDS_X, x);
 positionNode.put(EDITOR_BOUNDS_Y, y);
 return positionNode;
}

  @Override
  public Response deserialize(JsonParser jp, DeserializationContext ctxt)
      throws IOException {
    JsonNode node = jp.getCodec().readTree(jp);
    JsonNode sub = node.get("$ref");

    if (sub != null) {
      return Json.mapper().convertValue(node, RefResponse.class);
    } else {
      Response response = Json.responseMapper().convertValue(node, Response.class);
      return response;
    }
  }
}

protected void convertElementToJson(ObjectNode propertiesNode, BaseElement baseElement) {
 BoundaryEvent boundaryEvent = (BoundaryEvent) baseElement;
 ArrayNode dockersArrayNode = objectMapper.createArrayNode();
 ObjectNode dockNode = objectMapper.createObjectNode();
 GraphicInfo graphicInfo = model.getGraphicInfo(boundaryEvent.getId());
 GraphicInfo parentGraphicInfo = model.getGraphicInfo(boundaryEvent.getAttachedToRef().getId());
 dockNode.put(EDITOR_BOUNDS_X, graphicInfo.getX() - parentGraphicInfo.getX());
 dockNode.put(EDITOR_BOUNDS_Y, graphicInfo.getY() - parentGraphicInfo.getY());
 dockersArrayNode.add(dockNode);
 flowElementNode.set("dockers", dockersArrayNode);
 propertiesNode.put(PROPERTY_CANCEL_ACTIVITY, boundaryEvent.isCancelActivity());
 addEventProperties(boundaryEvent, propertiesNode);
}

@Test
public void gelfLayout() throws IOException {
  final Logger logger = context.getLogger();
  logger.info("Message");
  final String gelf = context.getListAppender("list").getMessages().get(0);
  final ObjectMapper mapper = new ObjectMapper();
  final JsonNode json = mapper.readTree(gelf);
  assertEquals("Message", json.get("short_message").asText());
  assertEquals("myhost", json.get("host").asText());
  assertEquals("FOO", json.get("_foo").asText());
  assertEquals(new JavaLookup().getRuntime(), json.get("_runtime").asText());
}

  public static Optional<AbsoluteRange> extractHistogramBoundaries(final String query) {
    try {
      final JsonParser jp = OBJECT_MAPPER.getFactory().createParser(query);
      final JsonNode rootNode = OBJECT_MAPPER.readTree(jp);
      final JsonNode timestampNode = rootNode.findValue("range").findValue("timestamp");
      final String from = elasticSearchTimeFormatToISO8601(timestampNode.findValue("from").asText());
      final String to = elasticSearchTimeFormatToISO8601(timestampNode.findValue("to").asText());

      return Optional.of(AbsoluteRange.create(from, to));
    } catch (Exception ignored) {
      return Optional.empty();
    }
  }
}

public static JsonNode validateIfNodeIsTextual(JsonNode node) {
 if (node != null && !node.isNull() && node.isTextual() && StringUtils.isNotEmpty(node.asText())) {
  try {
   node = validateIfNodeIsTextual(objectMapper.readTree(node.asText()));
  } catch(Exception e) {
   logger.error("Error converting textual node", e);
  }
 }
 return node;
}

private static Map<String, Object> getVendorExtensions(JsonNode node) {
  Map<String, Object> result = new HashMap<String, Object>();
  Iterator<String> fieldNameIter = node.fieldNames();
  while (fieldNameIter.hasNext()) {
    String fieldName = fieldNameIter.next();
    if(fieldName.startsWith("x-")) {
      JsonNode extensionField = node.get(fieldName);
      Object extensionObject = Json.mapper().convertValue(extensionField, Object.class);
      result.put(fieldName, extensionObject);
    }
  }
  return result;
}

public static ObjectNode createResourceNode(String id) {
 ObjectNode resourceNode = objectMapper.createObjectNode();
 resourceNode.put(EDITOR_SHAPE_ID, id);
 return resourceNode;
}

protected void convertElementToJson(ObjectNode propertiesNode, BaseElement baseElement) {
 SubProcess subProcess = (SubProcess) baseElement;
 propertiesNode.put("activitytype", "Event-Sub-Process");
 propertiesNode.put("subprocesstype", "Embedded");
 ArrayNode subProcessShapesArrayNode = objectMapper.createArrayNode();
 GraphicInfo graphicInfo = model.getGraphicInfo(subProcess.getId());
 processor.processFlowElements(subProcess, model, subProcessShapesArrayNode, formKeyMap, 
   decisionTableKeyMap, graphicInfo.getX(), graphicInfo.getY());
 flowElementNode.set("childShapes", subProcessShapesArrayNode);
}

public static void convertMessagesToJson(Collection<Message> messages, ObjectNode propertiesNode) {
 String propertyName = "messages";
 ArrayNode messagesNode = objectMapper.createArrayNode();
 for (Message message : messages) {
  ObjectNode propertyItemNode = objectMapper.createObjectNode();
  propertyItemNode.put(PROPERTY_MESSAGE_ID, message.getId());
  propertyItemNode.put(PROPERTY_MESSAGE_NAME, message.getName());
  propertyItemNode.put(PROPERTY_MESSAGE_ITEM_REF, message.getItemRef());
  messagesNode.add(propertyItemNode);
 }
 propertiesNode.set(propertyName, messagesNode);
}

public  static void main(String[] args) throws IOException {
  ObjectMapper mapper = new ObjectMapper();
  JsonNode root = mapper.readTree(json);
  String author = root.at("/store/book/3/title").asText();
  System.out.println(author); // print ["Hello, Middle-earth! "]
  System.out.println();
  String jsonHiWorld = "{\"message\":\"Hi\",\"place\":{\"name\":\"World!\"}}\"";
  String message = mapper.readTree(jsonHiWorld).at("/message").asText();
  String place = mapper.readTree(jsonHiWorld).at("/place/name").asText();
  System.out.println(message + " " + place); // print "Hi World!"
}

private ObjectNode arraySchema(JsonNode exampleArray) {
  ObjectNode schema = this.objectMapper.createObjectNode();
  schema.put("type", "array");
  if (exampleArray.size() > 0) {
    JsonNode exampleItem = exampleArray.get(0).isObject() ? mergeArrayItems(exampleArray) : exampleArray.get(0);
    schema.set("items", schemaFromExample(exampleItem));
  }
  return schema;
}