How to use

putArray

method

in

org.codehaus.jackson.node.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 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
protected void createArray(JsonNode e, String pName, List<JsonNode> elements) {
  ArrayNode array = ((ObjectNode) e).putArray(pName);
  for (JsonNode objectNode : elements) {
    array.add(objectNode);
  }
}

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);
  }
}

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);
  }
}

public byte[] toBytes() {
  ObjectNode node = JsonNodeFactory.instance.objectNode();
  node.put("default", defaultAccess);
  ArrayNode limitsNode = node.putArray("limits");
  for (Entry<String, Long> limit : limits.entrySet()) {
    ObjectNode limitNode = limitsNode.addObject();
    limitNode.put("store", limit.getKey());
    limitNode.put("limit", limit.getValue());
  }
  return JsonFormat.serializeAsBytesSoft(node, "BlobStoreAccessConfig");
}

@SuppressWarnings("rawtypes")
private void addJsonNode(ObjectNode jsonNode, String key, Object value) {
  if (value instanceof Integer) {
    jsonNode.put(key, (Integer) value);
  } else if (value instanceof String) {
    jsonNode.put(key, (String) value);
  } else if (value instanceof Long) {
    jsonNode.put(key, (Long) value);
  } else if (value instanceof List) {
    ArrayNode arrayNode = jsonNode.putArray(key);
    addListNode(arrayNode, (List) value);
  } else {
    jsonNode.put(key, String.valueOf(value));
  }
}

@GET
@Path("{instanceName}/healthreports")
public Response getHealthReportsOnInstance(@PathParam("clusterId") String clusterId,
  @PathParam("instanceName") String instanceName) throws IOException {
 HelixDataAccessor accessor = getDataAccssor(clusterId);
 ObjectNode root = JsonNodeFactory.instance.objectNode();
 root.put(Properties.id.name(), instanceName);
 ArrayNode healthReportsNode = root.putArray(InstanceProperties.healthreports.name());
 List<String> healthReports =
   accessor.getChildNames(accessor.keyBuilder().healthReports(instanceName));
 if (healthReports != null && healthReports.size() > 0) {
  healthReportsNode.addAll((ArrayNode) OBJECT_MAPPER.valueToTree(healthReports));
 }
 return JSONRepresentation(root);
}

@GET
@Path("{instanceName}/resources")
public Response getResourcesOnInstance(@PathParam("clusterId") String clusterId,
  @PathParam("instanceName") String instanceName) throws IOException {
 HelixDataAccessor accessor = getDataAccssor(clusterId);
 ObjectNode root = JsonNodeFactory.instance.objectNode();
 root.put(Properties.id.name(), instanceName);
 ArrayNode resourcesNode = root.putArray(InstanceProperties.resources.name());
 List<String> sessionIds = accessor.getChildNames(accessor.keyBuilder().sessions(instanceName));
 if (sessionIds == null || sessionIds.size() == 0) {
  return null;
 }
 // Only get resource list from current session id
 String currentSessionId = sessionIds.get(0);
 List<String> resources =
   accessor.getChildNames(accessor.keyBuilder().currentStates(instanceName, currentSessionId));
 if (resources != null && resources.size() > 0) {
  resourcesNode.addAll((ArrayNode) OBJECT_MAPPER.valueToTree(resources));
 }
 return JSONRepresentation(root);
}

@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
  throws JsonMappingException
{
  ObjectNode objectNode = createSchemaNode("string", true);
  if (typeHint != null) {
    JavaType type = TypeFactory.type(typeHint);
    if (type.isEnumType()) {
      ArrayNode enumNode = objectNode.putArray("enum");
      for (String value : _values.values()) {
        enumNode.add(value);
      }
    }
  }
  return objectNode;
}

@GET
public Response getJobs(@PathParam("clusterId") String clusterId,
  @PathParam("workflowName") String workflowName) {
 TaskDriver driver = getTaskDriver(clusterId);
 WorkflowConfig workflowConfig = driver.getWorkflowConfig(workflowName);
 ObjectNode root = JsonNodeFactory.instance.objectNode();
 if (workflowConfig == null) {
  return badRequest(String.format("Workflow %s is not found!", workflowName));
 }
 Set<String> jobs = workflowConfig.getJobDag().getAllNodes();
 root.put(Properties.id.name(), JobProperties.Jobs.name());
 ArrayNode jobsNode = root.putArray(JobProperties.Jobs.name());
 if (jobs != null) {
  jobsNode.addAll((ArrayNode) OBJECT_MAPPER.valueToTree(jobs));
 }
 return JSONRepresentation(root);
}

@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
  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;
}

private ObjectNode writeSpan(Span span) throws IOException {
  log.trace("wirte {}",span);
  ObjectNode jSpan = mapper.createObjectNode();
  jSpan.put("type", span.getType().name());
  jSpan.put("start", span.getStart());
  jSpan.put("end", span.getEnd());
  for(String key : span.getKeys()){
    List<Value<?>> values = span.getValues(key);
    if(values.size() == 1){
      jSpan.put(key, writeValue(values.get(0)));
    } else {
      ArrayNode jValues = jSpan.putArray(key);
      for(Value<?> value : values){
        jValues.add(writeValue(value));
      }
      jSpan.put(key, jValues);
    }
  }
  log.trace(" ... {}",jSpan);
  return jSpan;
}

@GET
public Response getResources(@PathParam("clusterId") String clusterId) {
 ObjectNode root = JsonNodeFactory.instance.objectNode();
 root.put(Properties.id.name(), JsonNodeFactory.instance.textNode(clusterId));
 HelixZkClient zkClient = getHelixZkClient();
 ArrayNode idealStatesNode = root.putArray(ResourceProperties.idealStates.name());
 ArrayNode externalViewsNode = root.putArray(ResourceProperties.externalViews.name());
 List<String> idealStates = zkClient.getChildren(PropertyPathBuilder.idealState(clusterId));
 List<String> externalViews = zkClient.getChildren(PropertyPathBuilder.externalView(clusterId));
 if (idealStates != null) {
  idealStatesNode.addAll((ArrayNode) OBJECT_MAPPER.valueToTree(idealStates));
 } else {
  return notFound();
 }
 if (externalViews != null) {
  externalViewsNode.addAll((ArrayNode) OBJECT_MAPPER.valueToTree(externalViews));
 }
 return JSONRepresentation(root);
}

@Override
ObjectNode toJson() {
 final ObjectNode obj = mapper.createObjectNode();
 final ArrayNode bool = obj.putArray(BooleanPropertyParser.BOOLEAN_PROPERTY);
 for (final QueryClause clause : clauses) {
  final ObjectNode e = bool.addObject();
  e.put(OccurPropertyParser.OCCUR_PROPERTY, clause.getOccur().toString());
  e.putAll(clause.getQuery().toJson());
 }
 return obj;
}

@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 ObjectNode toJson(RecordFilterList filter, Namespaces namespaces, LRepository repository,
    RecordFilterJsonConverter<RecordFilter> converter)
    throws RepositoryException, InterruptedException {
  ObjectNode node = JsonFormat.OBJECT_MAPPER.createObjectNode();
  if (filter.getOperator() != null) {
    node.put("operator", filter.getOperator().toString());
  }
  if (filter.getFilters() != null) {
    ArrayNode filters = node.putArray("filters");
    for (RecordFilter subFilter : filter.getFilters()) {
      filters.add(converter.toJson(subFilter, namespaces, repository, converter));
    }
  }
  return node;
}

@Override
ObjectNode toJson() {
 final ObjectNode obj = mapper.createObjectNode();
 final ObjectNode node = obj.putObject(NodePropertyParser.NODE_PROPERTY);
 node.put(QueryPropertyParser.QUERY_PROPERTY, booleanExpression);
 if (this.hasLevel()) {
  node.put(LevelPropertyParser.LEVEL_PROPERTY, this.getLevel());
 }
 if (this.hasRange()) {
  final ArrayNode array = node.putArray(RangePropertyParser.RANGE_PROPERTY);
  array.add(this.getLowerBound());
  array.add(this.getUpperBound());
 }
 if (this.hasBoost()) {
  node.put(BoostPropertyParser.BOOST_PROPERTY, this.getBoost());
 }
 return obj;
}

@Override
public ObjectNode toJson() {
 final ObjectNode obj = mapper.createObjectNode();
 final ObjectNode node = obj.putObject(NodePropertyParser.NODE_PROPERTY);
 node.put(QueryPropertyParser.QUERY_PROPERTY, booleanExpression);
 if (this.hasLevel()) {
  node.put(LevelPropertyParser.LEVEL_PROPERTY, this.getLevel());
 }
 if (this.hasRange()) {
  final ArrayNode array = node.putArray(RangePropertyParser.RANGE_PROPERTY);
  array.add(this.getLowerBound());
  array.add(this.getUpperBound());
 }
 if (this.hasBoost()) {
  node.put(BoostPropertyParser.BOOST_PROPERTY, this.getBoost());
 }
 return obj;
}

@Private
public JsonNode countersToJSON(Counters counters) {
 ArrayNode nodes = FACTORY.arrayNode();
 if (counters != null) {
  for (CounterGroup counterGroup : counters) {
   ObjectNode groupNode = nodes.addObject();
   groupNode.put("NAME", counterGroup.getName());
   groupNode.put("DISPLAY_NAME", counterGroup.getDisplayName());
   ArrayNode countersNode = groupNode.putArray("COUNTERS");
   for (Counter counter : counterGroup) {
    ObjectNode counterNode = countersNode.addObject();
    counterNode.put("NAME", counter.getName());
    counterNode.put("DISPLAY_NAME", counter.getDisplayName());
    counterNode.put("VALUE", counter.getValue());
   }
  }
 }
 return nodes;
}