Java 类com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer 实例源码

public JsonParser constructParser(ObjectReadContext readCtxt, int parserFeatures,
        ByteQuadsCanonicalizer rootByteSymbols, CharsToNameCanonicalizer rootCharSymbols,
        int factoryFeatures) throws IOException
{
    JsonEncoding enc = detectEncoding();

    if (enc == JsonEncoding.UTF8) {
        /* and without canonicalization, byte-based approach is not performant; just use std UTF-8 reader
         * (which is ok for larger input; not so hot for smaller; but this is not a common case)
         */
        if (JsonFactory.Feature.CANONICALIZE_FIELD_NAMES.enabledIn(factoryFeatures)) {
            ByteQuadsCanonicalizer can = rootByteSymbols.makeChild(factoryFeatures);
            return new UTF8StreamJsonParser(readCtxt, _context, parserFeatures, _in, can,
                    _inputBuffer, _inputPtr, _inputEnd, _bufferRecyclable);
        }
    }
    return new ReaderBasedJsonParser(readCtxt, _context, parserFeatures, constructReader(),
            rootCharSymbols.makeChild(factoryFeatures));
}

/**
 * Method called when caller wants to provide input buffer directly,
 * and it may or may not be recyclable use standard recycle context.
 */
public ReaderBasedJsonParser(ObjectReadContext readCtxt, IOContext ctxt,
        int features, Reader r,
        CharsToNameCanonicalizer st,
        char[] inputBuffer, int start, int end,
        boolean bufferRecyclable)
{
    super(readCtxt, ctxt, features);
    _reader = r;
    _inputBuffer = inputBuffer;
    _inputPtr = start;
    _inputEnd = end;
    _symbols = st;
    _hashSeed = st.hashSeed();
    _bufferRecyclable = bufferRecyclable;
}

@Test
public void testClose() throws IOException {
    IOContext ioContext = new IOContext(new BufferRecycler(), this, true);
    ReaderBasedJsonParser readerBasedJsonParser = new ReaderBasedJsonParser(
            ObjectReadContext.empty(),
            ioContext,
            2, null, CharsToNameCanonicalizer.createRoot());
    JsonParserSequence jsonParserSequence = JsonParserSequence.createFlattened(true, readerBasedJsonParser, readerBasedJsonParser);

    assertFalse(jsonParserSequence.isClosed());

    jsonParserSequence.close();

    assertTrue(jsonParserSequence.isClosed());
    assertNull(jsonParserSequence.nextToken());
}

public JsonParser constructParser(int parserFeatures, ObjectCodec codec,
        BytesToNameCanonicalizer rootByteSymbols, CharsToNameCanonicalizer rootCharSymbols,
        boolean canonicalize, boolean intern)
    throws IOException
{
    JsonEncoding enc = detectEncoding();

    if (enc == JsonEncoding.UTF8) {
        /* and without canonicalization, byte-based approach is not performance; just use std UTF-8 reader
         * (which is ok for larger input; not so hot for smaller; but this is not a common case)
         */
        if (canonicalize) {
            BytesToNameCanonicalizer can = rootByteSymbols.makeChild(canonicalize, intern);
            return new UTF8StreamJsonParser(_context, parserFeatures, _in, codec, can, _inputBuffer, _inputPtr, _inputEnd, _bufferRecyclable);
        }
    }
    return new ReaderBasedJsonParser(_context, parserFeatures, constructReader(), codec,
            rootCharSymbols.makeChild(canonicalize, intern));
}

public JsonParser constructParser(int parserFeatures, ObjectCodec codec,
        BytesToNameCanonicalizer rootByteSymbols, CharsToNameCanonicalizer rootCharSymbols,
        boolean canonicalize, boolean intern)
    throws IOException, JsonParseException
{
    JsonEncoding enc = detectEncoding();

    if (enc == JsonEncoding.UTF8) {
        /* and without canonicalization, byte-based approach is not performance; just use std UTF-8 reader
         * (which is ok for larger input; not so hot for smaller; but this is not a common case)
         */
        if (canonicalize) {
            BytesToNameCanonicalizer can = rootByteSymbols.makeChild(canonicalize, intern);
            return new UTF8StreamJsonParser(_context, parserFeatures, _in, codec, can, _inputBuffer, _inputPtr, _inputEnd, _bufferRecyclable);
        }
    }
    return new ReaderBasedJsonParser(_context, parserFeatures, constructReader(), codec,
            rootCharSymbols.makeChild(canonicalize, intern));
}

/**
 * Method called when input comes as a {@link java.io.Reader}, and buffer allocation
 * can be done using default mechanism.
 */
public ReaderBasedJsonParser(ObjectReadContext readCtxt, IOContext ctxt,
        int features, Reader r,
        CharsToNameCanonicalizer st)
{
    super(readCtxt, ctxt, features);
    _reader = r;
    _inputBuffer = ctxt.allocTokenBuffer();
    _inputPtr = 0;
    _inputEnd = 0;
    _symbols = st;
    _hashSeed = st.hashSeed();
    _bufferRecyclable = true;
}

public final JsonParser constructParser(int paramInt, ObjectCodec paramObjectCodec, BytesToNameCanonicalizer paramBytesToNameCanonicalizer, CharsToNameCanonicalizer paramCharsToNameCanonicalizer, boolean paramBoolean1, boolean paramBoolean2)
{
  if ((detectEncoding() == JsonEncoding.UTF8) && (paramBoolean1))
  {
    BytesToNameCanonicalizer localBytesToNameCanonicalizer = paramBytesToNameCanonicalizer.makeChild(paramBoolean1, paramBoolean2);
    return new UTF8StreamJsonParser(this._context, paramInt, this._in, paramObjectCodec, localBytesToNameCanonicalizer, this._inputBuffer, this._inputPtr, this._inputEnd, this._bufferRecyclable);
  }
  return new ReaderBasedJsonParser(this._context, paramInt, constructReader(), paramObjectCodec, paramCharsToNameCanonicalizer.makeChild(paramBoolean1, paramBoolean2));
}

public ReaderBasedJsonParser(IOContext paramIOContext, int paramInt, Reader paramReader, ObjectCodec paramObjectCodec, CharsToNameCanonicalizer paramCharsToNameCanonicalizer)
{
  super(paramIOContext, paramInt);
  this._reader = paramReader;
  this._inputBuffer = paramIOContext.allocTokenBuffer();
  this._objectCodec = paramObjectCodec;
  this._symbols = paramCharsToNameCanonicalizer;
  this._hashSeed = paramCharsToNameCanonicalizer.hashSeed();
}

public ReaderBasedJsonParser(IOContext ctxt, int features, Reader r,
        ObjectCodec codec, CharsToNameCanonicalizer st)
{
    super(ctxt, features);
    _reader = r;
    _inputBuffer = ctxt.allocTokenBuffer();
    _objectCodec = codec;
    _symbols = st;
    _hashSeed = st.hashSeed();
}

public ReaderBasedJsonParser(IOContext ctxt, int features, Reader r,
        ObjectCodec codec, CharsToNameCanonicalizer st)
{
    super(ctxt, features);
    _reader = r;
    _inputBuffer = ctxt.allocTokenBuffer();
    _objectCodec = codec;
    _symbols = st;
    _hashSeed = st.hashSeed();
}

private String _parseName2(int startPtr, int hash, int endChar) throws IOException
{
    _textBuffer.resetWithShared(_inputBuffer, startPtr, (_inputPtr - startPtr));

    /* Output pointers; calls will also ensure that the buffer is
     * not shared and has room for at least one more char.
     */
    char[] outBuf = _textBuffer.getCurrentSegment();
    int outPtr = _textBuffer.getCurrentSegmentSize();

    while (true) {
        if (_inputPtr >= _inputEnd) {
            if (!_loadMore()) {
                _reportInvalidEOF(" in field name", JsonToken.FIELD_NAME);
            }
        }
        char c = _inputBuffer[_inputPtr++];
        int i = (int) c;
        if (i <= INT_BACKSLASH) {
            if (i == INT_BACKSLASH) {
                /* Although chars outside of BMP are to be escaped as
                 * an UTF-16 surrogate pair, does that affect decoding?
                 * For now let's assume it does not.
                 */
                c = _decodeEscaped();
            } else if (i <= endChar) {
                if (i == endChar) {
                    break;
                }
                if (i < INT_SPACE) {
                    _throwUnquotedSpace(i, "name");
                }
            }
        }
        hash = (hash * CharsToNameCanonicalizer.HASH_MULT) + c;
        // Ok, let's add char to output:
        outBuf[outPtr++] = c;

        // Need more room?
        if (outPtr >= outBuf.length) {
            outBuf = _textBuffer.finishCurrentSegment();
            outPtr = 0;
        }
    }
    _textBuffer.setCurrentLength(outPtr);
    {
        TextBuffer tb = _textBuffer;
        char[] buf = tb.getTextBuffer();
        int start = tb.getTextOffset();
        int len = tb.size();
        return _symbols.findSymbol(buf, start, len, hash);
    }
}

private String _handleOddName2(int startPtr, int hash, int[] codes) throws IOException
{
    _textBuffer.resetWithShared(_inputBuffer, startPtr, (_inputPtr - startPtr));
    char[] outBuf = _textBuffer.getCurrentSegment();
    int outPtr = _textBuffer.getCurrentSegmentSize();
    final int maxCode = codes.length;

    while (true) {
        if (_inputPtr >= _inputEnd) {
            if (!_loadMore()) { // acceptable for now (will error out later)
                break;
            }
        }
        char c = _inputBuffer[_inputPtr];
        int i = (int) c;
        if (i <= maxCode) {
            if (codes[i] != 0) {
                break;
            }
        } else if (!Character.isJavaIdentifierPart(c)) {
            break;
        }
        ++_inputPtr;
        hash = (hash * CharsToNameCanonicalizer.HASH_MULT) + i;
        // Ok, let's add char to output:
        outBuf[outPtr++] = c;

        // Need more room?
        if (outPtr >= outBuf.length) {
            outBuf = _textBuffer.finishCurrentSegment();
            outPtr = 0;
        }
    }
    _textBuffer.setCurrentLength(outPtr);
    {
        TextBuffer tb = _textBuffer;
        char[] buf = tb.getTextBuffer();
        int start = tb.getTextOffset();
        int len = tb.size();

        return _symbols.findSymbol(buf, start, len, hash);
    }
}

private String _parseName2(int startPtr, int hash, int endChar) throws IOException
{
    _textBuffer.resetWithShared(_inputBuffer, startPtr, (_inputPtr - startPtr));

    /* Output pointers; calls will also ensure that the buffer is
     * not shared and has room for at least one more char.
     */
    char[] outBuf = _textBuffer.getCurrentSegment();
    int outPtr = _textBuffer.getCurrentSegmentSize();

    while (true) {
        if (_inputPtr >= _inputEnd) {
            if (!loadMore()) {
                _reportInvalidEOF(": was expecting closing '"+((char) endChar)+"' for name");
            }
        }
        char c = _inputBuffer[_inputPtr++];
        int i = (int) c;
        if (i <= INT_BACKSLASH) {
            if (i == INT_BACKSLASH) {
                /* Although chars outside of BMP are to be escaped as
                 * an UTF-16 surrogate pair, does that affect decoding?
                 * For now let's assume it does not.
                 */
                c = _decodeEscaped();
            } else if (i <= endChar) {
                if (i == endChar) {
                    break;
                }
                if (i < INT_SPACE) {
                    _throwUnquotedSpace(i, "name");
                }
            }
        }
        hash = (hash * CharsToNameCanonicalizer.HASH_MULT) + i;
        // Ok, let's add char to output:
        outBuf[outPtr++] = c;

        // Need more room?
        if (outPtr >= outBuf.length) {
            outBuf = _textBuffer.finishCurrentSegment();
            outPtr = 0;
        }
    }
    _textBuffer.setCurrentLength(outPtr);
    {
        TextBuffer tb = _textBuffer;
        char[] buf = tb.getTextBuffer();
        int start = tb.getTextOffset();
        int len = tb.size();

        return _symbols.findSymbol(buf, start, len, hash);
    }
}

private String _handleOddName2(int startPtr, int hash, int[] codes) throws IOException
{
    _textBuffer.resetWithShared(_inputBuffer, startPtr, (_inputPtr - startPtr));
    char[] outBuf = _textBuffer.getCurrentSegment();
    int outPtr = _textBuffer.getCurrentSegmentSize();
    final int maxCode = codes.length;

    while (true) {
        if (_inputPtr >= _inputEnd) {
            if (!loadMore()) { // acceptable for now (will error out later)
                break;
            }
        }
        char c = _inputBuffer[_inputPtr];
        int i = (int) c;
        if (i <= maxCode) {
            if (codes[i] != 0) {
                break;
            }
        } else if (!Character.isJavaIdentifierPart(c)) {
            break;
        }
        ++_inputPtr;
        hash = (hash * CharsToNameCanonicalizer.HASH_MULT) + i;
        // Ok, let's add char to output:
        outBuf[outPtr++] = c;

        // Need more room?
        if (outPtr >= outBuf.length) {
            outBuf = _textBuffer.finishCurrentSegment();
            outPtr = 0;
        }
    }
    _textBuffer.setCurrentLength(outPtr);
    {
        TextBuffer tb = _textBuffer;
        char[] buf = tb.getTextBuffer();
        int start = tb.getTextOffset();
        int len = tb.size();

        return _symbols.findSymbol(buf, start, len, hash);
    }
}

private String _parseFieldName2(int startPtr, int hash, int endChar)
    throws IOException, JsonParseException
{
    _textBuffer.resetWithShared(_inputBuffer, startPtr, (_inputPtr - startPtr));

    /* Output pointers; calls will also ensure that the buffer is
     * not shared and has room for at least one more char.
     */
    char[] outBuf = _textBuffer.getCurrentSegment();
    int outPtr = _textBuffer.getCurrentSegmentSize();

    while (true) {
        if (_inputPtr >= _inputEnd) {
            if (!loadMore()) {
                _reportInvalidEOF(": was expecting closing '"+((char) endChar)+"' for name");
            }
        }
        char c = _inputBuffer[_inputPtr++];
        int i = (int) c;
        if (i <= INT_BACKSLASH) {
            if (i == INT_BACKSLASH) {
                /* Although chars outside of BMP are to be escaped as
                 * an UTF-16 surrogate pair, does that affect decoding?
                 * For now let's assume it does not.
                 */
                c = _decodeEscaped();
            } else if (i <= endChar) {
                if (i == endChar) {
                    break;
                }
                if (i < INT_SPACE) {
                    _throwUnquotedSpace(i, "name");
                }
            }
        }
        hash = (hash * CharsToNameCanonicalizer.HASH_MULT) + i;
        // Ok, let's add char to output:
        outBuf[outPtr++] = c;

        // Need more room?
        if (outPtr >= outBuf.length) {
            outBuf = _textBuffer.finishCurrentSegment();
            outPtr = 0;
        }
    }
    _textBuffer.setCurrentLength(outPtr);
    {
        TextBuffer tb = _textBuffer;
        char[] buf = tb.getTextBuffer();
        int start = tb.getTextOffset();
        int len = tb.size();

        return _symbols.findSymbol(buf, start, len, hash);
    }
}

private String _parseUnusualFieldName2(int startPtr, int hash, int[] codes)
    throws IOException, JsonParseException
{
    _textBuffer.resetWithShared(_inputBuffer, startPtr, (_inputPtr - startPtr));
    char[] outBuf = _textBuffer.getCurrentSegment();
    int outPtr = _textBuffer.getCurrentSegmentSize();
    final int maxCode = codes.length;

    while (true) {
        if (_inputPtr >= _inputEnd) {
            if (!loadMore()) { // acceptable for now (will error out later)
                break;
            }
        }
        char c = _inputBuffer[_inputPtr];
        int i = (int) c;
        if (i <= maxCode) {
            if (codes[i] != 0) {
                break;
            }
        } else if (!Character.isJavaIdentifierPart(c)) {
            break;
        }
        ++_inputPtr;
        hash = (hash * CharsToNameCanonicalizer.HASH_MULT) + i;
        // Ok, let's add char to output:
        outBuf[outPtr++] = c;

        // Need more room?
        if (outPtr >= outBuf.length) {
            outBuf = _textBuffer.finishCurrentSegment();
            outPtr = 0;
        }
    }
    _textBuffer.setCurrentLength(outPtr);
    {
        TextBuffer tb = _textBuffer;
        char[] buf = tb.getTextBuffer();
        int start = tb.getTextOffset();
        int len = tb.size();

        return _symbols.findSymbol(buf, start, len, hash);
    }
}