Refine search
@Path("list") @GET @Produces(MediaType.APPLICATION_JSON) public String getClusterAsJson() throws Exception { InstanceConfig config = context.getExhibitor().getConfigManager().getConfig(); ObjectNode node = JsonNodeFactory.instance.objectNode(); ArrayNode serversNode = JsonNodeFactory.instance.arrayNode(); ServerList serverList = new ServerList(config.getString(StringConfigs.SERVERS_SPEC)); for ( ServerSpec spec : serverList.getSpecs() ) { serversNode.add(spec.getHostname()); } node.put("servers", serversNode); node.put("port", config.getInt(IntConfigs.CLIENT_PORT)); return JsonUtil.writeValueAsString(node); }
return nodeFactory.nullNode(); return nodeFactory.binaryNode((byte[]) ob); return nodeFactory.POJONode(ob); return nodeFactory.textNode(jp.getText()); if (nt == JsonParser.NumberType.BIG_INTEGER || ctxt.isEnabled(DeserializationConfig.Feature.USE_BIG_INTEGER_FOR_INTS)) { return nodeFactory.numberNode(jp.getBigIntegerValue()); return nodeFactory.numberNode(jp.getIntValue()); return nodeFactory.numberNode(jp.getLongValue()); if (nt == JsonParser.NumberType.BIG_DECIMAL || ctxt.isEnabled(DeserializationConfig.Feature.USE_BIG_DECIMAL_FOR_FLOATS)) { return nodeFactory.numberNode(jp.getDecimalValue()); return nodeFactory.numberNode(jp.getDoubleValue()); return nodeFactory.booleanNode(true); return nodeFactory.booleanNode(false); return nodeFactory.nullNode();
protected final ArrayNode deserializeArray(JsonParser jp, DeserializationContext ctxt, final JsonNodeFactory nodeFactory) throws IOException, JsonProcessingException { ArrayNode node = nodeFactory.arrayNode(); while (true) { switch (jp.nextToken()) { case START_OBJECT: node.add(deserializeObject(jp, ctxt, nodeFactory)); break; case START_ARRAY: node.add(deserializeArray(jp, ctxt, nodeFactory)); break; case END_ARRAY: return node; case VALUE_STRING: node.add(nodeFactory.textNode(jp.getText())); break; default: node.add(deserializeAny(jp, ctxt, nodeFactory)); break; } } }
/** * 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; }
@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); }
public String getNodeData(@QueryParam("key") String key) throws Exception ObjectNode node = JsonNodeFactory.instance.objectNode(); try node.put("bytes", bytesToString(bytes)); node.put("str", new String(bytes, "UTF-8")); } else { node.put("bytes", ""); node.put("str", "");
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);
/** {@inheritDoc} */ @Override protected JsonNode toJsonNode() { final ObjectNode root = JsonNodeFactory.instance.objectNode(); root.put(OPERATOR_NODE, mOperator.name()); final ArrayNode filters = root.arrayNode(); for (FijiRowFilter filter : mFilters) { if (filter != null) { filters.add(filter.toJson()); } } root.put(FILTERS_NODE, filters); return root; }
public String getNode(@QueryParam("key") String key) throws Exception ArrayNode children = JsonNodeFactory.instance.arrayNode(); try for ( String name : childrenNames ) ObjectNode node = children.addObject(); node.put("title", name); node.put("key", ZKPaths.makePath(key, name)); node.put("isLazy", true); node.put("expand", false); context.getExhibitor().getLog().add(ActivityLog.Type.ERROR, "getNode: " + key, e); ObjectNode node = children.addObject(); node.put("title", "* Exception *"); node.put("key", ERROR_KEY); return children.toString();
/** * Creates the class type field. * * @return the field */ private Field createClassTypeField() { List<String> classTypeSymbols = Arrays.asList(OBJECT, EVENT); Schema classTypeEnum = Schema.createEnum(CLASS_TYPE_TYPE_NAME, null, BASE_SCHEMA_FORM_NAMESPACE, classTypeSymbols); Field classTypeField = new Field(CLASS_TYPE, classTypeEnum, null, null); classTypeField.addProp(DISPLAY_NAME, "Class type"); JsonNodeFactory jsonFactory = JsonNodeFactory.instance; ArrayNode displayNamesNode = jsonFactory.arrayNode(); displayNamesNode.add(TextNode.valueOf("Object")); displayNamesNode.add(TextNode.valueOf("Event")); classTypeField.addProp(DISPLAY_NAMES, displayNamesNode); classTypeField.addProp(DISPLAY_PROMPT, "Select class type"); classTypeField.addProp(BY_DEFAULT, OBJECT); return classTypeField; }
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"); }
private void getWorkflowConfigNode(ObjectNode workflowConfigNode, ZNRecord record) { for (Map.Entry<String, String> entry : record.getSimpleFields().entrySet()) { if (!entry.getKey().equals(WorkflowConfig.WorkflowConfigProperty.Dag)) { workflowConfigNode.put(entry.getKey(), JsonNodeFactory.instance.textNode(entry.getValue())); } } }
@Override public void serialize(final Notification src, final JsonGenerator jgen, final SerializerProvider provider) throws IOException { final ObjectNode node = ThreadLocalJsonFactory.getFactory().objectNode(); node.put(SOURCE, ThreadLocalJsonFactory.getFactory().textNode(src.getSource().toString())); node.put(NOTIF_TYPE, src.getType()); node.put(SEQUENCE_NUMBER, src.getSequenceNumber()); if (timeStampAsString) node.put(TIME_STAMP, ThreadLocalJsonFactory.toValueNode(new Date(src.getTimeStamp()))); else node.put(TIME_STAMP, src.getTimeStamp()); node.put(MESSAGE, src.getMessage()); node.put(USER_DATA, ThreadLocalJsonFactory.toValueNode(src.getUserData())); node.serialize(jgen, provider); } }
@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; }
@Test public void test() throws JsonGenerationException, JsonMappingException, IOException { ObjectNode on = JsonNodeFactory.instance.objectNode(); BasicDBObject dbo = new BasicDBObject(); dbo.put("f1", null); dbo.put("f2", "f2value"); POJONode pn = JsonNodeFactory.instance.POJONode(dbo); on.put("properties", pn); ObjectMapper om = new ObjectMapper(); String value = om.writeValueAsString(on); System.out.println(value); } }
/** * Factory method that constructs and returns an empty {@link ObjectNode} * Construction is done using registered {@link JsonNodeFactory}. */ public final ObjectNode objectNode() { return _nodeFactory.objectNode(); }
public final NullNode nullNode() { return _nodeFactory.nullNode(); }
/** * Factory method that constructs and returns an empty {@link ArrayNode} * Construction is done using registered {@link JsonNodeFactory}. */ public final ArrayNode arrayNode() { return _nodeFactory.arrayNode(); }
result = pathToJson(value, valueType.getNestedValueType(), options, namespaces, repository); } else if (name.equals("STRING")) { result = factory.textNode((String)value); } else if (name.equals("LONG")) { result = factory.numberNode((Long)value); } else if (name.equals("DOUBLE")) { result = factory.numberNode((Double)value); } else if (name.equals("BOOLEAN")) { result = factory.booleanNode((Boolean)value); } else if (name.equals("INTEGER")) { result = factory.numberNode((Integer)value); } else if (name.equals("URI") || name.equals("DATETIME") || name.equals("DATE") || name.equals("LINK")) { result = factory.textNode(value.toString()); } else if (name.equals("DECIMAL")) { result = factory.numberNode((BigDecimal)value); } else if (name.equals("BLOB")) { Blob blob = (Blob)value; result = toJson((Record)value, options, namespaces, repository); } else if (name.equals("BYTEARRAY")) { result = factory.binaryNode(((ByteArray) value).getBytes()); } else { throw new RuntimeException("Unsupported value type: " + name);
public final NumericNode numberNode(short v) { return _nodeFactory.numberNode(v); } public final NumericNode numberNode(int v) { return _nodeFactory.numberNode(v); }