Best code snippets using org.codehaus.jackson.node.ObjectNode(Showing top 20 results out of 477)

/**
 * Get the default schema node.
 *
 * @return The default schema node.
 */
public static JsonNode getDefaultSchemaNode()
{
  ObjectNode objectNode = JsonNodeFactory.instance.objectNode();
  objectNode.put("type", "any");
  // "required" is false by default, no need to include
  //objectNode.put("required", false);
  return objectNode;
}

@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
  // [JACKSON-684]: serialize as index?
  if (provider.isEnabled(SerializationConfig.Feature.WRITE_ENUMS_USING_INDEX)) {
    return createSchemaNode("integer", true);
  }
  ObjectNode objectNode = createSchemaNode("string", true);
  if (typeHint != null) {
    JavaType type = provider.constructType(typeHint);
    if (type.isEnumType()) {
      ArrayNode enumNode = objectNode.putArray("enum");
      for (SerializedString value : _values.values()) {
        enumNode.add(value.getValue());
      }
    }
  }
  return objectNode;
}

@Override
public String toString()
{
  StringBuilder sb = new StringBuilder(32 + (size() << 4));
  sb.append("{");
  if (_children != null) {
    int count = 0;
    for (Map.Entry<String, JsonNode> en : _children.entrySet()) {
      if (count > 0) {
        sb.append(",");
      }
      ++count;
      TextNode.appendQuoted(sb, en.getKey());
      sb.append(':');
      sb.append(en.getValue().toString());
    }
  }
  sb.append("}");
  return sb.toString();
}

@Override
public boolean equals(Object o)
{
  if (o == this) return true;
  if (o == null) return false;
  if (o.getClass() != getClass()) {
    return false;
  }
  ObjectNode other = (ObjectNode) o;
  if (other.size() != size()) {
    return false;
  }
  if (_children != null) {
    for (Map.Entry<String, JsonNode> en : _children.entrySet()) {
      String key = en.getKey();
      JsonNode value = en.getValue();
      JsonNode otherValue = other.get(key);
      if (otherValue == null || !otherValue.equals(value)) {
        return false;
      }
    }
  }
  return true;
}

  @SuppressWarnings("unchecked")
  @Override
  public JsonNode getSchema(SerializerProvider provider, Type typeHint)
    throws JsonMappingException
  {
    ObjectNode o = createSchemaNode("object", true);
    if (typeHint instanceof ParameterizedType) {
      Type[] typeArgs = ((ParameterizedType) typeHint).getActualTypeArguments();
      if (typeArgs.length == 2) {
        JavaType enumType = provider.constructType(typeArgs[0]);
        JavaType valueType = provider.constructType(typeArgs[1]);
        ObjectNode propsNode = JsonNodeFactory.instance.objectNode();
        Class<Enum<?>> enumClass = (Class<Enum<?>>) enumType.getRawClass();
        for (Enum<?> enumValue : enumClass.getEnumConstants()) {
          JsonSerializer<Object> ser = provider.findValueSerializer(valueType.getRawClass(), _property);
          JsonNode schemaNode = (ser instanceof SchemaAware) ?
              ((SchemaAware) ser).getSchema(provider, null) :
              JsonSchema.getDefaultSchemaNode();
          propsNode.put(provider.getConfig().getAnnotationIntrospector().findEnumValue((Enum<?>)enumValue), schemaNode);
        }
        o.put("properties", propsNode);
      }
    }
    return o;
  }
}

throws IOException, JsonProcessingException
ObjectNode node = nodeFactory.objectNode();
JsonToken t = jp.getCurrentToken();
if (t == JsonToken.START_OBJECT) {
    break;
  case VALUE_STRING:
    value = nodeFactory.textNode(jp.getText());
    break;
  default:
    value = deserializeAny(jp, ctxt, nodeFactory);
  JsonNode old = node.put(fieldName, value);
  if (old != null) {
    _handleDuplicateField(fieldName, node, old, value);

objectNode.put("type", schemaType);
if (objectProperties != null) {
  try {
    objectNode.put("properties", new ObjectMapper().readValue(objectProperties, JsonNode.class));
  } catch (IOException e) {
    throw new IllegalStateException(e);
    objectNode.put("items", new ObjectMapper().readValue(itemDefinition, JsonNode.class));
  } catch (IOException e) {
    throw new IllegalStateException(e);

objectNode.put("type", schemaType);
if (objectProperties != null) {
  try {
    objectNode.put("properties", new ObjectMapper().readValue(objectProperties, JsonNode.class));
  } catch (IOException e) {
    throw new IllegalStateException(e);
    objectNode.put("items", new ObjectMapper().readValue(itemDefinition, JsonNode.class));
  } catch (IOException e) {
    throw new IllegalStateException(e);

 protected static String toJson(Map<String, ByteIterator> values)
   throws IOException {
  ObjectNode node = MAPPER.createObjectNode();
  Map<String, String> stringMap = StringByteIterator.getStringMap(values);
  for (Map.Entry<String, String> pair : stringMap.entrySet()) {
   node.put(pair.getKey(), pair.getValue());
  }
  JsonFactory jsonFactory = new JsonFactory();
  Writer writer = new StringWriter();
  JsonGenerator jsonGenerator = jsonFactory.createJsonGenerator(writer);
  MAPPER.writeTree(jsonGenerator, node);
  return writer.toString();
 }
}

  @Test
  public void testReplaceIndexedDocument() throws Exception {
   put(10, createPerson(0, "P", "", "?", "?", "MALE").toString());
   put(10, createPerson(0, "P", "Surname", "?", "?", "MALE").toString());

   ContentResponse response = get("10", "application/json");

   JsonNode person = MAPPER.readTree(response.getContentAsString());
   assertEquals("Surname", person.get("surname").asText());
  }
}

private JsonNode formatSSTable(AbstractCompactionStrategy strategy, SSTableReader sstable)
{
  ObjectNode node = json.objectNode();
  node.put("generation", sstable.descriptor.generation);
  node.put("version", sstable.descriptor.version.getVersion());
  node.put("size", sstable.onDiskLength());
  JsonNode logResult = strategy.strategyLogger().sstable(sstable);
  if (logResult != null)
    node.put("details", logResult);
  return node;
}

private JsonNode shutdownStrategy(AbstractCompactionStrategy strategy)
{
  ObjectNode node = json.objectNode();
  node.put("strategyId", getId(strategy));
  return node;
}

@Test
public void testCounterRollupSerialization() {
  final BluefloodCounterRollup rollup =
      new BluefloodCounterRollup()
          .withCount(123)
          .withRate(987.6d)
          .withSampleCount(5);
  ObjectNode resultNode = RollupSerializationHelper.rollupToJson(rollup);
  Assert.assertEquals(resultNode.get("count").asLong(), rollup.getCount().longValue());
  Assert.assertEquals(resultNode.get("rate").asDouble(), rollup.getRate());
  Assert.assertEquals(resultNode.get("sampleCount").asInt(), rollup.getSampleCount());
}

private static ObjectNode handleTimerRollup(BluefloodTimerRollup rollup) {
  ObjectNode rollupNode = JsonNodeFactory.instance.objectNode();
  rollupNode.put("sum", rollup.getSum());
  rollupNode.put("rate", rollup.getRate());
  rollupNode.put("sampleCount", rollup.getSampleCount());
  return handleBaseRollup(rollup, rollupNode);
}

private void convertDeviceOwnerWebsite(final JsonNode obj) {
 final ObjectNode node = (ObjectNode) obj.path("DeviceOwner");
 final JsonNode current = node.path("Website");
 if (!current.isMissingNode() && !current.isNull()) {
  node.put("Website", this.createValueDatatype("uri", current.asText()));
 }
 if (current.isNull()) {
  node.remove("Website");
 }
}

private void setStringArrayProperty(ObjectNode node, String property, String[] strings) {
  if (strings != null) {
    ArrayNode arrayNode = node.putArray(property);
    for (String string : strings) {
      arrayNode.add(string);
    }
    node.put(property, arrayNode);
  }
}

@Before
public void setUpMockRequest() {
  ObjectMapper mapper = new ObjectMapper();
  ObjectNode mockPluginDef = mapper.createObjectNode();
  mockPluginDef.put("foo", "bar"); //$NON-NLS-1$ //$NON-NLS-2$
  mockPluginDefinitionsArray = mapper.createArrayNode();
  mockPluginDefinitionsArray.add(mockPluginDef);
  when(mockApplicationModeObject.toString()).thenReturn(APPLICATION_MODE);
  when(mockRequest.getAttribute(WebAdminHostPageServlet.ATTR_APPLICATION_MODE)).thenReturn(mockApplicationModeObject);
  when(mockRequest.getAttribute(WebAdminHostPageServlet.ATTR_PLUGIN_DEFS)).thenReturn(mockPluginDefinitionsArray);
}

@Test
public void testSetRollupSerialization() {
  final BluefloodSetRollup rollup0 = new BluefloodSetRollup()
      .withObject(10)
      .withObject(20)
      .withObject(30);
  ObjectNode resultNode = RollupSerializationHelper.rollupToJson(rollup0);
  Assert.assertEquals(resultNode.get("count").asInt(), 3);
}

  /**
   * Gets a binding collection object
   */
  public BindingCollection getBindingCollection() throws IOException {
    return new CloudResource(new URL(owner.retrieve().get("bindingCollection").asText()), owner.getCredential()).coerce(BindingCollection.class);
  }
}

@Test
public void testGetUserInfoObject() {
  ObjectNode result = testServlet.getUserInfoObject(mockUser, "mockSsoToken"); //$NON-NLS-1$ //$NON-NLS-2$
  assertNotNull(result.get("id")); //$NON-NLS-1$
  assertEquals("admin", result.get("userName").asText()); //$NON-NLS-1$ //$NON-NLS-2$
  assertEquals("internal", result.get("domain").asText()); //$NON-NLS-1$ //$NON-NLS-2$
  assertEquals("mockSsoToken", result.get("ssoToken").asText()); //$NON-NLS-1$ //$NON-NLS-2$
}