Example usage for com.fasterxml.jackson.databind.node ObjectNode ObjectNode

List of usage examples for com.fasterxml.jackson.databind.node ObjectNode ObjectNode

Introduction

In this page you can find the example usage for com.fasterxml.jackson.databind.node ObjectNode ObjectNode.

Prototype

public ObjectNode(JsonNodeFactory paramJsonNodeFactory) 

Source Link

Usage

From source file:pl.edu.pwr.iiar.zak.thermalKit.deserializers.HeaterUnitDeserializerTest.java

@Test
public void testDeserializeThermalInstances() throws Exception {
    Method method = HeaterUnitDeserializer.class.getDeclaredMethod("deserializeThermalInstances",
            ArrayNode.class);
    method.setAccessible(true);//from   w  w w  . ja  v  a 2  s.c  o m

    JsonNodeFactory factory = JsonNodeFactory.instance;
    ArrayNode instanceArrayNode = new ArrayNode(factory);
    ObjectNode instanceNode = new ObjectNode(factory);
    instanceArrayNode.add(instanceNode);

    instanceNode.put("name", "upper");
    instanceNode.put("primitiveType", "SLICEL");

    ArrayNode attributeArrayNode = new ArrayNode(factory);
    instanceNode.put("attributes", attributeArrayNode);
    ObjectNode attributeNode = new ObjectNode(factory);
    attributeArrayNode.add(attributeNode);
    attributeNode.put("physicalName", "phyName1");
    attributeNode.put("logicalName", "logName1");
    attributeNode.put("value", "value1");

    ArrayNode enablePinsNode = new ArrayNode(factory);
    instanceNode.put("enablePins", enablePinsNode);
    ObjectNode enablePinNode = new ObjectNode(factory);
    enablePinsNode.add(enablePinNode);
    enablePinNode.put("isOutputPin", false);
    enablePinNode.put("name", "D3");

    System.out.print(instanceArrayNode.toString());

    ArrayList<ThermalInstance> heaterInstances = (ArrayList<ThermalInstance>) method
            .invoke(new HeaterUnitDeserializer(), instanceArrayNode);

    ThermalInstance heaterInstance = heaterInstances.get(0);
    Assert.assertEquals(heaterInstance.getName(), "upper");
    Assert.assertEquals(heaterInstance.getType().toString(), "SLICEL");
}

From source file:com.digitalpebble.storm.crawler.filtering.BasicURLNormalizerTest.java

private URLFilter createFilter(boolean removeAnchor, boolean unmangleQueryString,
        List<String> queryElementsToRemove) {
    ObjectNode filterParams = new ObjectNode(JsonNodeFactory.instance);
    filterParams.set("queryElementsToRemove", getArrayNode(queryElementsToRemove));
    filterParams.put("removeAnchorPart", Boolean.valueOf(removeAnchor));
    filterParams.put("unmangleQueryString", Boolean.valueOf(unmangleQueryString));
    return createFilter(filterParams);
}

From source file:net.pterodactylus.sone.web.ajax.GetLikesAjaxPage.java

/**
 * Creates a JSON array (containing the IDs and the nice names) from the
 * given Sones, after sorting them by name.
 *
 * @param sones//from   w w w  .j  ava2s .c  o m
 *            The Sones to convert to an array
 * @return The Sones, sorted by name
 */
private static JsonNode getSones(Set<Sone> sones) {
    ArrayNode soneArray = new ArrayNode(instance);
    for (Sone sone : FluentIterable.from(sones).toSortedList(NICE_NAME_COMPARATOR)) {
        soneArray.add(
                new ObjectNode(instance).put("id", sone.getId()).put("name", SoneAccessor.getNiceName(sone)));
    }
    return soneArray;
}

From source file:org.walkmod.conf.providers.yml.SetReaderYMLAction.java

@Override
public void doAction(JsonNode node) throws Exception {
    if (node.has("chains") && (chain == null || "".equals(chain.trim()))) {
        chain = "default";
    }/*ww  w.ja  v a2s  .c  om*/
    ObjectNode reader = null;
    ObjectMapper mapper = provider.getObjectMapper();
    if (chain != null && !"".equals(chain.trim())) {

        if (node.has("chains")) {
            JsonNode chainsListNode = node.get("chains");
            if (chainsListNode.isArray()) {
                Iterator<JsonNode> it = chainsListNode.iterator();
                boolean found = false;
                while (it.hasNext() && !found) {
                    JsonNode current = it.next();
                    if (current.has("name")) {
                        String name = current.get("name").asText();
                        found = name.equals(chain);
                        if (found) {
                            if (current.has("reader")) {
                                reader = (ObjectNode) current.get("reader");
                            } else {
                                reader = new ObjectNode(mapper.getNodeFactory());
                            }
                            if (type != null && !"".equals(type.trim())) {
                                reader.set("type", new TextNode(type));
                            }
                            if (path != null && !"".equals(path.trim())) {
                                reader.set("path", new TextNode(path));
                            }
                            if (params != null && !params.isEmpty()) {
                                ObjectNode paramsObject = null;
                                if (reader.has("params")) {
                                    paramsObject = (ObjectNode) reader.get("params");
                                } else {
                                    paramsObject = new ObjectNode(mapper.getNodeFactory());
                                    reader.set("params", paramsObject);
                                }

                                Set<String> keys = params.keySet();
                                for (String key : keys) {
                                    paramsObject.put(key, params.get(key).toString());
                                }

                            }
                        }
                    }
                }
            }
        }
        if (reader != null) {
            provider.write(node);
        }
    } else {
        if (!node.has("chains")) {
            ArrayNode chains = new ArrayNode(mapper.getNodeFactory());
            ObjectNode defaultChain = new ObjectNode(mapper.getNodeFactory());
            defaultChain.set("name", new TextNode("default"));
            ObjectNode readerNode = new ObjectNode(mapper.getNodeFactory());

            if (type != null && !"".equals(type.trim())) {
                readerNode.set("type", new TextNode(type));
            }
            if (path != null && !"".equals(path.trim())) {
                readerNode.set("path", new TextNode(path));
            }
            if (params != null && !params.isEmpty()) {
                ObjectNode paramsObject = new ObjectNode(mapper.getNodeFactory());
                Set<String> keys = params.keySet();
                for (String key : keys) {
                    paramsObject.put(key, params.get(key).toString());
                }
                readerNode.set("params", paramsObject);
            }
            defaultChain.set("reader", readerNode);
            if (node.has("transformations")) {
                defaultChain.set("transformations", node.get("transformations"));
            }
            chains.add(defaultChain);
            provider.write(chains);
        }

    }

}

From source file:org.walkmod.conf.providers.yml.SetWriterYMLAction.java

@Override
public void doAction(JsonNode node) throws Exception {

    ObjectNode writer = null;/*from  ww w . j av  a  2 s. c o m*/

    ObjectMapper mapper = provider.getObjectMapper();

    if (node.has("chains") && (chain == null || "".equals(chain.trim()))) {
        chain = "default";
    }

    if (chain != null && !"".equals(chain.trim())) {

        if (node.has("chains")) {
            JsonNode chainsListNode = node.get("chains");
            if (chainsListNode.isArray()) {
                Iterator<JsonNode> it = chainsListNode.iterator();
                boolean found = false;
                while (it.hasNext() && !found) {
                    JsonNode current = it.next();
                    if (current.has("name")) {
                        String name = current.get("name").asText();
                        found = name.equals(chain);
                        if (found) {
                            if (current.has("writer")) {
                                writer = (ObjectNode) current.get("writer");
                            } else {
                                writer = new ObjectNode(mapper.getNodeFactory());
                            }

                            if (type != null && !"".equals(type.trim())) {
                                writer.set("type", new TextNode(type));
                            }
                            if (path != null && !"".equals(path.trim())) {
                                writer.set("path", new TextNode(path));
                            }
                            if (params != null && !params.isEmpty()) {
                                ObjectNode paramsObject = null;
                                if (writer.has("params")) {
                                    paramsObject = (ObjectNode) writer.get("params");
                                } else {
                                    paramsObject = new ObjectNode(mapper.getNodeFactory());
                                    writer.set("params", paramsObject);
                                }

                                Set<String> keys = params.keySet();
                                for (String key : keys) {
                                    paramsObject.put(key, params.get(key).toString());
                                }

                            }
                        }
                    }
                }
            }
        }
        if (writer != null) {
            provider.write(node);
        }
    } else {
        if (!node.has("chains")) {
            ArrayNode chains = new ArrayNode(mapper.getNodeFactory());
            ObjectNode defaultChain = new ObjectNode(mapper.getNodeFactory());
            defaultChain.set("name", new TextNode("default"));
            ObjectNode writerNode = new ObjectNode(mapper.getNodeFactory());

            if (type != null && !"".equals(type.trim())) {
                writerNode.set("type", new TextNode(type));
            }
            if (path != null && !"".equals(path.trim())) {
                writerNode.set("path", new TextNode(path));
            }
            if (params != null && !params.isEmpty()) {
                ObjectNode paramsObject = new ObjectNode(mapper.getNodeFactory());
                Set<String> keys = params.keySet();
                for (String key : keys) {
                    paramsObject.put(key, params.get(key).toString());
                }
                writerNode.set("params", paramsObject);
            }

            if (node.has("transformations")) {
                defaultChain.set("transformations", node.get("transformations"));
            }
            defaultChain.set("writer", writerNode);
            chains.add(defaultChain);
            ObjectNode root = new ObjectNode(mapper.getNodeFactory());

            root.set("chains", chains);
            provider.write(root);
        }
    }

}

From source file:org.walkmod.conf.providers.yml.AddChainYMLAction.java

@Override
public void doAction(JsonNode chainsNode) throws Exception {
    ArrayNode chainsList = null;/*w ww. java2s  .c  o m*/
    ObjectMapper mapper = provider.getObjectMapper();

    if (chainsNode != null) {
        if (!chainsNode.has("chains")) {
            chainsList = new ArrayNode(mapper.getNodeFactory());
            if (chainsNode.isObject()) {
                ObjectNode aux = (ObjectNode) chainsNode;
                aux.set("chains", chainsList);
            } else {
                throw new TransformerException("The root element is not a JSON node");
            }
        } else {
            JsonNode aux = chainsNode.get("chains");
            if (aux.isArray()) {
                chainsList = (ArrayNode) chainsNode.get("chains");
            } else {
                throw new TransformerException("The plugins element is not a valid array");
            }
        }
    }
    ObjectNode chainNode = new ObjectNode(mapper.getNodeFactory());
    ReaderConfig readerCfg = chainCfg.getReaderConfig();
    if (readerCfg != null) {
        if (chainsNode == null) {
            chainsNode = new ObjectNode(mapper.getNodeFactory());
            ObjectNode aux = (ObjectNode) chainsNode;
            chainsList = new ArrayNode(mapper.getNodeFactory());
            aux.set("chains", chainsList);
        }
        ObjectNode readerNode = new ObjectNode(mapper.getNodeFactory());
        chainNode.set("reader", readerNode);
        populateWriterReader(readerNode, readerCfg.getPath(), readerCfg.getType(), readerCfg.getIncludes(),
                readerCfg.getExcludes(), readerCfg.getParameters());

    } else {
        provider.addDefaultReaderConfig(chainCfg);
    }

    WalkerConfig walkerCfg = chainCfg.getWalkerConfig();
    if (walkerCfg != null) {

        ObjectNode walkerNode = null;

        String type = walkerCfg.getType();
        if (type != null) {
            if (chainsNode == null) {
                chainsNode = new ObjectNode(mapper.getNodeFactory());
                ObjectNode aux = (ObjectNode) chainsNode;
                chainsList = new ArrayNode(mapper.getNodeFactory());
                aux.set("chains", chainsList);
            }
            walkerNode = new ObjectNode(mapper.getNodeFactory());
            chainNode.set("walker", walkerNode);
            walkerNode.set("type", new TextNode(type));
        }

        Map<String, Object> wparams = walkerCfg.getParams();
        if (wparams != null && !wparams.isEmpty()) {
            if (walkerNode == null) {
                if (chainsNode == null) {
                    chainsNode = new ObjectNode(mapper.getNodeFactory());
                    ObjectNode aux = (ObjectNode) chainsNode;
                    chainsList = new ArrayNode(mapper.getNodeFactory());
                    aux.set("chains", chainsList);
                }
                walkerNode = new ObjectNode(mapper.getNodeFactory());
                chainNode.set("walker", walkerNode);
            }
            populateParams(walkerNode, wparams);
        }

        String rootNamespace = walkerCfg.getRootNamespace();
        if (rootNamespace != null) {
            if (walkerNode == null) {
                if (chainsNode == null) {
                    chainsNode = new ObjectNode(mapper.getNodeFactory());
                    ObjectNode aux = (ObjectNode) chainsNode;
                    chainsList = new ArrayNode(mapper.getNodeFactory());
                    aux.set("chains", chainsList);
                }
                walkerNode = new ObjectNode(mapper.getNodeFactory());
                chainNode.set("walker", walkerNode);
            }
            walkerNode.set("root-namespace", new TextNode(rootNamespace));
        }

        List<TransformationConfig> transformationList = walkerCfg.getTransformations();
        if (transformationList != null && !transformationList.isEmpty()) {
            ArrayNode transformationListNode = new ArrayNode(mapper.getNodeFactory());
            if (walkerNode == null) {
                if (chainsNode == null) {
                    ObjectNode aux = new ObjectNode(mapper.getNodeFactory());
                    aux.set("transformations", transformationListNode);
                    chainsNode = aux;
                } else {
                    chainNode.set("transformations", transformationListNode);
                }
            } else {
                walkerNode.set("transformations", transformationListNode);
            }
            for (TransformationConfig transCfg : transformationList) {
                ObjectNode transformationNode = new ObjectNode(mapper.getNodeFactory());
                transformationListNode.add(transformationNode);
                createTransformation(transformationNode, transCfg);
            }

        }

    }

    WriterConfig writerCfg = chainCfg.getWriterConfig();
    if (writerCfg != null) {
        if (chainsNode == null) {
            chainsNode = new ObjectNode(mapper.getNodeFactory());
            ObjectNode aux = (ObjectNode) chainsNode;
            chainsList = new ArrayNode(mapper.getNodeFactory());
            aux.set("chains", chainsList);
        }
        ObjectNode writerNode = new ObjectNode(mapper.getNodeFactory());
        chainNode.set("writer", writerNode);
        populateWriterReader(writerNode, writerCfg.getPath(), writerCfg.getType(), writerCfg.getIncludes(),
                writerCfg.getExcludes(), writerCfg.getParams());

    } else {
        provider.addDefaultWriterConfig(chainCfg);
    }
    if (chainsList != null) {
        int beforePos = -1;
        if (before != null) {
            Iterator<JsonNode> it = chainsList.iterator();
            int i = 0;
            while (it.hasNext() && beforePos == -1) {
                JsonNode next = it.next();
                if (next.get("name").equals(before)) {
                    beforePos = i;
                }
                i++;
            }
        }
        if (beforePos == -1) {
            chainsList.add(chainNode);
        } else {
            chainsList.insert(beforePos, chainNode);
        }
    }
    if (readerCfg != null || walkerCfg != null || writerCfg != null) {
        provider.write(chainsNode);
    }

}

From source file:automenta.knowtention.Core.java

/** adapter for JSONPatch+ */
static JsonPatch getPatch(ArrayNode patch) throws IOException {

    //System.out.println("min: " + patch.toString());

    /*//from  w  w  w.  j  av  a2s . c o  m
            
    JSONPatch+
            
    [ [ <op>, <param1>[, <param2> ], .... ]
            
    + add
    - remove
    * copy
    / move
    = replace
    ? test
            
    [
      { "op": "test", "path": "/a/b/c", "value": "foo" },
      { "op": "remove", "path": "/a/b/c" },
      { "op": "add", "path": "/a/b/c", "value": [ "foo", "bar" ] },
      { "op": "replace", "path": "/a/b/c", "value": 42 },
      { "op": "move", "from": "/a/b/c", "path": "/a/b/d" },
      { "op": "copy", "from": "/a/b/d", "path": "/a/b/e" }
    ]
    */

    int i = 0;
    for (JsonNode k : patch) {
        JsonNode nextOp = k;
        ObjectNode m = null;
        if (k.isArray()) {
            String op = k.get(0).textValue();
            switch (op.charAt(0)) {
            case '+':
                m = new ObjectNode(newJson);
                m.put("op", "add");
                m.put("path", k.get(1));
                m.put("value", k.get(2));
                break;
            case '-':
                m = new ObjectNode(newJson);
                m.put("op", "remove");
                m.put("path", k.get(1));
                break;
            case '*':
                m = new ObjectNode(newJson);
                m.put("op", "copy");
                m.put("from", k.get(1));
                m.put("path", k.get(2));
                break;
            case '/':
                m = new ObjectNode(newJson);
                m.put("op", "move");
                m.put("from", k.get(1));
                m.put("path", k.get(2));
                break;
            case '?':
                m = new ObjectNode(newJson);
                m.put("op", "test");
                m.put("path", k.get(1));
                m.put("value", k.get(2));
                break;
            case '=':
                m = new ObjectNode(newJson);
                m.put("op", "replace");
                m.put("path", k.get(1));
                m.put("value", k.get(2));
                break;
            }
        }
        if (m != null)
            patch.set(i++, m);
    }

    //System.out.println("standard: " + patch.toString());

    return JsonPatch.fromJson(patch);
}

From source file:net.pterodactylus.sone.web.ajax.GetReplyAjaxPage.java

/**
 * Creates a JSON representation of the given reply.
 *
 * @param request//from www .j  a  v  a  2  s . c o m
 *            The request being processed
 * @param reply
 *            The reply to convert
 * @param currentSone
 *            The currently logged in Sone (to store in the template)
 * @return The JSON representation of the reply
 */
private JsonNode createJsonReply(FreenetRequest request, PostReply reply, Sone currentSone) {
    ObjectNode jsonReply = new ObjectNode(instance);
    jsonReply.put("id", reply.getId());
    jsonReply.put("postId", reply.getPostId());
    jsonReply.put("soneId", reply.getSone().getId());
    jsonReply.put("time", reply.getTime());
    StringWriter stringWriter = new StringWriter();
    TemplateContext templateContext = webInterface.getTemplateContextFactory().createTemplateContext();
    templateContext.set("core", webInterface.getCore());
    templateContext.set("request", request);
    templateContext.set("reply", reply);
    templateContext.set("currentSone", currentSone);
    try {
        replyTemplate.render(templateContext, stringWriter);
    } catch (TemplateException te1) {
        /* TODO - shouldnt happen. */
    } finally {
        Closer.close(stringWriter);
    }
    return jsonReply.put("html", stringWriter.toString());
}

From source file:org.walkmod.conf.providers.yml.AbstractYMLConfigurationAction.java

public void populateParams(ObjectNode root, Map<String, Object> params) {
    ObjectNode paramsNode = new ObjectNode(provider.getObjectMapper().getNodeFactory());
    root.set("params", paramsNode);

    Set<String> keys = params.keySet();
    for (String key : keys) {
        paramsNode.set(key, new TextNode(params.get(key).toString()));
    }/*from   www . j  a  v  a2  s.c om*/
}

From source file:net.pterodactylus.sone.web.ajax.GetPostAjaxPage.java

/**
 * Creates a JSON object from the given post. The JSON object will only
 * contain the ID of the post, its time, and its rendered HTML code.
 *
 * @param request/*w ww  .  j  a  v  a2s . c  o m*/
 *            The request being processed
 * @param post
 *            The post to create a JSON object from
 * @param currentSone
 *            The currently logged in Sone (to store in the template)
 * @return The JSON representation of the post
 */
private JsonNode createJsonPost(FreenetRequest request, Post post, Sone currentSone) {
    ObjectNode jsonPost = new ObjectNode(instance);
    jsonPost.put("id", post.getId());
    jsonPost.put("sone", post.getSone().getId());
    jsonPost.put("recipient", post.getRecipientId().orNull());
    jsonPost.put("time", post.getTime());
    StringWriter stringWriter = new StringWriter();
    TemplateContext templateContext = webInterface.getTemplateContextFactory().createTemplateContext();
    templateContext.set("core", webInterface.getCore());
    templateContext.set("request", request);
    templateContext.set("post", post);
    templateContext.set("currentSone", currentSone);
    templateContext.set("localSones", webInterface.getCore().getLocalSones());
    try {
        postTemplate.render(templateContext, stringWriter);
    } catch (TemplateException te1) {
        /* TODO - shouldnt happen. */
    } finally {
        Closer.close(stringWriter);
    }
    jsonPost.put("html", stringWriter.toString());
    return jsonPost;
}