}

        // Nope, root context

        // No commas within root context, but need space

    /* Public API, byte buffers

    /**********************************************************

     */

    /**

     * @param ix One of <code>READ_IO_BUFFER</code> constants.

     *

    /* Public API, char buffers

    /**********************************************************

     */

    public final char[] allocCharBuffer(int ix) {

    }

    /* Location/state information

    /**********************************************************************

     */

    /**

     * Name of the property of which value is to be parsed; only

     * used for OBJECT contexts

    /* State changes

    /**********************************************************************

     */

    public TokenFilter setPropertyName(String name) {

        }

    }

    public void skipParentChecks() {

        // should never occur but...

    }

    // // // Internally used abstract methods

    protected void appendDesc(StringBuilder sb) {

    /* Output buffering

    /**********************************************************************

     */

    /**

     * Intermediate buffer in which contents are buffered before

     * being written using {@link #_writer}.

        // we know there's room for at least one more char

        // The beef:

        }

    }

    @Override

    public JsonGenerator writeEndArray() throws JacksonException

    {

            }

        }

    @Override

    public JsonGenerator writeRawUTF8String(byte[] text, int offset, int length) throws JacksonException {

        // could add support for buffering if we really want it...

        }

    @Override

    public JsonGenerator writeNumber(int i) throws JacksonException

    @Override

    public JsonGenerator writeNumber(long l) throws JacksonException

        // First things first: let's flush the buffer to get some more room

        do {

    {

    /**

     * This method called when the string content is already in

     * a char buffer, and need not be copied for processing.

            }

            // Nope, need to escape the char.

        output_loop:

            char c;

    {

        output_loop:

            // Fast loop for chars not needing escaping

            char c;

            while (true) {

        output_loop:

            // Fast loop for chars not needing escaping

            char c;

            while (true) {

                }

            }

            // Short span? Better just copy it to buffer first:

    /* Internal methods, low-level writing; binary

    /**********************************************************************

     */

    protected final void _writeBinary(Base64Variant b64variant, byte[] input, int inputPtr, final int inputEnd)

        throws JacksonException

    {

    {

        // Let's also reserve room for possible (and quoted) lf char each round

            }

        // And then we may have 1 or 2 leftover bytes to encode

        }

    }

    // write method when length is unknown

    protected final int _writeBinary(Base64Variant b64variant,

            InputStream data, byte[] readBuffer)

        // Let's also reserve room for possible (and quoted) LF char each round

        }

    }

    private int _readMore(InputStream in,

            byte[] readBuffer, int inputPtr, int inputEnd,

            int maxRead) throws JacksonException

        do {

            int count;

            try {

    /* Internal methods, low-level writing, other

    /**********************************************************************

     */

    private final void _writeNull() throws JacksonException

    {

    /**

     * Method called to try to either prepend character escape at front of

     * given buffer; or if not possible, to write it out directly.

     * @return Pointer to start of prepended entity (if prepended); or 'ptr'

     *   if not.

     */

    private char[] _allocateEntityBuffer()

    {

    protected void _loadMoreGuaranteed() throws JacksonException {

    protected boolean _loadMore() throws JacksonException

    {

    }

    // // // Let's override default impls for improved performance

    @Override

// !!! 16-Nov-2015, tatu: TODO: fix [databind#37], copy next location to current here

        // Also: may need to start new context?

        }

        // Ok: we must have a value... what is it?

        JsonToken t;

        /*

         * This check proceeds only if the Feature.ALLOW_MISSING_VALUES is enabled

         * The Check is for missing values. In case of missing values in an array, the next token will be either ',' or ']'.

         * so that the existing flow goes back to checking the next token which will be comma again and

         * it continues the parsing.

         */

// case ']':  // 11-May-2020, tatu: related to [core#616], this should never be reached

        case ',':

                }

            }

        }

            }

        // but let's also ensure we either get EOF, or non-alphanum char...

        implements JacksonFeature

    {

        // // // Symbol handling (interning etc)

        /**

         * Feature that determines whether JSON object property names are

         * to be canonicalized using {@link String#intern} or not:

    }

    /*

    /**********************************************************************

     * by default.

     */

    /**

     * Bitfield (set of flags) of all generator features that are enabled

     * by default.

    /**

     * Active StreamReadConstraints to use.

     */

    /*

    /**********************************************************************

    /* Capability introspection

    /**********************************************************************

     */

    /**

     * Introspection method that higher-level functionality may call

     * to see whether underlying data format requires a stable ordering

    /*

    /**********************************************************************

    /* Parser factories, convenience methods that do not specify

    /**********************************************************************

     */

     */

    public <P extends JsonParser & ByteArrayFeeder> P createNonBlockingByteArrayParser(ObjectReadContext readCtxt)

            throws JacksonException {

    }

    /**

     *

     * @param writeCtxt Object-binding context where applicable; used for providing contextual

     *    configuration

     *

     * @return Generator constructed

     *

    /*

    /**********************************************************************

    /* Generator factories, convenience methods that do not specify

    /**********************************************************************

     */

    /**

     * Method for constructing JSON generator for writing content

     * using specified output stream.

     * Note: there are formats that use fixed encoding (like most binary data formats)

     * and that ignore passed in encoding.

     *

     * @param enc Character encoding to use

     *

     * @return Generator constructed

     * Convenience method for constructing generator that uses default

     * encoding of the format (UTF-8 for JSON and most other data formats),

     *

     *

     * @return Generator constructed

     *

    public JsonGenerator createGenerator(OutputStream out) throws JacksonException {

    }

    /**

     * Method for constructing JSON generator for writing content

     * using specified Writer.

     * {@link tools.jackson.core.StreamWriteFeature#AUTO_CLOSE_TARGET} is enabled).

     * Using application needs to close it explicitly.

     *

     *

     * @return Generator constructed

     *

    /* Error reporting methods

    /**********************************************************************

     */

    protected JacksonException _wrapIOFailure(IOException e) {

    }

    protected <T> T _unsupported() {

    }

    protected <T> T _unsupported(String str, Object... args) {

    }

    /**

     * Length of the exponent part of the number, if any, not

     * Not used for  pure integer values.

     */

    protected int _expLength;

     */

    // // // Life-cycle of number-parsing

    protected final JsonToken reset(boolean negative, int intLen, int fractLen, int expLen)

    {

    }

    protected final JsonToken resetFloat(boolean negative, int intLen, int fractLen, int expLen)

    {

        // Inelegant but we know how to create StreamReadExceptions,

    }

    protected final JsonToken resetAsNaN(String valueStr, double value)

    {

            }

        }

        /* And then floating point types. Here optimal type

         * needs to be big decimal, to avoid losing any data?

         * However... using BD is slow, so let's allow returning

        }

    }

    @Override

    public int getIntValue() throws JacksonException

    {

        }

    }

    @Override

    public long getLongValue() throws JacksonException

    {

        }

    }

    @Override

    public BigInteger getBigIntegerValue()

    {

        }

    }

    @Override

    public float getFloatValue() throws JacksonException

    {

        }

    }

    @Override

    public BigDecimal getDecimalValue()

    {

        }

    protected void convertNumberToBigInteger()

    {

        }

    protected void convertNumberToDouble() throws InputCoercionException

    {

        /* 05-Aug-2008, tatus: Important note: this MUST start with

         *   value is the original one (others get generated when

         *   requested)

         */

        }

    protected void convertNumberToBigDecimal()

    {

        // 05-Aug-2008, tatus: Important note: this MUST start with more

    protected char _decodeEscaped() throws JacksonException {

    }

    protected final int _decodeBase64Escape(Base64Variant b64variant, int ch, int index)

        throws JacksonException

    {

        }

    }

    protected final int _decodeBase64Escape(Base64Variant b64variant, char ch, int index)

        throws JacksonException

    {

        }

    }

    protected <T> T _reportInvalidBase64Char(Base64Variant b64variant, int ch, int bindex)

            throws StreamReadException {

    @Override

    public void write(int c) throws IOException

    {

        }

    }

    protected static void illegalSurrogate(int code) throws IOException {

    }

    protected static String illegalSurrogateDesc(int code)

    {

 * {@link JsonPointer} and matches a single value accordingly.

 * Instances are immutable and fully thread-safe, shareable,

 * and efficient to use.

 * @since 2.6

 */

public class JsonPointerBasedFilter extends TokenFilter

    public TokenFilter filterStartArray() {

    }

    @Override

    public TokenFilter filterStartObject() {

    }

    @Override

    protected boolean _includeScalar() {

        // should only occur for root-level scalars, path "/"

     * which signals starting of an Object value.

     */

    /**

     * END_OBJECT is returned when encountering '}'

     * which signals ending of an Object value

     * has internal floating-point representation).

     */

    /**

     * VALUE_TRUE is returned when encountering literal "true" in

     * value context

     */

        ;

    final String _serialized;

    final char[] _serializedChars;

    final byte[] _serializedBytes;

    final int _id;

    final boolean _isStructStart, _isStructEnd;

    final boolean _isNumber;

            }

        }

    }

    /*

    /**********************************************************************

    /* API, accessors, mostly for Unit Tests