@Override public DataSourceImpl deepCopy() { return newInstance(model, data.deepCopy()); }
/** * Returns the details of the welcome message that was sent from the router * to the client */ public ObjectNode welcomeDetails() { return welcomeDetails.deepCopy(); }
/** * Returns a copy of the configuration. * * @return Copy of the configuration. */ public ObjectNode getConfig() { return config.deepCopy(); }
/** * Returns a copy of the configuration. * * @return Copy of the configuration. */ public ObjectNode getConfig() { return config.deepCopy(); }
/** * Returns the details of the welcome message that was sent from the router * to the client */ public ObjectNode welcomeDetails() { return welcomeDetails.deepCopy(); }
/** * Returns the details of the welcome message that was sent from the router * to the client */ public ObjectNode welcomeDetails() { return welcomeDetails.deepCopy(); }
public ObjectNode copyNode() { return jsonNode.deepCopy(); }
public static ObjectNode cloneObjectNode(ObjectNode src) { return src.deepCopy(); }
/** * Retrieve the parameter list to be modified without thread issues * * @return parameter list */ public ObjectNode getParametersSafe() { return getParameterList().deepCopy(); }
public Row build() { return new Row(_data.deepCopy()); }
public OpenApiDefinition(OpenApiDefinition copy) { root = copy.getRoot().deepCopy(); }
private void crossProduct(Queue<JsonNode> buffer, ObjectNode r, List<String> fields, Map<String, JsonNode> generators, int currentFieldIndex) { if (currentFieldIndex < fields.size()) { // get this generator JsonNode values = generators.get(fields.get(currentFieldIndex)); int n = values.size(); // and for each value it has for (int j = 0; j < n; j++) { // set that field ... r.set(fields.get(currentFieldIndex), values.get(j)); // and recurse crossProduct(buffer, r, fields, generators, currentFieldIndex + 1); } } else { // when we bottom out we add a copied record to the buffer buffer.add(r.deepCopy()); } } }
/** * Adds a new parameter to current request parameters. * <p/> * <i>Caution:</i> If you set request parameters this way, you should follow this convention * during all the building process like that: * <pre> * client.createRequest() * .method("find") * .id(43121) * .param("firstName", "Steven") * .param("lastName", "Stamkos") * .returnAs(Player.class) * .execute(); * </pre> * <p/> * <b>Calls to <i>params</i> method are not permitted after this method has been invoked</b>. * * @param name parameter name * @param value parameter value * @return new builder */ @NotNull public RequestBuilder<T> param(@NotNull String name, @NotNull Object value) { ObjectNode newObjectParams = objectParams.deepCopy(); newObjectParams.set(name, mapper.valueToTree(value)); return new RequestBuilder<T>(transport, mapper, method, id, newObjectParams, arrayParams, javaType); }
/** * Prepare query variables if not defined previously * * @param parameters Parameters * @param alias Database alias * @param page Page number * @param max Max elements per page * @return Query parameter map */ private ObjectNode forceAliasPageAndMax(ObjectNode parameters, String alias, String page, String max) { ObjectNode forcedParameters = parameters.deepCopy(); // Force alias if not null if (alias != null) { forcedParameters.set(AweConstants.COMPONENT_DATABASE, JsonNodeFactory.instance.textNode(alias)); } // Force page if not null if (page != null) { forcedParameters.set(AweConstants.COMPONENT_PAGE, JsonNodeFactory.instance.numberNode(Long.parseLong(page))); } // Force max if not null if (max != null) { forcedParameters.set(AweConstants.COMPONENT_MAX, JsonNodeFactory.instance.numberNode(Long.parseLong(max))); } return forcedParameters; }
/** * merge parent and child properties maps. * @param content ObjectNode * @param parent ObjectNode * @return merged ObjectNode */ public static ObjectNode mergeProperties(ObjectNode content, ObjectNode parent) { ObjectNode merged = parent.deepCopy(); Iterator<Map.Entry<String, JsonNode>> fields = content.fields(); for ( ; fields.hasNext(); ) { Map.Entry<String, JsonNode> field = fields.next(); String fieldId = field.getKey(); if( merged.get(fieldId) != null ) { if( merged.get(fieldId).getNodeType().equals(JsonNodeType.OBJECT)) { merged.put(fieldId, mergeProperties(field.getValue().deepCopy(), (ObjectNode)merged.get(fieldId))); } else if ( merged.get(fieldId).getNodeType().equals(JsonNodeType.ARRAY)) { merged.put(fieldId, mergeArrays(((ArrayNode)field.getValue()), ((ArrayNode)merged.get(fieldId)))); } else { merged.put(fieldId, content.get(fieldId)); } } else { merged.put(fieldId, content.get(fieldId)); } } return merged; }
@SuppressWarnings("unchecked") @Override public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { ObjectNode root = mapper.readTree(jp); ObjectNode copy = root.deepCopy(); // compare top level fields and keep only missing fields final Class<?> tClass = this.defaultDeserializer.handledType(); for (Class<?> c : TypeUtil.getAllClasses(tClass)) { Field[] fields = c.getDeclaredFields(); for (Field field : fields) { JsonProperty property = field.getAnnotation(JsonProperty.class); String key = property.value().split("((?<!\\\\))\\.")[0]; if (!key.isEmpty()) { if (copy.has(key)) { copy.remove(key); } } } } // put into additional properties root.put("additionalProperties", copy); JsonParser parser = new JsonFactory().createParser(root.toString()); parser.nextToken(); return defaultDeserializer.deserialize(parser, ctxt); }
@SuppressWarnings("unchecked") @Override public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { ObjectNode root = mapper.readTree(jp); ObjectNode copy = root.deepCopy(); // compare top level fields and keep only missing fields final Class<?> tClass = this.defaultDeserializer.handledType(); for (Class<?> c : TypeToken.of(tClass).getTypes().classes().rawTypes()) { Field[] fields = c.getDeclaredFields(); for (Field field : fields) { JsonProperty property = field.getAnnotation(JsonProperty.class); String key = property.value().split("((?<!\\\\))\\.")[0]; if (!key.isEmpty()) { if (copy.has(key)) { copy.remove(key); } } } } // put into additional properties root.put("additionalProperties", copy); JsonParser parser = new JsonFactory().createParser(root.toString()); parser.nextToken(); return defaultDeserializer.deserialize(parser, ctxt); }
@Override public void accept(LogMessage logEvent) { logger.debug("writing log message: {}", logEvent); if (neo4j != null) { String labelClause = ""; String label = logEvent.getLabel(); if (!Strings.isNullOrEmpty(label)) { checkLabel(label); labelClause = ":" + label; } JsonNode n = logEvent.getPayload(); try { if (n != null && n.isObject()) { ObjectNode props = (ObjectNode) n; props = props.deepCopy(); applyTimestamp(logEvent.getTimestamp(), props); String cypher = "create (x:EventLog" + labelClause + ") set x={props}"; neo4j.execCypher(cypher, "props", props); } } catch (RuntimeException e) { logger.warn("problem logging to EventLog: " + n, e); } } } };
private static HalResource createReport(HalPath halPath, HalResource hal, List<String> errors) { HalResource filterReport = new HalResource(hal.getLink().getHref()); filterReport.getModel().put("halPath", halPath.toString()); ArrayNode errorContainer = filterReport.getModel().putArray("errors"); for (String error : errors) { errorContainer.add(error); } filterReport.getModel().set("copy", hal.getModel().deepCopy()); return filterReport; }
@Test(dependsOnMethods = "settingAnyJsonNodeWorks") public void nodesAreUnalteredWhenSubmitted() { final ObjectNode foo = FACTORY.objectNode(); foo.put("a", "b"); final JsonNode node = foo.deepCopy(); final ProcessingMessage msg = new ProcessingMessage().put("foo", foo); foo.remove("a"); assertMessage(msg).hasField("foo", node); }