Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.core.base;
  
  
Intermediate base class used by all Jackson com.fasterxml.jackson.core.JsonParser implementations, but does not add any additional fields that depend on particular method of obtaining input.

Note that 'minimal' here mostly refers to minimal number of fields (size) and functionality that is specific to certain types of parser implementations; but not necessarily to number of methods.

Author(s):
Tatu Saloranta
 
 public abstract class ParserMinimalBase
     extends JsonParser
 {
     // Control chars:
     protected final static int INT_TAB = '\t';
     protected final static int INT_LF = '\n';
     protected final static int INT_CR = '\r';
     protected final static int INT_SPACE = 0x0020;
 
     // Markup
     protected final static int INT_LBRACKET = '[';
     protected final static int INT_RBRACKET = ']';
     protected final static int INT_LCURLY = '{';
     protected final static int INT_RCURLY = '}';
     protected final static int INT_QUOTE = '"';
     protected final static int INT_BACKSLASH = '\\';
     protected final static int INT_SLASH = '/';
     protected final static int INT_COLON = ':';
     protected final static int INT_COMMA = ',';
     protected final static int INT_ASTERISK = '*';
     protected final static int INT_APOSTROPHE = '\'';
 
     // Letters we need
     protected final static int INT_b = 'b';
     protected final static int INT_f = 'f';
     protected final static int INT_n = 'n';
     protected final static int INT_r = 'r';
     protected final static int INT_t = 't';
     protected final static int INT_u = 'u';
 
     /*
     /**********************************************************
     /* Minimal generally useful state
     /**********************************************************
      */
    
    
Last token retrieved via nextToken(), if any. Null before the first call to nextToken(), as well as if token has been explicitly cleared (by call to clearCurrentToken())
 
     protected JsonToken _currToken;

    
Last cleared token, if any: that is, value that was in effect when clearCurrentToken() was called.
 
     protected JsonToken _lastClearedToken;
     
     /*
     /**********************************************************
     /* Life-cycle
     /**********************************************************
      */
 
     protected ParserMinimalBase() { }
     protected ParserMinimalBase(int features) {
         super(features);
     }
 
     @Override
     public Version version() {
         return VersionUtil.versionFor(getClass());
     }
     
     /*
     /**********************************************************
     /* Configuration overrides if any
     /**********************************************************
      */
 
     // from base class:
 
     //public void enableFeature(Feature f)
     //public void disableFeature(Feature f)
     //public void setFeature(Feature f, boolean state)
     //public boolean isFeatureEnabled(Feature f)
    /*
    /**********************************************************
    /* JsonParser impl
    /**********************************************************
     */
    @Override
    public abstract JsonToken nextToken() throws IOExceptionJsonParseException;
    @Override
    public JsonToken getCurrentToken() {
        return ;
    }
    @Override
    public boolean hasCurrentToken() {
        return  != null;
    }
    
    @Override
    public JsonToken nextValue()
        throws IOExceptionJsonParseException
    {
        /* Implementation should be as trivial as follows; only
         * needs to change if we are to skip other tokens (for
         * example, if comments were exposed as tokens)
         */
        JsonToken t = nextToken();
        if (t == .) {
            t = nextToken();
        }
        return t;
    }
    @Override
    {
        if ( != .
            &&  != .) {
            return this;
        }
        int open = 1;
        /* Since proper matching of start/end markers is handled
         * by nextToken(), we'll just count nesting levels here
         */
        while (true) {
            JsonToken t = nextToken();
            if (t == null) {
                _handleEOF();
                /* given constraints, above should never return;
                 * however, FindBugs doesn't know about it and
                 * complains... so let's add dummy break here
                 */
                return this;
            }
            switch (t) {
            case :
            case :
                ++open;
                break;
            case :
            case :
                if (--open == 0) {
                    return this;
                }
                break;
            }
        }
    }

    
Method sub-classes need to implement
    protected abstract void _handleEOF() throws JsonParseException;
    //public JsonToken getCurrentToken()
    //public boolean hasCurrentToken()
    @Override
    public abstract String getCurrentName() throws IOExceptionJsonParseException;
    
    @Override
    public abstract void close() throws IOException;
    @Override
    public abstract boolean isClosed();
    @Override
    public abstract JsonStreamContext getParsingContext();
//    public abstract JsonLocation getTokenLocation();
//   public abstract JsonLocation getCurrentLocation();
    /*
    /**********************************************************
    /* Public API, token state overrides
    /**********************************************************
     */
    @Override
    public void clearCurrentToken() {
        if ( != null) {
             = ;
             = null;
        }
    }
    @Override
    public JsonToken getLastClearedToken() {
        return ;
    }
    @Override
    public abstract void overrideCurrentName(String name);
    
    /*
    /**********************************************************
    /* Public API, access to token information, text
    /**********************************************************
     */
    @Override
    public abstract String getText() throws IOExceptionJsonParseException;
    @Override
    public abstract char[] getTextCharacters() throws IOExceptionJsonParseException;
    @Override
    public abstract boolean hasTextCharacters();
    @Override
    public abstract int getTextLength() throws IOExceptionJsonParseException;
    @Override
    public abstract int getTextOffset() throws IOExceptionJsonParseException;  
    /*
    /**********************************************************
    /* Public API, access to token information, binary
    /**********************************************************
     */
    @Override
    public abstract byte[] getBinaryValue(Base64Variant b64variant)
        throws IOExceptionJsonParseException;
    /*
    /**********************************************************
    /* Public API, access with conversion/coercion
    /**********************************************************
     */
    @Override
    public boolean getValueAsBoolean(boolean defaultValuethrows IOExceptionJsonParseException
    {
        if ( != null) {
            switch () {
            case :
                return getIntValue() != 0;
            case :
                return true;
            case :
            case :
                return false;
            case :
                {
                    Object value = this.getEmbeddedObject();
                    if (value instanceof Boolean) {
                        return (Booleanvalue;
                    }
                }
            case :
                String str = getText().trim();
                if ("true".equals(str)) {
                    return true;
                }
                break;
            }
        }
        return defaultValue;
    }
    
    @Override
    public int getValueAsInt(int defaultValuethrows IOExceptionJsonParseException
    {
        if ( != null) {
            switch () {
            case :
            case :
                return getIntValue();
            case :
                return 1;
            case :
            case :
                return 0;
            case :
                return NumberInput.parseAsInt(getText(), defaultValue);
            case :
                {
                    Object value = this.getEmbeddedObject();
                    if (value instanceof Number) {
                        return ((Numbervalue).intValue();
                    }
                }
            }
        }
        return defaultValue;
    }
    
    @Override
    public long getValueAsLong(long defaultValuethrows IOExceptionJsonParseException
    {
        if ( != null) {
            switch () {
            case :
            case :
                return getLongValue();
            case :
                return 1;
            case :
            case :
                return 0;
            case :
                return NumberInput.parseAsLong(getText(), defaultValue);
            case :
                {
                    Object value = this.getEmbeddedObject();
                    if (value instanceof Number) {
                        return ((Numbervalue).longValue();
                    }
                }
            }
        }
        return defaultValue;
    }
    @Override
    public double getValueAsDouble(double defaultValuethrows IOExceptionJsonParseException
    {
        if ( != null) {
            switch () {
            case :
            case :
                return getDoubleValue();
            case :
                return 1;
            case :
            case :
                return 0;
            case :
                return NumberInput.parseAsDouble(getText(), defaultValue);
            case :
                {
                    Object value = this.getEmbeddedObject();
                    if (value instanceof Number) {
                        return ((Numbervalue).doubleValue();
                    }
                }
            }
        }
        return defaultValue;
    }
    @Override
    public String getValueAsString(String defaultValuethrows IOExceptionJsonParseException
    {
        if ( != .) {
            if ( == null ||  == . || !.isScalarValue()) {
                return defaultValue;
            }
        }
        return getText();
    }
    
    /*
    /**********************************************************
    /* Base64 decoding
    /**********************************************************
     */

    
Helper method that can be used for base64 decoding in cases where encoded content has already been read as a String.
    protected void _decodeBase64(String strByteArrayBuilder builderBase64Variant b64variant)
        throws IOExceptionJsonParseException
    {
        int ptr = 0;
        int len = str.length();
        
        main_loop:
        while (ptr < len) {
            // first, we'll skip preceding white space, if any
            char ch;
            do {
                ch = str.charAt(ptr++);
                if (ptr >= len) {
                    break main_loop;
                }
            } while (ch <= );
            int bits = b64variant.decodeBase64Char(ch);
            if (bits < 0) {
                _reportInvalidBase64(b64variantch, 0, null);
            }
            int decodedData = bits;
            // then second base64 char; can't get padding yet, nor ws
            if (ptr >= len) {
                _reportBase64EOF();
            }
            ch = str.charAt(ptr++);
            bits = b64variant.decodeBase64Char(ch);
            if (bits < 0) {
                _reportInvalidBase64(b64variantch, 1, null);
            }
            decodedData = (decodedData << 6) | bits;
            // third base64 char; can be padding, but not ws
            if (ptr >= len) {
                // but as per [JACKSON-631] can be end-of-input, iff not using padding
                if (!b64variant.usesPadding()) {
                    decodedData >>= 4;
                    builder.append(decodedData);
                    break;
                }
                _reportBase64EOF();
            }
            ch = str.charAt(ptr++);
            bits = b64variant.decodeBase64Char(ch);
            
            // First branch: can get padding (-> 1 byte)
            if (bits < 0) {
                if (bits != .) {
                    _reportInvalidBase64(b64variantch, 2, null);
                }
                // Ok, must get padding
                if (ptr >= len) {
                    _reportBase64EOF();
                }
                ch = str.charAt(ptr++);
                if (!b64variant.usesPaddingChar(ch)) {
                    _reportInvalidBase64(b64variantch, 3, "expected padding character '"+b64variant.getPaddingChar()+"'");
                }
                // Got 12 bits, only need 8, need to shift
                decodedData >>= 4;
                builder.append(decodedData);
                continue;
            }
            // Nope, 2 or 3 bytes
            decodedData = (decodedData << 6) | bits;
            // fourth and last base64 char; can be padding, but not ws
            if (ptr >= len) {
                // but as per [JACKSON-631] can be end-of-input, iff not using padding
                if (!b64variant.usesPadding()) {
                    decodedData >>= 2;
                    builder.appendTwoBytes(decodedData);
                    break;
                }
                _reportBase64EOF();
            }
            ch = str.charAt(ptr++);
            bits = b64variant.decodeBase64Char(ch);
            if (bits < 0) {
                if (bits != .) {
                    _reportInvalidBase64(b64variantch, 3, null);
                }
                decodedData >>= 2;
                builder.appendTwoBytes(decodedData);
            } else {
                // otherwise, our triple is now complete
                decodedData = (decodedData << 6) | bits;
                builder.appendThreeBytes(decodedData);
            }
        }
    }

    

Parameters:
bindex Relative index within base64 character unit; between 0 and 3 (as unit has exactly 4 characters)
    protected void _reportInvalidBase64(Base64Variant b64variantchar chint bindexString msg)
        throws JsonParseException
    {
        String base;
        if (ch <= ) {
            base = "Illegal white space character (code 0x"+Integer.toHexString(ch)+") as character #"+(bindex+1)+" of 4-char base64 unit: can only used between units";
        } else if (b64variant.usesPaddingChar(ch)) {
            base = "Unexpected padding character ('"+b64variant.getPaddingChar()+"') as character #"+(bindex+1)+" of 4-char base64 unit: padding only legal as 3rd or 4th character";
        } else if (!Character.isDefined(ch) || Character.isISOControl(ch)) {
            // Not sure if we can really get here... ? (most illegal xml chars are caught at lower level)
            base = "Illegal character (code 0x"+Integer.toHexString(ch)+") in base64 content";
        } else {
            base = "Illegal character '"+ch+"' (code 0x"+Integer.toHexString(ch)+") in base64 content";
        }
        if (msg != null) {
            base = base + ": " + msg;
        }
        throw _constructError(base);
    }
    protected void _reportBase64EOF() throws JsonParseException {
        throw _constructError("Unexpected end-of-String in base64 content");
    }
    
    
    /*
    /**********************************************************
    /* Error reporting
    /**********************************************************
     */
    
    protected void _reportUnexpectedChar(int chString comment)
        throws JsonParseException
    {
        String msg = "Unexpected character ("+_getCharDesc(ch)+")";
        if (comment != null) {
            msg += ": "+comment;
        }
        _reportError(msg);
    }
    protected void _reportInvalidEOF()
        throws JsonParseException
    {
        _reportInvalidEOF(" in "+);
    }
    protected void _reportInvalidEOF(String msg)
        throws JsonParseException
    {
        _reportError("Unexpected end-of-input"+msg);
    }
    protected void _reportInvalidEOFInValue() throws JsonParseException
    {
        _reportInvalidEOF(" in a value");
    }
    
    protected void _throwInvalidSpace(int i)
        throws JsonParseException
    {
        char c = (chari;
        String msg = "Illegal character ("+_getCharDesc(c)+"): only regular white space (\\r, \\n, \\t) is allowed between tokens";
        _reportError(msg);
    }

    
Method called to report a problem with unquoted control character. Note: starting with version 1.4, it is possible to suppress exception by enabling com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS.
    protected void _throwUnquotedSpace(int iString ctxtDesc)
        throws JsonParseException
    {
        // JACKSON-208; possible to allow unquoted control chars:
        if (!isEnabled(.) || i >= ) {
            char c = (chari;
            String msg = "Illegal unquoted character ("+_getCharDesc(c)+"): has to be escaped using backslash to be included in "+ctxtDesc;
            _reportError(msg);
        }
    }
    protected char _handleUnrecognizedCharacterEscape(char chthrows JsonProcessingException
    {
        // as per [JACKSON-300]
            return ch;
        }
        // and [JACKSON-548]
        if (ch == '\'' && isEnabled(.)) {
            return ch;
        }
        _reportError("Unrecognized character escape "+_getCharDesc(ch));
        return ch;
    }
    
    /*
    /**********************************************************
    /* Error reporting, generic
    /**********************************************************
     */
    protected final static String _getCharDesc(int ch)
    {
        char c = (charch;
        if (Character.isISOControl(c)) {
            return "(CTRL-CHAR, code "+ch+")";
        }
        if (ch > 255) {
            return "'"+c+"' (code "+ch+" / 0x"+Integer.toHexString(ch)+")";
        }
        return "'"+c+"' (code "+ch+")";
    }
    protected final void _reportError(String msg)
        throws JsonParseException
    {
        throw _constructError(msg);
    }
    protected final void _wrapError(String msgThrowable t)
        throws JsonParseException
    {
        throw _constructError(msgt);
    }
    protected final void _throwInternal()
    {
        throw new RuntimeException("Internal error: this code path should never get executed");
    }
    protected final JsonParseException _constructError(String msgThrowable t)
    {
        return new JsonParseException(msggetCurrentLocation(), t);
    }
New to GrepCode? Check out our FAQ X