Java Code Examples for com.fasterxml.jackson.core.io.CharTypes#getInputCodeUtf8JsNames()

/**
     * Method called when we see non-white space character other
     * than double quote, when expecting a field name.
     * In standard mode will just throw an exception; but
     * in non-standard modes may be able to parse name.
     */
    private JsonToken _handleOddName(int ch) throws IOException
    {
        // First: may allow single quotes
        switch (ch) {
        case '#':
            // Careful, since this may alternatively be leading char of
            // unquoted name...
            if (JsonParser.Feature.ALLOW_YAML_COMMENTS.enabledIn(_features)) {
                return _finishHashComment(MINOR_FIELD_LEADING_WS);
            }
            break;
        case '/':
            return _startSlashComment(MINOR_FIELD_LEADING_WS);
        case '\'':
            if (isEnabled(Feature.ALLOW_SINGLE_QUOTES)) {
                return _finishAposName(0, 0, 0);
            }
            break;
        case ']': // for better error reporting...
            return _closeArrayScope();
        }
        // allow unquoted names if feature enabled:
        if (!isEnabled(Feature.ALLOW_UNQUOTED_FIELD_NAMES)) {
         // !!! TODO: Decode UTF-8 characters properly...
//            char c = (char) _decodeCharForError(ch);
            char c = (char) ch;
            _reportUnexpectedChar(c, "was expecting double-quote to start field name");
        }
        // Also: note that although we use a different table here, it does NOT handle UTF-8
        // decoding. It'll just pass those high-bit codes as acceptable for later decoding.
        final int[] codes = CharTypes.getInputCodeUtf8JsNames();
        // Also: must start with a valid character...
        if (codes[ch] != 0) {
            _reportUnexpectedChar(ch, "was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
        }

        return _finishUnquotedName(0, ch, 1);
    }
 

/**
 * Method called when we see non-white space character other
 * than double quote, when expecting a field name.
 * In standard mode will just throw an exception; but
 * in non-standard modes may be able to parse name.
 */
protected String _handleOddName(int ch) throws IOException
{
    // First: may allow single quotes
    if (ch == INT_APOS && isEnabled(Feature.ALLOW_SINGLE_QUOTES)) {
        return _parseAposName();
    }
    // Allow unquoted names if feature enabled:
    if (!isEnabled(Feature.ALLOW_UNQUOTED_FIELD_NAMES)) {
        char c = (char) _decodeCharForError(ch);
        _reportUnexpectedChar(c, "was expecting double-quote to start field name");
    }
    /* Also: note that although we use a different table here,
     * it does NOT handle UTF-8 decoding. It'll just pass those
     * high-bit codes as acceptable for later decoding.
     */
    final int[] codes = CharTypes.getInputCodeUtf8JsNames();
    // Also: must start with a valid character...
    if (codes[ch] != 0) {
        _reportUnexpectedChar(ch, "was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
    }

    // Ok, now; instead of ultra-optimizing parsing here (as with regular
    // JSON names), let's just use the generic "slow" variant.
    // Can measure its impact later on if need be.
    int[] quads = _quadBuffer;
    int qlen = 0;
    int currQuad = 0;
    int currQuadBytes = 0;

    while (true) {
        // Ok, we have one more byte to add at any rate:
        if (currQuadBytes < 4) {
            ++currQuadBytes;
            currQuad = (currQuad << 8) | ch;
        } else {
            if (qlen >= quads.length) {
                _quadBuffer = quads = growArrayBy(quads, quads.length);
            }
            quads[qlen++] = currQuad;
            currQuad = ch;
            currQuadBytes = 1;
        }
        if (_inputPtr >= _inputEnd) {
            if (!_loadMore()) {
                _reportInvalidEOF(" in field name", JsonToken.FIELD_NAME);
            }
        }
        ch = _inputBuffer[_inputPtr] & 0xFF;
        if (codes[ch] != 0) {
            break;
        }
        ++_inputPtr;
    }

    if (currQuadBytes > 0) {
        if (qlen >= quads.length) {
            _quadBuffer = quads = growArrayBy(quads, quads.length);
        }
        quads[qlen++] = currQuad;
    }
    String name = _symbols.findName(quads, qlen);
    if (name == null) {
        name = addName(quads, qlen, currQuadBytes);
    }
    return name;
}
 

/**
 * Method called when we see non-white space character other
 * than double quote, when expecting a field name.
 * In standard mode will just throw an exception; but
 * in non-standard modes may be able to parse name.
 */
protected String _handleOddName(int ch) throws IOException
{
    if (ch == '\'' && isEnabled(Feature.ALLOW_SINGLE_QUOTES)) {
        return _parseAposName();
    }
    if (!isEnabled(Feature.ALLOW_UNQUOTED_FIELD_NAMES)) {
        char c = (char) _decodeCharForError(ch);
        _reportUnexpectedChar(c, "was expecting double-quote to start field name");
    }
    /* Also: note that although we use a different table here,
     * it does NOT handle UTF-8 decoding. It'll just pass those
     * high-bit codes as acceptable for later decoding.
     */
    final int[] codes = CharTypes.getInputCodeUtf8JsNames();
    // Also: must start with a valid character...
    if (codes[ch] != 0) {
        _reportUnexpectedChar(ch, "was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
    }

    /* Ok, now; instead of ultra-optimizing parsing here (as with
     * regular JSON names), let's just use the generic "slow"
     * variant. Can measure its impact later on if need be
     */
    int[] quads = _quadBuffer;
    int qlen = 0;
    int currQuad = 0;
    int currQuadBytes = 0;

    while (true) {
        // Ok, we have one more byte to add at any rate:
        if (currQuadBytes < 4) {
            ++currQuadBytes;
            currQuad = (currQuad << 8) | ch;
        } else {
            if (qlen >= quads.length) {
                _quadBuffer = quads = _growArrayBy(quads, quads.length);
            }
            quads[qlen++] = currQuad;
            currQuad = ch;
            currQuadBytes = 1;
        }
        ch = _inputData.readUnsignedByte();
        if (codes[ch] != 0) {
            break;
        }
    }
    // Note: we must "push back" character read here for future consumption
    _nextByte = ch;
    if (currQuadBytes > 0) {
        if (qlen >= quads.length) {
            _quadBuffer = quads = _growArrayBy(quads, quads.length);
        }
        quads[qlen++] = currQuad;
    }
    String name = _symbols.findName(quads, qlen);
    if (name == null) {
        name = addName(quads, qlen, currQuadBytes);
    }
    return name;
}
 

/**
 * Parsing of optionally supported non-standard "unquoted" names: names without
 * either double-quotes or apostrophes surrounding them.
 * Unlike other 
 */
private JsonToken _finishUnquotedName(int qlen, int currQuad, int currQuadBytes)
    throws IOException
{
    int[] quads = _quadBuffer;
    final int[] codes = CharTypes.getInputCodeUtf8JsNames();

    // Ok, now; instead of ultra-optimizing parsing here (as with regular JSON names),
    // let's just use the generic "slow" variant. Can measure its impact later on if need be.
    while (true) {
        if (_inputPtr >= _inputEnd) {
            _quadLength = qlen;
            _pending32 = currQuad;
            _pendingBytes = currQuadBytes;
            _minorState = MINOR_FIELD_UNQUOTED_NAME;
            return (_currToken = JsonToken.NOT_AVAILABLE);
        }
        int ch = _inputBuffer[_inputPtr] & 0xFF;
        if (codes[ch] != 0) {
            break;
        }
        ++_inputPtr;
        // Ok, we have one more byte to add at any rate:
        if (currQuadBytes < 4) {
            ++currQuadBytes;
            currQuad = (currQuad << 8) | ch;
        } else {
            if (qlen >= quads.length) {
                _quadBuffer = quads = growArrayBy(quads, quads.length);
            }
            quads[qlen++] = currQuad;
            currQuad = ch;
            currQuadBytes = 1;
        }
    }

    if (currQuadBytes > 0) {
        if (qlen >= quads.length) {
            _quadBuffer = quads = growArrayBy(quads, quads.length);
        }
        quads[qlen++] = currQuad;
    }
    String name = _symbols.findName(quads, qlen);
    if (name == null) {
        name = _addName(quads, qlen, currQuadBytes);
    }
    return _fieldComplete(name);
}
 

/**
 * Method called when we see non-white space character other
 * than double quote, when expecting a field name.
 * In standard mode will just throw an expection; but
 * in non-standard modes may be able to parse name.
 */
protected String _handleOddName(int ch) throws IOException
{
    // [JACKSON-173]: allow single quotes
    if (ch == '\'' && isEnabled(Feature.ALLOW_SINGLE_QUOTES)) {
        return _parseAposName();
    }
    // [JACKSON-69]: allow unquoted names if feature enabled:
    if (!isEnabled(Feature.ALLOW_UNQUOTED_FIELD_NAMES)) {
        char c = (char) _decodeCharForError(ch);
        _reportUnexpectedChar(c, "was expecting double-quote to start field name");
    }
    /* Also: note that although we use a different table here,
     * it does NOT handle UTF-8 decoding. It'll just pass those
     * high-bit codes as acceptable for later decoding.
     */
    final int[] codes = CharTypes.getInputCodeUtf8JsNames();
    // Also: must start with a valid character...
    if (codes[ch] != 0) {
        _reportUnexpectedChar(ch, "was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
    }

    /* Ok, now; instead of ultra-optimizing parsing here (as with
     * regular JSON names), let's just use the generic "slow"
     * variant. Can measure its impact later on if need be
     */
    int[] quads = _quadBuffer;
    int qlen = 0;
    int currQuad = 0;
    int currQuadBytes = 0;

    while (true) {
        // Ok, we have one more byte to add at any rate:
        if (currQuadBytes < 4) {
            ++currQuadBytes;
            currQuad = (currQuad << 8) | ch;
        } else {
            if (qlen >= quads.length) {
                _quadBuffer = quads = growArrayBy(quads, quads.length);
            }
            quads[qlen++] = currQuad;
            currQuad = ch;
            currQuadBytes = 1;
        }
        if (_inputPtr >= _inputEnd) {
            if (!loadMore()) {
                _reportInvalidEOF(" in field name");
            }
        }
        ch = _inputBuffer[_inputPtr] & 0xFF;
        if (codes[ch] != 0) {
            break;
        }
        ++_inputPtr;
    }

    if (currQuadBytes > 0) {
        if (qlen >= quads.length) {
            _quadBuffer = quads = growArrayBy(quads, quads.length);
        }
        quads[qlen++] = currQuad;
    }
    String name = _symbols.findName(quads, qlen);
    if (name == null) {
        name = addName(quads, qlen, currQuadBytes);
    }
    return name;
}