Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind.node;
  
  
 
Facade over com.fasterxml.jackson.databind.JsonNode that implements com.fasterxml.jackson.core.JsonParser to allow accessing contents of JSON tree in alternate form (stream of tokens). Useful when a streaming source is expected by code, such as data binding functionality.
 
 public class TreeTraversingParser extends ParserMinimalBase
 {
     /*
     /**********************************************************
     /* Configuration
     /**********************************************************
      */
 
     protected ObjectCodec _objectCodec;

    
Traversal context within tree
 
     protected NodeCursor _nodeCursor;
 
     /*
     /**********************************************************
     /* State
     /**********************************************************
      */

    
Sometimes parser needs to buffer a single look-ahead token; if so, it'll be stored here. This is currently used for handling
 
     protected JsonToken _nextToken;

    
Flag needed to handle recursion into contents of child Array/Object nodes.
 
     protected boolean _startContainer;
    
    
Flag that indicates whether parser is closed or not. Gets set when parser is either closed by explicit call (close()) or when end-of-input is reached.
 
     protected boolean _closed;
 
     /*
     /**********************************************************
     /* Life-cycle
     /**********************************************************
      */
 
     public TreeTraversingParser(JsonNode n) { this(nnull); }
 
     public TreeTraversingParser(JsonNode nObjectCodec codec)
     {
         super(0);
          = codec;
         if (n.isArray()) {
              = .;
              = new NodeCursor.Array(nnull);
         } else if (n.isObject()) {
              = .;
              = new NodeCursor.Object(nnull);
         } else { // value node
              = new NodeCursor.RootValue(nnull);
         }
     }
 
     @Override
     public void setCodec(ObjectCodec c) {
          = c;
     }
 
     @Override
     public ObjectCodec getCodec() {
         return ;
     }
 
     @Override
     public Version version() {
     }
     
     /*
     /**********************************************************
     /* Closeable implementation
    /**********************************************************
     */
    @Override
    public void close() throws IOException
    {
        if (!) {
             = true;
             = null;
             = null;
        }
    }
    /*
    /**********************************************************
    /* Public API, traversal
    /**********************************************************
     */
    @Override
    {
        if ( != null) {
             = ;
             = null;
            return ;
        }
        // are we to descend to a container child?
        if () {
             = false;
            // minor optimization: empty containers can be skipped
            if (!.currentHasChildren()) {
                 = ( == .) ?
                    . : .;
                return ;
            }
             = .iterateChildren();
             = .nextToken();
            if ( == . ||  == .) {
                 = true;
            }
            return ;
        }
        // No more content?
        if ( == null) {
             = true// if not already set
            return null;
        }
        // Otherwise, next entry from current cursor
         = .nextToken();
        if ( != null) {
            if ( == . ||  == .) {
                 = true;
            }
            return ;
        }
        // null means no more children; need to return end marker
         = .endToken();
         = .getParent();
        return ;
    }
    
    // default works well here:
    //public JsonToken nextValue() throws IOException, JsonParseException
    @Override
    {
        if ( == .) {
             = false;
             = .;
        } else if ( == .) {
             = false;
             = .;
        }
        return this;
    }
    @Override
    public boolean isClosed() {
        return ;
    }
    /*
    /**********************************************************
    /* Public API, token accessors
    /**********************************************************
     */
    @Override
    public String getCurrentName() {
        return ( == null) ? null : .getCurrentName();
    }
    @Override
    public void overrideCurrentName(String name)
    {
        if ( != null) {
            .overrideCurrentName(name);
        }
    }
    
    @Override
        return ;
    }
    @Override
    public JsonLocation getTokenLocation() {
        return .;
    }
    @Override
    public JsonLocation getCurrentLocation() {
        return .;
    }
    /*
    /**********************************************************
    /* Public API, access to textual content
    /**********************************************************
     */
    @Override
    public String getText()
    {
        if () {
            return null;
        }
        // need to separate handling a bit...
        switch () {
        case :
            return .getCurrentName();
        case :
            return currentNode().textValue();
        case :
        case :
            return String.valueOf(currentNode().numberValue());
        case :
            JsonNode n = currentNode();
            if (n != null && n.isBinary()) {
                // this will convert it to base64
                return n.asText();
            }
        default:
        	return ( == null) ? null : .asString();
        }
    }
    @Override
    public char[] getTextCharacters() throws IOExceptionJsonParseException {
        return getText().toCharArray();
    }
    @Override
    public int getTextLength() throws IOExceptionJsonParseException {
        return getText().length();
    }
    @Override
    public int getTextOffset() throws IOExceptionJsonParseException {
        return 0;
    }
    @Override
    public boolean hasTextCharacters() {
        // generally we do not have efficient access as char[], hence:
        return false;
    }
    
    /*
    /**********************************************************
    /* Public API, typed non-text access
    /**********************************************************
     */
    //public byte getByteValue() throws IOException, JsonParseException
    @Override
        JsonNode n = currentNumericNode();
        return (n == null) ? null : n.numberType();
    }
    @Override
    {
        return currentNumericNode().bigIntegerValue();
    }
    @Override
        return currentNumericNode().decimalValue();
    }
    @Override
    public double getDoubleValue() throws IOExceptionJsonParseException {
        return currentNumericNode().doubleValue();
    }
    @Override
    public float getFloatValue() throws IOExceptionJsonParseException {
        return (floatcurrentNumericNode().doubleValue();
    }
    @Override
    public long getLongValue() throws IOExceptionJsonParseException {
        return currentNumericNode().longValue();
    }
    @Override
    public int getIntValue() throws IOExceptionJsonParseException {
        return currentNumericNode().intValue();
    }
    @Override
    public Number getNumberValue() throws IOExceptionJsonParseException {
        return currentNumericNode().numberValue();
    }
    @Override
    public Object getEmbeddedObject()
    {
        if (!) {
            JsonNode n = currentNode();
            if (n != null) {
                if (n.isPojo()) {
                    return ((POJONoden).getPojo();
                }
                if (n.isBinary()) {
                    return ((BinaryNoden).binaryValue();
                }
            }
        }
        return null;
    }
    /*
    /**********************************************************
    /* Public API, typed binary (base64) access
    /**********************************************************
     */
    @Override
    public byte[] getBinaryValue(Base64Variant b64variant)
        throws IOExceptionJsonParseException
    {
        // Multiple possibilities...
        JsonNode n = currentNode();
        if (n != null) { // binary node?
            byte[] data = n.binaryValue();
            // (or TextNode, which can also convert automatically!)
            if (data != null) {
                return data;
            }
            // Or maybe byte[] as POJO?
            if (n.isPojo()) {
                Object ob = ((POJONoden).getPojo();
                if (ob instanceof byte[]) {
                    return (byte[]) ob;
                }
            }
        }
        // otherwise return null to mark we have no binary content
        return null;
    }
    @Override
    public int readBinaryValue(Base64Variant b64variantOutputStream out)
            throws IOExceptionJsonParseException
    {
        byte[] data = getBinaryValue(b64variant);
        if (data != null) {
            out.write(data, 0, data.length);
            return data.length;
        }
        return 0;
    }
    /*
    /**********************************************************
    /* Internal methods
    /**********************************************************
     */
    protected JsonNode currentNode() {
        if ( ||  == null) {
            return null;
        }
        return .currentNode();
    }
    protected JsonNode currentNumericNode()
        throws JsonParseException
    {
        JsonNode n = currentNode();
        if (n == null || !n.isNumber()) {
            JsonToken t = (n == null) ? null : n.asToken();
            throw _constructError("Current token ("+t+") not numeric, can not use numeric value accessors");
        }
        return n;
    }
    @Override
    protected void _handleEOF() throws JsonParseException {
        _throwInternal(); // should never get called
    }
New to GrepCode? Check out our FAQ X