private boolean canParseSingleTokenLiteral(boolean embedded, String tokenLiteral) {
            int startPosition = parser.mark();
            // If the next token is what we expect, then either...
            if (parser.canConsume(tokenLiteral)) {
                //   ...we're reading an embedded value, in which case the next token will be handled appropriately
                //      by the caller if it's something like an end delimiter for a map or array, or a comma to
                //      separate multiple embedded values...
                //   ...or it's being parsed as part of a top-level string, in which case, any other tokens should
                //      cause use to stop parsing this single-token literal as such and instead just treat it like
                //      a string. For example, the top-level string "true}" will be tokenized as the tokens "true" and
                //      "}", but should ultimately be parsed as just the string "true}" instead of the boolean true.
                if (embedded || !parser.hasNext()) {
                    return true;
                }
            }
            parser.rewindTo(startPosition);
            return false;
        }
Convert the specified value with the desired floating point type.

@param value  the value to be converted; may not be null
@param schema the schema for the current value type; may not be null
@param error  any previous error that should be included in an exception message; may be null
@return the double value after conversion; never null
@throws DataException if the value could not be converted to a double
connect/api/src/main/java/org/apache/kafka/connect/data/Values.java