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

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

Introduction

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

Prototype

public TextNode(String paramString) 

Source Link

Usage

From source file:com.mapr.synth.samplers.StringSampler.java

@Override
public JsonNode sample() {
    synchronized (this) {
        return new TextNode(distribution.get().sample());
    }
}

From source file:org.apache.usergrid.client.EntityTestCase.java

@Test
public void testEntityCreationSuccess() {
    String collectionName = "ect" + System.currentTimeMillis();
    String entityName = "testEntity1";

    HashMap<String, JsonNode> map = new HashMap<>();
    map.put("name", new TextNode(entityName));
    map.put("color", new TextNode("red"));
    map.put("shape", new TextNode("square"));

    UsergridEntity entity = new UsergridEntity(collectionName, null, map);
    UsergridResponse response = entity.save();
    assertNull(response.getResponseError());

    UsergridEntity eLookUp = Usergrid.GET(collectionName, entityName).first();
    assertNotNull("The returned entity is null!", eLookUp);
    assertEquals("entities has the correct type", eLookUp.getType(), collectionName);
    assertEquals("entities has the correct name", eLookUp.getName(), entityName);
    assertEquals("entities has the correct color", eLookUp.getStringProperty("color"), "red");
    assertEquals("entities has the correct shape", eLookUp.getStringProperty("shape"), "square");
}

From source file:com.mapr.synth.samplers.DateSampler.java

@Override
public JsonNode sample() {
    synchronized (this) {
        long t = (long) Math.rint(base.nextDouble());
        return new TextNode(df.format(new java.util.Date(end - t)));
    }/*from   w ww.  jav  a2s .c  o  m*/
}

From source file:com.aol.one.patch.DefaultPatcherTest.java

@Test
public void testReplaceForSuccess() throws PatchException {

    List<PatchOperation> operations = new ArrayList<>();

    TextNode strNode = new TextNode("1.1String");
    DoubleNode doubleNode = new DoubleNode(10.1d);
    LongNode longNode = new LongNode(200L);
    TextNode childStrNode = new TextNode("2.1String");
    DoubleNode childDoubleNode = new DoubleNode(102.1);

    operations.add(new ReplaceOperation("/doubleField", doubleNode));
    operations.add(new ReplaceOperation("/strField", strNode));
    operations.add(new ReplaceOperation("/longField", longNode));
    operations.add(new ReplaceOperation("/child/strField", childStrNode));
    operations.add(new ReplaceOperation("/child/doubleField", childDoubleNode));

    patcher.patch(testObject, operations);

    assertThat(testObject.getDoubleField(), is(doubleNode.asDouble()));
    assertThat(testObject.getStrField(), is(strNode.asText()));
    assertThat(testObject.getLongField(), is(longNode.longValue()));
    verify(testObject).setStrField(strNode.asText());
    verify(testObject).setDoubleField(doubleNode.doubleValue());
    // replacement of long field via setLongField
    verify(testObject).setLongField(longNode.longValue());

    // child//from www. j  a v a  2s. c  om
    assertThat(childTestObject.getDoubleField(), is(childDoubleNode.asDouble()));
    assertThat(childTestObject.getStrField(), is(childStrNode.asText()));
    verify(childTestObject).setStrField(childStrNode.textValue());
    verify(childTestObject).setDoubleField(childDoubleNode.doubleValue());
}

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";
    }// w ww.  ja va2 s .  c  o  m
    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;// w w  w . ja  v 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.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  ww  w .j  a v a  2 s . c om
}

From source file:com.mapr.synth.samplers.ArrivalSampler.java

@Override
public JsonNode sample() {
    synchronized (this) {
        TextNode r = new TextNode(df.format(new Date((long) start)));
        start += minInterval - meanInterval * Math.log(1 - base.nextDouble());
        return r;
    }// www. jav a  2  s  . com
}

From source file:com.cedarsoft.serialization.test.utils.AbstractJsonSerializerTest2.java

@Nonnull

public static String addTypeInformation(@Nonnull String type, @Nonnull Version version,
        @Nonnull byte[] xmlBytes) throws Exception {
    JsonNode tree = new ObjectMapper().readTree(new String(xmlBytes, Charsets.UTF_8));

    Map<String, JsonNode> newProps = new LinkedHashMap<String, JsonNode>();
    newProps.put("@type", new TextNode(type));
    newProps.put("@version", new TextNode(version.format()));

    Iterator<Map.Entry<String, JsonNode>> nodeIterator = tree.fields();
    while (nodeIterator.hasNext()) {
        Map.Entry<String, JsonNode> jsonNode = nodeIterator.next();
        newProps.put(jsonNode.getKey(), jsonNode.getValue());
    }/*from   www. ja  v a  2s.c o m*/

    ((ContainerNode) tree).removeAll();
    ((ObjectNode) tree).putAll(newProps);

    return tree.toString();
}

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

@Override
public void doAction(JsonNode node) throws Exception {
    if (chain == null) {
        chain = "default";
    }//from   www .ja v a 2  s .  c o  m
    ObjectMapper mapper = provider.getObjectMapper();
    if (node.has("chains")) {
        JsonNode chains = node.get("chains");
        if (chains.isArray()) {
            ArrayNode chainsArray = (ArrayNode) chains;
            int limit = chainsArray.size();
            ObjectNode selectedChain = null;
            for (int i = 0; i < limit && selectedChain == null; i++) {
                JsonNode chainNode = chainsArray.get(i);
                if (chainNode.has("name")) {
                    if (chainNode.get("name").asText().equals(chain)) {
                        selectedChain = (ObjectNode) chainNode;
                    }
                }
            }
            if (selectedChain == null) {
                selectedChain = new ObjectNode(mapper.getNodeFactory());
                selectedChain.set("name", new TextNode(chain));
                chainsArray.add(selectedChain);
            }

            if (setToReader) {
                JsonNode reader = null;
                if (selectedChain.has("reader")) {
                    reader = selectedChain.get("reader");
                } else {
                    reader = new ObjectNode(mapper.getNodeFactory());
                    selectedChain.set("reader", reader);
                }
                setIncludesOrExcludesList((ObjectNode) reader);

            }
            if (setToWriter) {
                JsonNode reader = null;
                if (selectedChain.has("writer")) {
                    reader = selectedChain.get("writer");
                } else {
                    reader = new ObjectNode(mapper.getNodeFactory());
                    selectedChain.set("writer", reader);
                }
                setIncludesOrExcludesList((ObjectNode) reader);
            }

        }
    } else {
        ObjectNode root = (ObjectNode) node;
        if (node.has("transformations")) {
            JsonNode transformations = node.get("transformations");

            root.remove("transformations");
            ObjectNode chainNode = new ObjectNode(mapper.getNodeFactory());
            chainNode.set("name", new TextNode("default"));
            chainNode.set("transformations", transformations);
            ArrayNode chains = new ArrayNode(mapper.getNodeFactory());
            chains.add(chainNode);
            if (!chain.equals("default")) {
                chainNode = new ObjectNode(mapper.getNodeFactory());
                chainNode.set("name", new TextNode(chain));
                chains.add(chainNode);
            }
            ObjectNode reader = new ObjectNode(mapper.getNodeFactory());
            setIncludesOrExcludesList(reader);

            chainNode.set("reader", reader);
            ObjectNode writer = new ObjectNode(mapper.getNodeFactory());
            setIncludesOrExcludesList(writer);
            chainNode.set("writer", writer);

            root.set("chains", chains);
        } else if (!node.has("modules")) {
            ObjectNode chainNode = new ObjectNode(mapper.getNodeFactory());
            chainNode.set("name", new TextNode("default"));
            ArrayNode chains = new ArrayNode(mapper.getNodeFactory());
            chains.add(chainNode);

            ObjectNode reader = new ObjectNode(mapper.getNodeFactory());
            setIncludesOrExcludesList(reader);

            chainNode.set("reader", reader);
            ObjectNode writer = new ObjectNode(mapper.getNodeFactory());
            setIncludesOrExcludesList(writer);
            chainNode.set("writer", writer);

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

    }
    provider.write(node);
}