Example usage for com.fasterxml.jackson.core JsonParser readValueAsTree

List of usage examples for com.fasterxml.jackson.core JsonParser readValueAsTree

Introduction

In this page you can find the example usage for com.fasterxml.jackson.core JsonParser readValueAsTree.

Prototype

@SuppressWarnings("unchecked")
public <T extends TreeNode> T readValueAsTree() throws IOException, JsonProcessingException 

Source Link

Document

Method to deserialize JSON content into equivalent "tree model", represented by root TreeNode of resulting model.

Usage

From source file:org.opendaylight.groupbasedpolicy.jsonrpc.JsonRpcDecoder.java

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out) throws Exception {

    logger.trace("readable bytes {}, records read {}, incomplete record bytes {}", buf.readableBytes(),
            recordsRead, lastRecordBytes);

    if (lastRecordBytes == 0) {
        if (buf.readableBytes() < 4) {
            return; //wait for more data
        }/*from  w w  w .  ja  v a 2 s . c om*/

        skipSpaces(buf);

        byte[] buff = new byte[4];
        buf.getBytes(buf.readerIndex(), buff);
        ByteSourceJsonBootstrapper strapper = new ByteSourceJsonBootstrapper(jacksonIOContext, buff, 0, 4);
        JsonEncoding jsonEncoding = strapper.detectEncoding();
        if (!JsonEncoding.UTF8.equals(jsonEncoding)) {
            throw new InvalidEncodingException(jsonEncoding.getJavaName(), "currently only UTF-8 is supported");
        }
    }

    int i = lastRecordBytes + buf.readerIndex();

    for (; i < buf.writerIndex(); i++) {
        switch (buf.getByte(i)) {
        case '{':
            if (!inS)
                leftCurlies++;
            break;
        case '}':
            if (!inS)
                rightCurlies++;
            break;
        case '"': {
            if (buf.getByte(i - 1) != '\\')
                inS = !inS;
            break;
        }
        default:
            break;
        }

        if (leftCurlies != 0 && leftCurlies == rightCurlies && !inS) {
            ByteBuf slice = buf.readSlice(1 + i - buf.readerIndex());
            JsonParser jp = jacksonJsonFactory.createParser(new ByteBufInputStream(slice));
            JsonNode root = jp.readValueAsTree();
            out.add(root);
            leftCurlies = rightCurlies = lastRecordBytes = 0;
            recordsRead++;
            break;
        }

        if (i - buf.readerIndex() >= maxFrameLength) {
            fail(ctx, i - buf.readerIndex());
        }
    }

    // end of stream, save the incomplete record index to avoid reexamining the whole on next run
    if (i >= buf.writerIndex()) {
        lastRecordBytes = buf.readableBytes();
        return;
    }
}

From source file:com.github.fge.jsonpatch.mergepatch.JsonMergePatchDeserializer.java

@Override
public JsonMergePatch deserialize(final JsonParser jp, final DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    // FIXME: see comment above
    jp.setCodec(CODEC);/* ww w .  j  ava 2  s. c  om*/
    final JsonNode node = jp.readValueAsTree();

    /*
     * Not an object: the simple case
     */
    if (!node.isObject())
        return new NonObjectMergePatch(node);

    /*
     * The complicated case...
     *
     * We have to build a set of removed members, plus a map of modified
     * members.
     */

    final Set<String> removedMembers = Sets.newHashSet();
    final Map<String, JsonMergePatch> modifiedMembers = Maps.newHashMap();
    final Iterator<Map.Entry<String, JsonNode>> iterator = node.fields();

    Map.Entry<String, JsonNode> entry;

    while (iterator.hasNext()) {
        entry = iterator.next();
        if (entry.getValue().isNull())
            removedMembers.add(entry.getKey());
        else {
            final JsonMergePatch value = deserialize(entry.getValue().traverse(), ctxt);
            modifiedMembers.put(entry.getKey(), value);
        }
    }

    return new ObjectMergePatch(removedMembers, modifiedMembers);
}

From source file:org.opendaylight.ovsdb.lib.jsonrpc.JsonRpcDecoder.java

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out) throws Exception {

    logger.trace("readable bytes {}, records read {}, incomplete record bytes {}", buf.readableBytes(),
            recordsRead, lastRecordBytes);

    if (lastRecordBytes == 0) {
        if (buf.readableBytes() < 4) {
            return; //wait for more data
        }/*from w  ww. ja v a 2s.c  om*/

        skipSpaces(buf);

        byte[] buff = new byte[4];
        buf.getBytes(buf.readerIndex(), buff);
        ByteSourceJsonBootstrapper strapper = new ByteSourceJsonBootstrapper(jacksonIOContext, buff, 0, 4);
        JsonEncoding jsonEncoding = strapper.detectEncoding();
        if (!JsonEncoding.UTF8.equals(jsonEncoding)) {
            throw new InvalidEncodingException(jsonEncoding.getJavaName(), "currently only UTF-8 is supported");
        }
    }

    int index = lastRecordBytes + buf.readerIndex();

    for (; index < buf.writerIndex(); index++) {
        switch (buf.getByte(index)) {
        case '{':
            if (!inS) {
                leftCurlies++;
            }
            break;
        case '}':
            if (!inS) {
                rightCurlies++;
            }
            break;
        case '"':
            if (buf.getByte(index - 1) != '\\') {
                inS = !inS;
            }
            break;
        default:
            break;
        }

        if (leftCurlies != 0 && leftCurlies == rightCurlies && !inS) {
            ByteBuf slice = buf.readSlice(1 + index - buf.readerIndex());
            JsonParser jp = jacksonJsonFactory.createParser(new ByteBufInputStream(slice));
            JsonNode root = jp.readValueAsTree();
            out.add(root);
            leftCurlies = rightCurlies = lastRecordBytes = 0;
            recordsRead++;
            break;
        }

        if (index - buf.readerIndex() >= maxFrameLength) {
            fail(ctx, index - buf.readerIndex());
        }
    }

    // end of stream, save the incomplete record index to avoid reexamining the whole on next run
    if (index >= buf.writerIndex()) {
        lastRecordBytes = buf.readableBytes();
        return;
    }
}

From source file:com.unboundid.scim2.common.utils.Parser.java

/**
 * Read a filter from the reader./*from  w  w w .j  a  v  a2s . com*/
 *
 * @param reader The reader to read the filter from.
 * @param isValueFilter Whether to read the filter as a value filter.
 * @return The parsed filter.
 * @throws BadRequestException If the filter string could not be parsed.
 */
private static Filter readFilter(final StringReader reader, final boolean isValueFilter)
        throws BadRequestException {
    final Stack<Filter> outputStack = new Stack<Filter>();
    final Stack<String> precedenceStack = new Stack<String>();

    String token;
    String previousToken = null;

    while ((token = readFilterToken(reader, isValueFilter)) != null) {
        if (token.equals("(") && expectsNewFilter(previousToken)) {
            precedenceStack.push(token);
        } else if (token.equalsIgnoreCase(FilterType.NOT.getStringValue()) && expectsNewFilter(previousToken)) {
            // "not" should be followed by an (
            String nextToken = readFilterToken(reader, isValueFilter);
            if (nextToken == null) {
                throw BadRequestException.invalidFilter("Unexpected end of filter string");
            }
            if (!nextToken.equals("(")) {
                final String msg = String.format("Expected '(' at position %d", reader.mark);
                throw BadRequestException.invalidFilter(msg);
            }
            precedenceStack.push(token);
        } else if (token.equals(")") && !expectsNewFilter(previousToken)) {
            String operator = closeGrouping(precedenceStack, outputStack, false);
            if (operator == null) {
                final String msg = String.format(
                        "No opening parenthesis matching closing " + "parenthesis at position %d", reader.mark);
                throw BadRequestException.invalidFilter(msg);
            }
            if (operator.equalsIgnoreCase(FilterType.NOT.getStringValue())) {
                // Treat "not" the same as "(" except wrap everything in a not filter.
                outputStack.push(Filter.not(outputStack.pop()));
            }
        } else if (token.equalsIgnoreCase(FilterType.AND.getStringValue())
                && !expectsNewFilter(previousToken)) {
            // and has higher precedence than or.
            precedenceStack.push(token);
        } else if (token.equalsIgnoreCase(FilterType.OR.getStringValue()) && !expectsNewFilter(previousToken)) {
            // pop all the pending ands first before pushing or.
            LinkedList<Filter> andComponents = new LinkedList<Filter>();
            while (!precedenceStack.isEmpty()) {
                if (precedenceStack.peek().equalsIgnoreCase(FilterType.AND.getStringValue())) {
                    precedenceStack.pop();
                    andComponents.addFirst(outputStack.pop());
                } else {
                    break;
                }
                if (!andComponents.isEmpty()) {
                    andComponents.addFirst(outputStack.pop());
                    outputStack.push(Filter.and(andComponents));
                }
            }

            precedenceStack.push(token);
        } else if (token.endsWith("[") && expectsNewFilter(previousToken)) {
            // This is a complex value filter.
            final Path filterAttribute;
            try {
                filterAttribute = parsePath(token.substring(0, token.length() - 1));
            } catch (final BadRequestException e) {
                Debug.debugException(e);
                final String msg = String.format("Invalid attribute path at position %d: %s", reader.mark,
                        e.getMessage());
                throw BadRequestException.invalidFilter(msg);
            }

            if (filterAttribute.isRoot()) {
                final String msg = String.format("Attribute path expected at position %d", reader.mark);
                throw BadRequestException.invalidFilter(msg);
            }

            outputStack.push(Filter.hasComplexValue(filterAttribute, readFilter(reader, true)));
        } else if (isValueFilter && token.equals("]") && !expectsNewFilter(previousToken)) {
            break;
        } else if (expectsNewFilter(previousToken)) {
            // This must be an attribute path followed by operator and maybe value.
            final Path filterAttribute;
            try {
                filterAttribute = parsePath(token);
            } catch (final BadRequestException e) {
                Debug.debugException(e);
                final String msg = String.format("Invalid attribute path at position %d: %s", reader.mark,
                        e.getMessage());
                throw BadRequestException.invalidFilter(msg);
            }

            if (filterAttribute.isRoot()) {
                final String msg = String.format("Attribute path expected at position %d", reader.mark);
                throw BadRequestException.invalidFilter(msg);
            }

            String op = readFilterToken(reader, isValueFilter);

            if (op == null) {
                throw BadRequestException.invalidFilter("Unexpected end of filter string");
            }

            if (op.equalsIgnoreCase(FilterType.PRESENT.getStringValue())) {
                outputStack.push(Filter.pr(filterAttribute));
            } else {
                ValueNode valueNode;
                try {
                    // Mark the beginning of the JSON value so we can later reset back
                    // to this position and skip the actual chars that were consumed
                    // by Jackson. The Jackson parser is buffered and reads everything
                    // until the end of string.
                    reader.mark(0);
                    ScimJsonFactory scimJsonFactory = (ScimJsonFactory) JsonUtils.getObjectReader()
                            .getFactory();
                    JsonParser parser = scimJsonFactory.createScimFilterParser(reader);
                    // The object mapper will return a Java null for JSON null.
                    // Have to distinguish between reading a JSON null and encountering
                    // the end of string.
                    if (parser.getCurrentToken() == null && parser.nextToken() == null) {
                        // End of string.
                        valueNode = null;
                    } else {
                        valueNode = parser.readValueAsTree();

                        // This is actually a JSON null. Use NullNode.
                        if (valueNode == null) {
                            valueNode = JsonUtils.getJsonNodeFactory().nullNode();
                        }
                    }
                    // Reset back to the beginning of the JSON value.
                    reader.reset();
                    // Skip the number of chars consumed by JSON parser.
                    reader.skip(parser.getCurrentLocation().getCharOffset());
                } catch (IOException e) {
                    final String msg = String.format("Invalid comparison value at position %d: %s", reader.mark,
                            e.getMessage());
                    throw BadRequestException.invalidFilter(msg);
                }

                if (valueNode == null) {
                    throw BadRequestException.invalidFilter("Unexpected end of filter string");
                }

                if (op.equalsIgnoreCase(FilterType.EQUAL.getStringValue())) {
                    outputStack.push(Filter.eq(filterAttribute, valueNode));
                } else if (op.equalsIgnoreCase(FilterType.NOT_EQUAL.getStringValue())) {
                    outputStack.push(Filter.ne(filterAttribute, valueNode));
                } else if (op.equalsIgnoreCase(FilterType.CONTAINS.getStringValue())) {
                    outputStack.push(Filter.co(filterAttribute, valueNode));
                } else if (op.equalsIgnoreCase(FilterType.STARTS_WITH.getStringValue())) {
                    outputStack.push(Filter.sw(filterAttribute, valueNode));
                } else if (op.equalsIgnoreCase(FilterType.ENDS_WITH.getStringValue())) {
                    outputStack.push(Filter.ew(filterAttribute, valueNode));
                } else if (op.equalsIgnoreCase(FilterType.GREATER_THAN.getStringValue())) {
                    outputStack.push(Filter.gt(filterAttribute, valueNode));
                } else if (op.equalsIgnoreCase(FilterType.GREATER_OR_EQUAL.getStringValue())) {
                    outputStack.push(Filter.ge(filterAttribute, valueNode));
                } else if (op.equalsIgnoreCase(FilterType.LESS_THAN.getStringValue())) {
                    outputStack.push(Filter.lt(filterAttribute, valueNode));
                } else if (op.equalsIgnoreCase(FilterType.LESS_OR_EQUAL.getStringValue())) {
                    outputStack.push(Filter.le(filterAttribute, valueNode));
                } else {
                    final String msg = String.format("Unrecognized attribute operator '%s' at position %d. "
                            + "Expected: eq,ne,co,sw,ew,pr,gt,ge,lt,le", op, reader.mark);
                    throw BadRequestException.invalidFilter(msg);
                }
            }
        } else {
            final String msg = String.format("Unexpected character '%s' at position %d", token, reader.mark);
            throw BadRequestException.invalidFilter(msg);
        }
        previousToken = token;
    }

    closeGrouping(precedenceStack, outputStack, true);

    if (outputStack.isEmpty()) {
        throw BadRequestException.invalidFilter("Unexpected end of filter string");
    }
    return outputStack.pop();
}

From source file:com.proofpoint.event.collector.S3Uploader.java

private void verifyFile(File file) throws IOException {
    SnappyInputStream input = new SnappyInputStream(new FileInputStream(file));
    JsonParser parser = new ObjectMapper().getFactory().createParser(input);
    try {/*w ww  .j a v a  2 s  .co  m*/
        while (parser.readValueAsTree() != null) {
            // ignore contents
        }
    } finally {
        parser.close();
    }
}

From source file:com.strategicgains.hyperexpress.serialization.siren.jackson.SirenResourceDeserializer.java

@Override
public SirenResource deserialize(JsonParser jp, DeserializationContext context)
        throws IOException, JsonProcessingException {
    ObjectCodec oc = jp.getCodec();//from   ww  w  . j  a v  a 2 s . c  om
    return deserializeResource((JsonNode) jp.readValueAsTree(), oc);
}

From source file:com.strategicgains.hyperexpress.serialization.jackson.HalResourceDeserializer.java

@Override
public HalResource deserialize(JsonParser jp, DeserializationContext context)
        throws IOException, JsonProcessingException {
    ObjectCodec oc = jp.getCodec();// w  w w. j  a va2 s.  c o m
    return deserializeResource((JsonNode) jp.readValueAsTree(), oc);
}

From source file:com.brainlounge.zooterrain.netty.WebSocketServerInboundHandler.java

private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {

    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain());
        return;//from   ww  w. j  av  a  2s . c  om
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(
                String.format("%s frame types not supported", frame.getClass().getName()));
    }

    String request = ((TextWebSocketFrame) frame).text();
    if (logger.isLoggable(Level.FINE)) {
        logger.fine(String.format("%s received %s", ctx.channel(), request));
    }

    // expecting JSON, parse now
    TreeNode jsonRequest;
    ClientRequest.Type requestType;
    try {
        final JsonParser parser = jsonMapper.getFactory().createParser(request);
        jsonRequest = parser.readValueAsTree();
        TextNode type = (TextNode) jsonRequest.get("r");
        requestType = ClientRequest.Type.valueOf(type.textValue());
    } catch (Exception e) {
        logger.info("parsing JSON failed for '" + request + "'");
        // TODO return error to client
        return;
    }

    if (requestType == ClientRequest.Type.i) {
        // client requested initial data

        // sending connection string info
        final ControlMessage handshakeInfo = new ControlMessage(zkStateObserver.getZkConnection(),
                ControlMessage.Type.H);
        writeClientMessage(ctx, handshakeInfo);

        // sending initial znodes
        try {
            zkStateObserver.initialTree("/", 6, Sets.<ZkStateListener>newHashSet(new OutboundConnector(ctx)));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } else if (requestType == ClientRequest.Type.b) {
        final String znode;
        try {
            znode = ((TextNode) jsonRequest.get("z")).textValue();
        } catch (Exception e) {
            return; // TODO return error
        }
        final DataMessage dataMessage = zkStateObserver.retrieveNodeData(znode);
        if (dataMessage != null) {
            writeClientMessage(ctx, dataMessage);
        }
    } else {
        System.out.println("unknown, unhandled client request = " + request);
    }
}

From source file:com.anrisoftware.simplerest.oanda.rest.AbstractInstrumentHistory.java

private Collection<T> parseResponseList0(ObjectMapper mapper, JsonParser parser)
        throws IOException, JsonParseException, JsonMappingException {
    TreeNode tree = parser.readValueAsTree();
    TreeNode candlesNode = tree.get(CANDLES_NAME);
    int size = candlesNode.size();
    TreeNode node;/*  ww  w.j  a v a  2  s .  co  m*/
    for (int i = 0; i < size; i++) {
        node = candlesNode.get(i);
        T obj = mapper.readValue(node.traverse(), candleType);
        log.parsedInstrumentHistory(obj);
        container.add(obj);
    }
    return container;
}

From source file:com.trenurbanoapp.webapi.WebApiRestClient.java

public AssetsResponse assets() {
    HttpClient httpClient = getHttpClient();
    HttpGet httpGet = new HttpGet(urlbase + "/asset");
    getRequestCallback().doWithRequest(httpGet);
    try {/*from   w  w w  .  j av  a 2 s  .co m*/
        return httpClient.execute(httpGet, response -> {
            int status = response.getStatusLine().getStatusCode();
            if (!(status >= 200 && status < 300)) {
                return new AssetsResponse(status, response.getStatusLine().getReasonPhrase());
            }

            List<Asset> assets = new ArrayList<>();
            final JsonFactory jsonFactory = getObjectMapper().getFactory();
            final JsonParser parser = jsonFactory.createParser(response.getEntity().getContent());
            JsonToken token;
            while ((token = parser.nextToken()) != null) {
                switch (token) {
                case START_OBJECT:
                    JsonNode node = parser.readValueAsTree();
                    Asset asset = createAsset(node);
                    assets.add(asset);
                    break;
                }
            }
            return new AssetsResponse(assets);
        });
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}