The Token class represents a token that has been parsed from a JSON string. It includes the start and end indices of the token within the source, as well as its type. The class provides methods for getting the string representation of the token, as well as its length and a string representation that includes its start and end indices and type. Additionally, the class includes equals and hashCode methods for comparing tokens.

JsonParserBuilder

Builder class for creating instances of JsonParser.

Please refer to JsonParserBuilder#build() for details on how the build logic is formed.

public JsonParser build() {
    if (strict()) {
        return new JsonStrictParser(objectsKeysCanBeEncoded());
    } else if (isSupportNoQuoteKeys() || isAllowHashComment() || isAllowSlashSlashComment() || isAllowSlashStarComment() || parseKey != null) {
        final ParseFunction[] funcTable = this.getFuncTable();
        funcTable[ParseConstants.STRING_START_TOKEN] = JsonParserFunctions::parseString;
        funcTable[ParseConstants.NULL_START] = JsonParserFunctions::parseNull;
        funcTable[ParseConstants.TRUE_BOOLEAN_START] = JsonParserFunctions::parseTrue;
        funcTable[ParseConstants.FALSE_BOOLEAN_START] = JsonParserFunctions::parseFalse;
        for (int i = ParseConstants.NUM_0; i < ParseConstants.NUM_9 + 1; i++) {
            funcTable[i] = JsonParserFunctions::parseNumber;
        }
        funcTable[ParseConstants.MINUS] = JsonParserFunctions::parseNumber;
        funcTable[ParseConstants.PLUS] = JsonParserFunctions::parseNumber;
        if (isAllowHashComment()) {
            funcTable['#'] = (source, tokens) -> source.findChar('\n');
        }
        if (isSupportNoQuoteKeys() && getParseKey() == null) {
            setParseKey(JsonParserFunctions::parseKeyNoQuote);
        }
        if (isAllowSlashStarComment() || isAllowSlashSlashComment()) {
            funcTable['/'] = (source, tokens) -> {
                int next = source.next();
                if (next == '/') {
                    source.findChar('\n');
                } else if (next == '*') {
                    loop: while (source.findChar('*')) {
                        switch(source.next()) {
                            case '/':
                                break loop;
                            case ParseConstants.ETX:
                                throw new UnexpectedCharacterException("Comment parse", "End of stream", source);
                        }
                    }
                }
            };
        }
        return new JsonFuncParser(objectsKeysCanBeEncoded(), Arrays.copyOf(funcTable, funcTable.length), this.getDefaultFunc(), this.getParseKey());
    } else {
        return new JsonFastParser(objectsKeysCanBeEncoded());
    }
}

The build() method in the JsonParserBuilder class is responsible for creating and returning an instance of JsonParser based on the configuration set in the builder. Here is a step-by-step description of what the method is doing:

1. If the strict() flag is set to true, a new JsonStrictParser instance is created with the objectsKeysCanBeEncoded() flag and returned.
2. If the isSupportNoQuoteKeys(), isAllowHashComment(), isAllowSlashSlashComment(), or isAllowSlashStarComment() flags are set to true, or if the parseKey is not null, additional configuration is applied to the JsonParser.
3. An array of ParseFunction called funcTable is retrieved using the getFuncTable() method.
4. The funcTable is populated with different parse functions for each token or character:
   • The STRING_START_TOKEN is mapped to JsonParserFunctions::parseString.
   • The NULL_START is mapped to JsonParserFunctions::parseNull.
   • The TRUE_BOOLEAN_START is mapped to JsonParserFunctions::parseTrue.
   • The FALSE_BOOLEAN_START is mapped to JsonParserFunctions::parseFalse.
   • The numbers from NUM_0 to NUM_9 are mapped to JsonParserFunctions::parseNumber.
   • The MINUS is mapped to JsonParserFunctions::parseNumber.
   • The PLUS is mapped to JsonParserFunctions::parseNumber.
   • If the isAllowHashComment() flag is true, the # character is mapped to a lambda function that finds the next character on a new line.
   • If the isSupportNoQuoteKeys() flag is true and the parseKey is null, the parseKeyNoQuote function is set as the parseKey in the builder.
   • If the isAllowSlashStarComment() or isAllowSlashSlashComment() flags are true, the / character is mapped to a lambda function that handles comments. If the next character is /, it finds the next character on a new line. If the next character is *, it processes the comment until it finds */.
5. Finally, if none of the above conditions are met, a new JsonFastParser instance is created with the objectsKeysCanBeEncoded() flag and returned.

The returned JsonParser instance has different behavior based on the configuration options set in the builder.

public JsonEventParser buildEventParser() {
    if (strict()) {
        return new JsonEventStrictParser(objectsKeysCanBeEncoded(), tokenEventListener());
    } else {
        return new JsonEventFastParser(objectsKeysCanBeEncoded(), tokenEventListener());
    }
}

The buildEventParser method in the JsonParserBuilder class is designed to create and return an instance of the JsonEventParser interface. Here is a step-by-step description of what the method does based on its body:

1. Check if the strict() method returns true.

   • If true, proceed to step 2.
   • If false, proceed to step 3.

2. Create a new instance of the JsonEventStrictParser class.

   • Pass the result of the objectsKeysCanBeEncoded() method as the first argument.
   • Pass the result of the tokenEventListener() method as the second argument.
   • Return the created JsonEventStrictParser instance.

3. Create a new instance of the JsonEventFastParser class.

   • Pass the result of the objectsKeysCanBeEncoded() method as the first argument.
   • Pass the result of the tokenEventListener() method as the second argument.
   • Return the created JsonEventFastParser instance.

Note that the choice between using JsonEventStrictParser and JsonEventFastParser depends on the return value of the strict() method. If strict() is true, the strict parser is used; otherwise, the fast parser is used.

The JsonParserFunctions class is a collection of functions that are utilized by the JsonFuncParser to parse JSON.

public static boolean parseKeyNoQuote(final CharSource source, final TokenList tokens) {
    int ch = source.nextSkipWhiteSpace();
    final int startIndex = source.getIndex() - 1;
    final int tokenListIndex = tokens.getIndex();
    tokens.placeHolder();
    boolean found = false;
    switch(ch) {
        case ParseConstants.STRING_START_TOKEN:
            final int strStartIndex = startIndex + 1;
            final int strEndIndex = source.findEndOfEncodedString();
            tokens.add(new Token(strStartIndex + 1, strEndIndex, TokenTypes.STRING_TOKEN));
            found = true;
            break;
        case ParseConstants.OBJECT_END_TOKEN:
            tokens.undoPlaceholder();
            return true;
        default:
            if (Character.isAlphabetic(ch)) {
                final int start = source.getIndex();
                final int end = source.findAttributeEnd();
                tokens.add(new Token(start, end, TokenTypes.STRING_TOKEN));
                found = true;
            } else {
                throw new UnexpectedCharacterException("Parsing key", "Unexpected character found", source);
            }
    }
    boolean done = source.findObjectEndOrAttributeSep();
    if (!done && found) {
        tokens.set(tokenListIndex, new Token(startIndex + 1, source.getIndex(), TokenTypes.ATTRIBUTE_KEY_TOKEN));
    } else if (found && done) {
        throw new UnexpectedCharacterException("Parsing key", "Not found", source);
    }
    return done;
}

The method parseKeyNoQuote in the JsonParserFunctions class takes two parameters: source of type CharSource and tokens of type TokenList. It returns a boolean value.

Here is a step-by-step description of what the method does based on its body:

1. It retrieves the next character from the source and skips any leading white spaces.
2. It saves the current index of the source minus 1 as startIndex.
3. It saves the current index of the tokens as tokenListIndex.
4. It adds a placeholder token to the tokens list.
5. It initializes a boolean variable found as false.
6. It enters a switch statement based on the value of the character ch.
   • If ch is equal to ParseConstants.STRING_START_TOKEN:
     • It calculates the start index of the string as strStartIndex by adding 1 to startIndex.
     • It calculates the end index of the string as strEndIndex by calling the findEndOfEncodedString method on the source object.
     • It adds a new Token object to the tokens list with the start index, end index, and type TokenTypes.STRING_TOKEN.
     • It sets found to true.
   • If ch is equal to ParseConstants.OBJECT_END_TOKEN:
     • It undoes the placeholder token added to the tokens list.
     • It returns true.
   • If ch is neither ParseConstants.STRING_START_TOKEN nor ParseConstants.OBJECT_END_TOKEN:
     • If ch is an alphabetic character:
       • It saves the current index of the source as start.
       • It finds the end index of the attribute by calling the findAttributeEnd method on the source object and saves it as end.
       • It adds a new Token object to the tokens list with the start index, end index, and type TokenTypes.STRING_TOKEN.
       • It sets found to true.
     • If ch is not an alphabetic character:
       • It throws an UnexpectedCharacterException with the message "Unexpected character found" and the source object as arguments.
7. It checks if it needs to find the end of the object or the attribute separator by calling the findObjectEndOrAttributeSep method on the source object. The result is saved in the done variable.
8. If done is false and found is true:
   • It updates the placeholder token in the tokens list with the start index as startIndex + 1 and the current index of the source as the end index, and the type TokenTypes.ATTRIBUTE_KEY_TOKEN.
9. If found is true and done is true:
   • It throws an UnexpectedCharacterException with the message "Not found" and the source object as arguments.
10. It returns the value of done.

public static boolean parseKeyWithEncode(final CharSource source, final TokenList tokens) {
    int ch = source.nextSkipWhiteSpace();
    final int startIndex = source.getIndex() - 1;
    final int tokenListIndex = tokens.getIndex();
    tokens.placeHolder();
    boolean found = false;
    switch(ch) {
        case ParseConstants.STRING_START_TOKEN:
            final int strStartIndex = startIndex + 1;
            final int strEndIndex = source.findEndOfEncodedString();
            tokens.add(new Token(strStartIndex + 1, strEndIndex, TokenTypes.STRING_TOKEN));
            found = true;
            break;
        case ParseConstants.OBJECT_END_TOKEN:
            tokens.undoPlaceholder();
            return true;
        default:
            throw new UnexpectedCharacterException("Parsing key", "Unexpected character found", source);
    }
    boolean done = source.findObjectEndOrAttributeSep();
    if (!done && found) {
        tokens.set(tokenListIndex, new Token(startIndex + 1, source.getIndex(), TokenTypes.ATTRIBUTE_KEY_TOKEN));
    } else if (found && done) {
        throw new UnexpectedCharacterException("Parsing key", "Not found", source);
    }
    return done;
}

The parseKeyWithEncode method is defined in the io.nats.jparse.parser.functable.JsonParserFunctions class. It takes two parameters: source of type CharSource and tokens of type TokenList. The method has a return type of boolean.

The purpose of this method is to parse a key while encoding it, given a character source (source) and a list of tokens (tokens).

Below is a step-by-step description of what the method does:

1. The method starts by retrieving the next character from the source, skipping any white space characters.

2. It initializes two variables: startIndex to hold the index of the character in the source minus 1 and tokenListIndex to hold the current index of the tokens list.

3. A placeholder token is added to the tokens list.

4. The method enters a switch statement based on the value of the retrieved character.

5. If the retrieved character is equal to the constant ParseConstants.STRING_START_TOKEN, the method proceeds to parse a string. It initializes two variables: strStartIndex to hold the index of the start of the string plus 1 and strEndIndex to hold the index of the end of the encoded string. A new Token object is created with the start and end indexes, and a token type of TokenTypes.STRING_TOKEN. The newly created token is added to the tokens list. The found variable is set to true.

6. If the retrieved character is equal to the constant ParseConstants.OBJECT_END_TOKEN, the method undoes the placeholder token and returns true.

7. If none of the above cases match, an UnexpectedCharacterException is thrown, indicating that an unexpected character was found while parsing the key.

8. The method then tries to find the end of the object or the attribute separator. The done variable is set to true if the end is found.

9. If done is false and found is true, the method updates the token at the tokenListIndex in the tokens list with a new Token object that has the updated start and end indexes, and a token type of TokenTypes.ATTRIBUTE_KEY_TOKEN.

10. If found is true and done is true, an UnexpectedCharacterException is thrown, indicating that the key was not found.

11. Finally, the method returns the value of the done variable.

This method is used to parse a key while encoding it, and it handles different cases based on the character read from the source. If the key is successfully parsed, the method updates the tokens list accordingly. However, if an unexpected character is encountered or the key is not found, an exception is thrown.

public static boolean parseKeyNoEncode(final CharSource source, final TokenList tokens) {
    int ch = source.nextSkipWhiteSpace();
    final int startIndex = source.getIndex() - 1;
    final int tokenListIndex = tokens.getIndex();
    tokens.placeHolder();
    boolean found = false;
    switch(ch) {
        case ParseConstants.STRING_START_TOKEN:
            final int strStartIndex = startIndex + 1;
            final int strEndIndex = source.findEndString();
            tokens.add(new Token(strStartIndex + 1, strEndIndex, TokenTypes.STRING_TOKEN));
            found = true;
            break;
        case ParseConstants.OBJECT_END_TOKEN:
            tokens.undoPlaceholder();
            return true;
        default:
            throw new UnexpectedCharacterException("Parsing key", "Unexpected character found", source);
    }
    boolean done = source.findObjectEndOrAttributeSep();
    if (!done && found) {
        tokens.set(tokenListIndex, new Token(startIndex + 1, source.getIndex(), TokenTypes.ATTRIBUTE_KEY_TOKEN));
    } else if (found && done) {
        throw new UnexpectedCharacterException("Parsing key", "Not found", source);
    }
    return done;
}

The JsonFuncParser class is an implementation of the JsonParser interface. It uses a function table to define the behavior of the parser. The function table, which is an array of ParseFunction objects, determines which function to call when parsing a specific character. The function table can be customized by subclassing this class and overriding the initFuncTable method. Additionally, the function table can be configured using the JsonParserBuilder.

private void doParse(final CharSource source, final TokenList tokens, final int ch) {
    if (ch < 256) {
        funcTable[ch].parse(source, tokens);
    } else {
        defaultFunc.parse(source, tokens);
    }
}

The method doParse defined in class io.nats.jparse.parser.functable.JsonFuncParser is a private method with the following step-by-step description:

1. Accepts three parameters: source of type CharSource, tokens of type TokenList, and ch of type int.
2. Checks if the value of ch is less than 256.
3. If ch is less than 256: a. Retrieves the appropriate parser from the funcTable array at index ch. b. Invokes the parse method on the retrieved parser, passing source and tokens as arguments.
4. If ch is not less than 256: a. Invokes the parse method on the defaultFunc, passing source and tokens as arguments.

This method essentially determines the appropriate parser to use based on the value of ch and delegates the parsing task to the selected parser using the parse method.

private void parseArray(final CharSource source, final TokenList tokens) {
    final int startSourceIndex = source.getIndex();
    final int tokenListIndex = tokens.getIndex();
    tokens.placeHolder();
    boolean done = false;
    while (!done) {
        done = parseArrayItem(source, tokens);
    }
    final Token arrayToken = new Token(startSourceIndex, source.getIndex(), TokenTypes.ARRAY_TOKEN);
    tokens.set(tokenListIndex, arrayToken);
}

The method parseArray is defined in the class io.nats.jparse.parser.functable.JsonFuncParser. It takes two parameters: source of type CharSource and tokens of type TokenList.

Here is a step-by-step description of what the method does:

1. It stores the current index of the source in a variable called startSourceIndex.
2. It also stores the current index of the tokens in a variable called tokenListIndex.
3. It inserts a placeholder token in the tokens list using the placeHolder() method.
4. It initializes a boolean variable called done to false.
5. It enters a while loop that continues until done becomes true.
6. Inside the while loop, it calls the parseArrayItem() method passing source and tokens as parameters. The parseArrayItem() method is responsible for parsing each item in the array.
7. After parseArrayItem() returns, it checks the value of done and updates it accordingly.
8. Once all the items in the array have been parsed, it creates a new Token object called arrayToken using the startSourceIndex, current index of the source, and the type TokenTypes.ARRAY_TOKEN.
9. Finally, it updates the token at tokenListIndex in the tokens list with the newly created arrayToken.

That's the step-by-step description of what the parseArray method does based on its body.

private boolean parseArrayItem(CharSource source, TokenList tokens) {
    char ch = (char) source.nextSkipWhiteSpace();
    forLoop: for (; ch != ETX; ch = (char) source.nextSkipWhiteSpace()) {
        switch(ch) {
            case ARRAY_END_TOKEN:
                source.next();
                return true;
            case ARRAY_SEP:
                source.next();
                return false;
            default:
                doParse(source, tokens, ch);
                break forLoop;
        }
    }
    if (source.getCurrentChar() == ARRAY_END_TOKEN) {
        source.next();
        return true;
    }
    return false;
}

The parseArrayItem method is defined in the JsonFuncParser class, which is located in the package io.nats.jparse.parser.functable.

This method takes two parameters:

• source of type CharSource, which represents the source of characters to parse.
• tokens of type TokenList, which represents the list of tokens that have been parsed so far.

Here is a step-by-step description of what the parseArrayItem method does based on its body:

1. Retrieve the next character from the source and assign it to the variable ch. Skip any whitespace characters.
2. Start a for loop that iterates until the character ETX (end of text) is encountered.
3. Within the for loop, check the value of ch using a switch statement.
4. If ch is equal to ARRAY_END_TOKEN (representing the end of the array), move the source to the next character and return true to indicate that the array item has been successfully parsed.
5. If ch is equal to ARRAY_SEP (representing the separator between array items), move the source to the next character and return false to indicate that more array items need to be parsed.
6. If none of the above cases match (i.e., ch is any other character), call the doParse method to further parse the item using the current character ch. Then, break out of the for loop to stop parsing the current array item and move on to the next one.
7. After the for loop ends, check if the current character in the source is equal to ARRAY_END_TOKEN.
8. If it is, move the source to the next character and return true to indicate that the array item has been successfully parsed.
9. If the current character in the source is not equal to ARRAY_END_TOKEN, return false to indicate that the array item has not been fully parsed yet.

That's the step-by-step description of what the parseArrayItem method does based on its body.

private boolean parseValue(final CharSource source, TokenList tokens) {
    int ch = source.nextSkipWhiteSpace();
    final int startIndex = source.getIndex();
    final int tokenListIndex = tokens.getIndex();
    tokens.placeHolder();
    doParse(source, tokens, ch);
    ch = source.skipWhiteSpace();
    switch(ch) {
        case OBJECT_END_TOKEN:
            if (source.getIndex() == tokenListIndex) {
                throw new UnexpectedCharacterException("Parsing Value", "Key separator before value", source);
            }
            tokens.set(tokenListIndex, new Token(startIndex, source.getIndex(), TokenTypes.ATTRIBUTE_VALUE_TOKEN));
            return true;
        case OBJECT_ATTRIBUTE_SEP:
            if (source.getIndex() == tokenListIndex) {
                throw new UnexpectedCharacterException("Parsing Value", "Key separator before value", source);
            }
            tokens.set(tokenListIndex, new Token(startIndex, source.getIndex(), TokenTypes.ATTRIBUTE_VALUE_TOKEN));
            return false;
        default:
            throw new UnexpectedCharacterException("Parsing Value", "Unexpected character", source, source.getCurrentChar());
    }
}

The parseValue method in the JsonFuncParser class is used to parse a JSON value from a given source and add it to a list of tokens. Here is a step-by-step description of the method's functionality:

1. Get the next character from the source, skipping any white spaces.
2. Store the current index of the source as the starting index of the value.
3. Store the current index of the tokens list.
4. Create a placeholder token in the tokens list to represent the parsed value. This placeholder will be replaced later with the actual value token.
5. Call the doParse method to parse the value and update the tokens list.
6. Get the next character from the source after parsing the value, skipping any white spaces.
7. Check the value of the next character using a switch statement.
8. If the next character is an object end token, check that the source index is equal to the token list index. If it is not, throw an UnexpectedCharacterException indicating that there was a key separator before the value. Otherwise, update the placeholder token in the token list with the correct start and end indexes and set its type as ATTRIBUTE_VALUE_TOKEN. Finally, return true to indicate that the parsing is successful.
9. If the next character is an object attribute separator, perform the same check as in step 8. If the check fails, throw an UnexpectedCharacterException indicating that there was a key separator before the value. Otherwise, update the placeholder token in the token list with the correct start and end indexes and set its type as ATTRIBUTE_VALUE_TOKEN. Finally, return false to indicate that the parsing is not yet complete.
10. If none of the above cases match, throw an UnexpectedCharacterException indicating that there is an unexpected character in the value, along with the current character from the source.

This method is responsible for parsing a JSON value from a source and adding it to the tokens list, while also handling different scenarios such as object end token and object attribute separator.

private void parseObject(final CharSource source, TokenList tokens) {
    final int startSourceIndex = source.getIndex();
    final int tokenListIndex = tokens.getIndex();
    tokens.placeHolder();
    boolean done = false;
    while (!done) {
        done = parseKey.parse(source, tokens);
        if (!done)
            done = parseValue(source, tokens);
    }
    source.next();
    tokens.set(tokenListIndex, new Token(startSourceIndex, source.getIndex(), TokenTypes.OBJECT_TOKEN));
}

The parseObject() method in the class io.nats.jparse.parser.functable.JsonFuncParser is responsible for parsing a JSON object. Here is a step-by-step description of what this method is doing based on its body:

1. The method begins by creating two local variables: startSourceIndex and tokenListIndex. These variables are assigned the current index of the source and tokens.

2. The tokens.placeHolder() method is called to create a placeholder token in the tokens list.

3. A boolean variable named done is declared and initialized as false. This variable is used to indicate whether the parsing of the object is complete.

4. A while loop is started with the condition !done. This loop continues until the parsing of the object is complete.

5. The parseKey.parse(source, tokens) method is called to parse a key from the source. If the parsing is successful and returns true, the value of done is set to true, indicating that the parsing of the object is complete. If the parsing of the key is not successful, the method parseValue(source, tokens) is called to parse a value.

6. Once the parsing of the object is complete, the source.next() method is called to move the index of the source to the next character.

7. The tokens.set(tokenListIndex, new Token(startSourceIndex, source.getIndex(), TokenTypes.OBJECT_TOKEN)) method is called to set the token at tokenListIndex to a new Token object representing the parsed JSON object. The startSourceIndex is the starting index of the object, and the current index of the source is the ending index of the object. The TokenTypes.OBJECT_TOKEN indicates that the token represents an object.

In summary, the parseObject() method parses a JSON object by repeatedly calling methods to parse keys and values until the entire object is parsed. It then updates the tokens list with a new token representing the parsed object.

The JsonEventFastParser class is a public class that extends the JsonEventAbstractParser. It is a fast JSON event parser.

public void parseWithEvents(CharSource source, final TokenEventListener event)

@Override
public void parseWithEvents(CharSource source, final TokenEventListener event) {
    int ch = source.nextSkipWhiteSpace();
    switch(ch) {
        case OBJECT_START_TOKEN:
            parseObject(source, event);
            break;
        case ARRAY_START_TOKEN:
            parseArray(source, event);
            break;
        case TRUE_BOOLEAN_START:
            parseTrue(source, event);
            break;
        case FALSE_BOOLEAN_START:
            parseFalse(source, event);
            break;
        case NULL_START:
            parseNull(source, event);
            break;
        case STRING_START_TOKEN:
            parseString(source, event);
            break;
        case NUM_0:
        case NUM_1:
        case NUM_2:
        case NUM_3:
        case NUM_4:
        case NUM_5:
        case NUM_6:
        case NUM_7:
        case NUM_8:
        case NUM_9:
        case MINUS:
        case PLUS:
            parseNumber(source, event);
            break;
        default:
            throw new UnexpectedCharacterException("Scanning JSON", "Unexpected character", source, (char) ch);
    }
}

The parseWithEvents method in the JsonEventFastParser class is used to parse JSON content with event callbacks. Here is a step-by-step description of what this method does:

1. It takes two parameters: source, which is a CharSource object representing the JSON content to parse, and event, which is a TokenEventListener object that will receive the parsing events.

2. The method calls source.nextSkipWhiteSpace() to read the next character from the source and skips any leading white spaces. The returned value is stored in the ch variable.

3. It enters a switch statement based on the value of ch.

4. If ch equals OBJECT_START_TOKEN, the method calls the parseObject method, passing the source and event parameters. This method is responsible for parsing JSON objects.

5. If ch equals ARRAY_START_TOKEN, the method calls the parseArray method, passing the source and event parameters. This method is responsible for parsing JSON arrays.

6. If ch equals TRUE_BOOLEAN_START, the method calls the parseTrue method, passing the source and event parameters. This method is responsible for parsing the JSON "true" boolean value.

7. If ch equals FALSE_BOOLEAN_START, the method calls the parseFalse method, passing the source and event parameters. This method is responsible for parsing the JSON "false" boolean value.

8. If ch equals NULL_START, the method calls the parseNull method, passing the source and event parameters. This method is responsible for parsing the JSON "null" value.

9. If ch equals STRING_START_TOKEN, the method calls the parseString method, passing the source and event parameters. This method is responsible for parsing JSON strings.

10. If ch equals any of the number-related characters (NUM_0, NUM_1, NUM_2, etc.), the method calls the parseNumber method, passing the source and event parameters. This method is responsible for parsing JSON numeric values.

11. If none of the above cases match, it means that an unexpected character was encountered, and the method throws an UnexpectedCharacterException, passing a message, the current source, and the unexpected character.

Overall, the parseWithEvents method determines the type of JSON value based on the first character of the input source, and then delegates the parsing to specific methods accordingly. It ensures that the appropriate parsing method is called based on the type of JSON token encountered, and if an unexpected character is encountered, it throws an exception.

The method parseWithEvents in the JsonEventFastParser class is used to parse a JSON input using an event-based approach. It takes a CharSource object representing the input source and a TokenEventListener object to handle the parsing events.

Within the method, it reads the first character from the input source and determines the type of token it represents. Based on the token, the method dispatches the parsing task to corresponding methods such as parseObject, parseArray, parseTrue, parseFalse, parseNull, parseString, or parseNumber.

If the first character does not match any of the expected JSON tokens, it throws an exception indicating an unexpected character.

Overall, this method enables parsing of JSON input using event-based parsing technique, where the parser notifies the listener about different events encountered during parsing, such as the start and end of JSON objects or arrays, the discovery of boolean values, null values, strings, or numeric values.

private void parseArray(final CharSource source, final TokenEventListener event) {
    event.start(TokenTypes.ARRAY_TOKEN, source.getIndex(), source);
    boolean done = false;
    while (!done) {
        done = parseArrayItem(source, event);
        if (!done) {
            done = source.findCommaOrEndForArray();
        }
    }
    event.end(TokenTypes.ARRAY_TOKEN, source.getIndex(), source);
}

The parseArray method in the JsonEventFastParser class is responsible for parsing JSON arrays. Here is a step-by-step breakdown of what this method does:

1. The method takes two arguments: source, which is a CharSource object representing the source of the JSON data, and event, which is a TokenEventListener object used for notifying events during parsing.

2. The method starts by calling the start method of the event object to notify the start of an array token, providing the token type, the index of the source, and the source itself.

3. A boolean variable done is initialized to false, indicating the parsing process is not yet completed.

4. The method enters a while loop that continues until the parsing is complete (indicated by done being set to true).

5. Inside the loop, the method calls the parseArrayItem method to parse each item in the array. This method is responsible for handling the inner elements of the array and returns a boolean value indicating whether the parsing for the item is complete or not.

6. If the parsing for the current item is not complete (indicated by the returned value of parseArrayItem being false), the method calls the findCommaOrEndForArray method of the source object. This method is responsible for finding the next comma separator or the end of the array in the source and returns a boolean value indicating whether the parsing for the array is complete or not.

7. The while loop continues or terminates based on the value of done. If done is true, the parsing is complete, and the loop will exit.

8. Finally, the method calls the end method of the event object to notify the end of the array token, providing the token type, the index of the source, and the source itself.

This method essentially iterates over the elements of a JSON array, calling the appropriate parsing methods and notifying the events to the TokenEventListener during the process.

The parseArray method in the JsonEventFastParser class is used to parse an array from a given input source and notify the provided TokenEventListener of the encountered array tokens.

The method starts by calling the start method of the TokenEventListener to notify the start of the array token.

Then, it enters a loop to parse each item in the array. It calls the parseArrayItem method to parse each item, and if the parsing is not yet done, it checks if there is a comma (,) or end (]) of the array.

Once the parsing is done, it calls the end method of the TokenEventListener to notify the end of the array token.

private boolean parseArrayItem(CharSource source, final TokenEventListener event) {
    char startChar = source.getCurrentChar();
    int ch = source.nextSkipWhiteSpace();
    switch(ch) {
        case OBJECT_START_TOKEN:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseObject(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case ARRAY_START_TOKEN:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseArray(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case TRUE_BOOLEAN_START:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseTrue(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case FALSE_BOOLEAN_START:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseFalse(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case NULL_START:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseNull(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case STRING_START_TOKEN:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseString(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case NUM_0:
        case NUM_1:
        case NUM_2:
        case NUM_3:
        case NUM_4:
        case NUM_5:
        case NUM_6:
        case NUM_7:
        case NUM_8:
        case NUM_9:
        case MINUS:
        case PLUS:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseNumber(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            if (source.getCurrentChar() == ARRAY_END_TOKEN || source.getCurrentChar() == ARRAY_SEP) {
                if (source.getCurrentChar() == ARRAY_END_TOKEN) {
                    source.next();
                    return true;
                }
            }
            break;
        case ARRAY_END_TOKEN:
            if (startChar == ARRAY_SEP) {
                throw new UnexpectedCharacterException("Parsing Array Item", "Trailing comma", source, (char) ch);
            }
            source.next();
            return true;
        default:
            throw new UnexpectedCharacterException("Parsing Array Item", "Unexpected character", source, (char) ch);
    }
    return false;
}

The parseArrayItem method is responsible for parsing an item within a JSON array. Here is a step-by-step description of what this method does based on its body:

1. The method takes two parameters: a CharSource object, which represents the source of characters to be parsed, and a TokenEventListener object, which handles the parsing events.

2. The method starts by getting the current character from the CharSource and storing it in the startChar variable. It then calls the nextSkipWhiteSpace method on the CharSource to get the next non-whitespace character and stores it in the ch variable.

3. The method performs a switch statement on the value of ch to determine the type of JSON value to be parsed:

   • If ch is equal to OBJECT_START_TOKEN, it means that the item is an object. The method calls the start method on the TokenEventListener to indicate the start of an array item, followed by invoking the parseObject method to parse the nested object. After parsing the object, the end method is called on the TokenEventListener to indicate the end of the array item.

   • If ch is equal to ARRAY_START_TOKEN, it means that the item is an array. The method follows the same steps as described for the object case, but calls the parseArray method instead to parse the nested array.

   • If ch is equal to TRUE_BOOLEAN_START, it means that the item is a boolean value true. The method follows the same steps as described for the object case, but calls the parseTrue method instead to parse the value true.

   • If ch is equal to FALSE_BOOLEAN_START, it means that the item is a boolean value false. The method follows the same steps as described for the object case, but calls the parseFalse method instead to parse the value false.

   • If ch is equal to NULL_START, it means that the item is a null value. The method follows the same steps as described for the object case, but calls the parseNull method instead to parse the value null.

   • If ch is equal to STRING_START_TOKEN, it means that the item is a string value. The method follows the same steps as described for the object case, but calls the parseString method instead to parse the string value.

   • If ch is one of the characters NUM_0 to NUM_9, MINUS, or PLUS, it means that the item is a numeric value. The method follows the same steps as described for the object case, but calls the parseNumber method instead to parse the numeric value. After parsing the number, it checks if the current character in the source is either the ARRAY_END_TOKEN or the ARRAY_SEP. If it's the ARRAY_END_TOKEN, it means that the array ends after this item, so the method returns true to indicate that the parsing of the array is complete. If it's the ARRAY_SEP, it means that more items are present in the array, so the method continues parsing the next item by returning false.

   • If ch is equal to ARRAY_END_TOKEN, it means that the array ends after this item. The method checks if the startChar is the ARRAY_SEP character, which indicates a trailing comma in the array. If it's a trailing comma, the method throws an UnexpectedCharacterException with a message indicating the presence of a trailing comma. Otherwise, it simply moves to the next character in the source and returns true to indicate that the parsing of the array is complete.

   • If none of the above cases match, it means that the character ch is not a valid character for an item in the JSON array. The method throws an UnexpectedCharacterException with a message indicating that an unexpected character was encountered while parsing the array item.

4. Finally, if none of the above cases match and no exception is thrown, the method returns false to indicate that the parsing of the array is not yet complete and there are more items to be parsed.

This is a general overview of the parseArrayItem method and its behavior based on the provided code snippet.

The parseArrayItem method in the JsonEventFastParser class is responsible for parsing an item within a JSON array.

It takes in a CharSource object, which represents the source of characters to be parsed, and a TokenEventListener object, which handles the events generated during parsing.

The method starts by getting the current character from the CharSource and then reads the next character after skipping any white space.

It then checks the value of the character and performs different actions based on its value. If the character indicates the start of an object, it calls the parseObject method and generates the appropriate start and end tokens for the array item. Similarly, if the character indicates the start of an array, boolean value (true/false), null value, string, or number, it calls the respective parsing methods and generates the corresponding tokens.

If the character is a digit or special character that indicates the start of a number, the method parses the number and checks if the current character is either the end of the array or a comma separator. If it is the end of the array, the method returns true to indicate that the item has been parsed successfully.

If the character is the end token of an array, the method returns true if and only if the start character of the array item is a comma separator. This is to check if there is a trailing comma after the last item in the array, which is not allowed in JSON.

If none of the above conditions are met, the method throws an exception indicating that an unexpected character was encountered.

Finally, the method returns false to indicate that the item has not been fully parsed yet.

This method is used internally by the parser to parse individual items within a JSON array.

private void parseNumber(final CharSource source, final TokenEventListener event) {
    final int startIndex = source.getIndex();
    final NumberParseResult numberParse = source.findEndOfNumber();
    final int tokenType = numberParse.wasFloat() ? TokenTypes.FLOAT_TOKEN : TokenTypes.INT_TOKEN;
    event.start(tokenType, startIndex, source);
    event.end(tokenType, numberParse.endIndex(), source);
}

The parseNumber method, which is defined in the class io.nats.jparse.parser.event.JsonEventFastParser, is responsible for parsing numbers from a given character source and notifying a token event listener about the parsed number.

Here is a step-by-step description of what the parseNumber method does:

1. It takes two parameters: source, which is the character source containing the JSON string, and event, which is the token event listener that will be notified about the parsed number.

2. It retrieves the current index of the character source using the getIndex() method and assigns it to the startIndex variable. This will be the starting index of the parsed number.

3. It calls the findEndOfNumber() method on the source object to find the end index of the number. This method scans the character source and determines the end index of the number, taking into account the decimal point and scientific notation if present. The result of this operation is stored in the numberParse variable, which is of type NumberParseResult.

4. It determines the token type based on the result of the wasFloat() method called on numberParse. If the parsed number is a float, the token type is set to TokenTypes.FLOAT_TOKEN. Otherwise, it is set to TokenTypes.INT_TOKEN.

5. It notifies the token event listener that a number token is starting by calling the start() method on event. This method takes three parameters: the token type, the startIndex, and the source object. This allows the event listener to handle the start of a number token.

6. It notifies the token event listener that a number token has ended by calling the end() method on event. This method also takes three parameters: the token type, the end index obtained from numberParse, and the source object. This allows the event listener to handle the end of a number token.

Overall, the parseNumber method scans the character source to find the end index of a number, determines its type (float or integer), and notifies the token event listener about the start and end of the number token.

The parseNumber method in the JsonEventFastParser class is responsible for parsing a number from a given CharSource and notifying the TokenEventListener about the parsed number.

Here is a breakdown of what the method does:

1. It saves the starting index of the current parsing position in the source using source.getIndex().
2. Then, it uses the findEndOfNumber() method of the source to parse the number and stores the result in numberParse.
3. Next, it determines the tokenType based on whether the parsed number was a float or an integer, using the wasFloat() method of numberParse.
4. It notifies the TokenEventListener that a new token is starting by calling its start() method with the tokenType, the startIndex, and the source.
5. Finally, it notifies the TokenEventListener that the token has ended by calling its end() method with the tokenType, the endIndex() obtained from numberParse, and the source.

In summary, the parseNumber method parses a number from the source and lets the TokenEventListener know about the token's type, starting and ending positions.

private boolean parseKey(final CharSource source, final TokenEventListener event) {
    int ch = source.nextSkipWhiteSpace();
    event.start(TokenTypes.ATTRIBUTE_KEY_TOKEN, source.getIndex(), source);
    boolean found = false;
    switch(ch) {
        case STRING_START_TOKEN:
            final int strStartIndex = source.getIndex();
            event.start(TokenTypes.STRING_TOKEN, strStartIndex + 1, source);
            final int strEndIndex;
            if (objectsKeysCanBeEncoded) {
                strEndIndex = source.findEndOfEncodedString();
            } else {
                strEndIndex = source.findEndString();
            }
            found = true;
            event.end(TokenTypes.STRING_TOKEN, strEndIndex, source);
            break;
        case OBJECT_END_TOKEN:
            return true;
        default:
            throw new UnexpectedCharacterException("Parsing key", "Unexpected character found", source);
    }
    boolean done = source.findObjectEndOrAttributeSep();
    if (!done && found) {
        event.end(TokenTypes.ATTRIBUTE_KEY_TOKEN, source.getIndex(), source);
    } else if (found && done) {
        throw new UnexpectedCharacterException("Parsing key", "Not found", source);
    }
    return done;
}

The parseKey method is defined in the JsonEventFastParser class of the io.nats.jparse.parser.event package.

Here is a step-by-step description of what the parseKey method does based on its body:

1. It takes two parameters: source of type CharSource and event of type TokenEventListener.
2. It retrieves the next character from the source while skipping any whitespace.
3. It notifies the event that a new ATTRIBUTE_KEY_TOKEN is being started, providing the index and the source.
4. It uses a switch statement to handle different cases for the retrieved character:
   • If the character is STRING_START_TOKEN, it means that a new string token is starting.
     • It notifies the event that a new STRING_TOKEN is being started, providing the index plus one (to exclude the STRING_START_TOKEN) and the source.
     • It determines the end index of the string token:
       • If objectsKeysCanBeEncoded is true, it uses the findEndOfEncodedString() method of the source to locate the end of the encoded string.
       • If objectsKeysCanBeEncoded is false, it uses the findEndString() method of the source to locate the end of the string.
     • It sets found to true to indicate that a string token has been found.
     • It notifies the event that the STRING_TOKEN is ending, providing the end index and the source.
   • If the character is OBJECT_END_TOKEN, it means that the end of the object is reached.
     • It returns true to indicate that the parsing of the key is done.
   • If none of the above cases match, it throws an UnexpectedCharacterException with a message indicating that an unexpected character is found in the key parsing, along with the source.
5. It attempts to find the end of the object or the attribute separator in the source, and assigns the result to the done variable.
6. If done is false and found is true, it notifies the event that the ATTRIBUTE_KEY_TOKEN is ending, providing the current index and the source.
7. If found is true and done is true, it throws an UnexpectedCharacterException with a message indicating that the end of the key is not found, along with the source.
8. It returns the value of done, indicating whether the parsing of the key is done or not.

The method parseKey is a part of the JsonEventFastParser class in the io.nats.jparse.parser.event package.

This method is responsible for parsing the key of a JSON attribute. It takes a CharSource object and a TokenEventListener object as parameters.

The method begins by skipping any whitespace characters in the source and then starts the attribute key token event. It then checks the next character in the source.

If the next character is a string start token, the method starts a string token event, determines the end index of the string, and sets the found flag to true. The method then ends the string token event.

If the next character is an object end token, the method returns true.

If none of the above conditions are met, the method throws an UnexpectedCharacterException with a relevant message.

Finally, the method checks if the parsing is done by finding the end of the object or the attribute separator in the source. If parsing is not yet done and the found flag is true, the method ends the attribute key token event. If parsing is done and the found flag is true, the method throws an UnexpectedCharacterException with a relevant message.

The method returns the value of the done variable, indicating whether the parsing of the key is completed or not.

private boolean parseValue(final CharSource source, final TokenEventListener event) {
    int ch = source.nextSkipWhiteSpace();
    event.start(TokenTypes.ATTRIBUTE_VALUE_TOKEN, source.getIndex(), source);
    switch(ch) {
        case OBJECT_START_TOKEN:
            parseObject(source, event);
            break;
        case ARRAY_START_TOKEN:
            parseArray(source, event);
            break;
        case TRUE_BOOLEAN_START:
            parseTrue(source, event);
            break;
        case FALSE_BOOLEAN_START:
            parseFalse(source, event);
            break;
        case NULL_START:
            parseNull(source, event);
            break;
        case STRING_START_TOKEN:
            parseString(source, event);
            break;
        case NUM_0:
        case NUM_1:
        case NUM_2:
        case NUM_3:
        case NUM_4:
        case NUM_5:
        case NUM_6:
        case NUM_7:
        case NUM_8:
        case NUM_9:
        case MINUS:
        case PLUS:
            parseNumber(source, event);
            break;
        default:
            throw new UnexpectedCharacterException("Parsing Value", "Unexpected character", source, ch);
    }
    source.skipWhiteSpace();
    switch(source.getCurrentChar()) {
        case OBJECT_END_TOKEN:
            event.end(TokenTypes.ATTRIBUTE_VALUE_TOKEN, source.getIndex(), source);
            return true;
        case OBJECT_ATTRIBUTE_SEP:
            event.end(TokenTypes.ATTRIBUTE_VALUE_TOKEN, source.getIndex(), source);
            return false;
        default:
            throw new UnexpectedCharacterException("Parsing Value", "Unexpected character", source, source.getCurrentChar());
    }
}

The parseValue method in the JsonEventFastParser class is responsible for parsing a JSON value from a given source and generating corresponding events through a TokenEventListener.

Here is a step-by-step description of what the parseValue method does based on its body:

1. The method starts by skipping any white space characters in the source and then notifies the event listener that a new attribute value token is about to be processed.

2. It reads the next character from the source and performs a switch case based on its value:

   • If the character is the start of an object ({), it calls the parseObject method to parse the object.
   • If the character is the start of an array ([), it calls the parseArray method to parse the array.
   • If the character is the start of a boolean true value (true), it calls the parseTrue method to parse the true value.
   • If the character is the start of a boolean false value (false), it calls the parseFalse method to parse the false value.
   • If the character is the start of a null value (null), it calls the parseNull method to parse the null value.
   • If the character is the start of a string ("), it calls the parseString method to parse the string.
   • If the character is a digit or a minus/plus sign (0-9, -, +), it calls the parseNumber method to parse a number.
   • If none of the above cases match, it throws an UnexpectedCharacterException with an error message.

3. After parsing the value, the method skips any remaining white space characters in the source.

4. It then performs another switch case based on the current character in the source:

   • If the character is the end of an object (}), it notifies the event listener that the attribute value token has ended and returns true.
   • If the character is the separator between object attributes (:), it notifies the event listener that the attribute value token has ended and returns false.
   • If none of the above cases match, it throws an UnexpectedCharacterException with an error message.

This method is responsible for handling the main types of JSON values (objects, arrays, booleans, null, strings, and numbers) and generating appropriate events for each value type through the event listener.

The parseValue method in the JsonEventFastParser class is responsible for parsing a JSON value from a given CharSource and notifying a TokenEventListener with the parsed value.

First, it reads the next character from the source and skips any whitespace. It then notifies the event listener that it is starting to parse an attribute value token.

Based on the type of the character read, it performs the following actions:

• If the character is the start of an object token, it invokes the parseObject method.
• If the character is the start of an array token, it invokes the parseArray method.
• If the character is the start of a true boolean token, it invokes the parseTrue method.
• If the character is the start of a false boolean token, it invokes the parseFalse method.
• If the character is the start of a null token, it invokes the parseNull method.
• If the character is the start of a string token, it invokes the parseString method.
• If the character is a digit or a symbol related to numbers, it invokes the parseNumber method.
• If none of the above cases match, it throws an exception for encountering an unexpected character.

After parsing the value and skipping any whitespace, it checks the current character of the source. If it is the end of an object token, it notifies the event listener and returns true. If it is a comma separating object attributes, it notifies the event listener and returns false. If none of these cases match, it throws an exception for encountering an unexpected character.

Overall, the parseValue method efficiently parses and validates a JSON value, handling various types such as objects, arrays, booleans, null, numbers, and strings.

private void parseObject(final CharSource source, final TokenEventListener event) {
    event.start(TokenTypes.OBJECT_TOKEN, source.getIndex(), source);
    boolean done = false;
    while (!done) {
        done = parseKey(source, event);
        if (!done)
            done = parseValue(source, event);
    }
    if (source.getCurrentChar() != OBJECT_END_TOKEN) {
        throw new UnexpectedCharacterException("Parsing Object", "Unexpected character", source, source.getCurrentCharSafe());
    }
    source.next();
    event.end(TokenTypes.OBJECT_TOKEN, source.getIndex(), source);
}

The parseObject method in the JsonEventFastParser class is used to parse a JSON object. Here's a step-by-step description of how the method works:

1. It starts by invoking the start method of the TokenEventListener with the token type OBJECT_TOKEN to indicate the beginning of parsing an object. It also provides the index and the character source.

2. It initializes a boolean variable done to false, which will be used to determine when parsing is complete.

3. It enters a while loop, which continues until done is true. This loop iteratively parses the key-value pairs within the JSON object.

4. Inside the loop, it calls the parseKey method to parse the key of the key-value pair. The parseKey method is expected to return a boolean value indicating whether the key parsing is complete.

5. If the parseKey method returns false, it means the key parsing is not yet complete, so it calls the parseValue method to parse the value of the key-value pair.

6. After parsing the key and value, it checks if the current character is the end of the object token (OBJECT_END_TOKEN). If it's not, it throws an UnexpectedCharacterException, indicating that an unexpected character was found when parsing the JSON object.

7. If the current character is the end of the object token, it moves to the next character in the source by invoking the next method.

8. Finally, it invokes the end method of the TokenEventListener with the token type OBJECT_TOKEN to indicate the end of parsing an object. It also provides the index and the character source.

This method essentially handles the parsing of a JSON object by calling helper methods to parse the key-value pairs and verifying the end of the object token.

The parseObject method in the class io.nats.jparse.parser.event.JsonEventFastParser is responsible for parsing a JSON object from a given input source.

The method starts by notifying the event listener that an object token is being parsed. It then enters a loop, where it alternates between parsing a key and parsing a value until the end of the object is reached.

After the loop, the method checks if the last character of the input source is the expected object end token. If it's not, an UnexpectedCharacterException is thrown.

Finally, the method notifies the event listener that the parsing of the object is complete.

The JsonEventAbstractParser class provides shared code for event parsers. It is an abstract class that implements the JsonEventParser and JsonParser interfaces. This class serves as a base for implementing event-based JSON parsers.

public List scan(final CharSource source)

@Override
public List<Token> scan(final CharSource source) {
    tokenList = new TokenList();
    this.parseWithEvents(source, base);
    return tokenList;
}

This method is defined in the io.nats.jparse.parser.event.JsonEventAbstractParser class.

• source: The CharSource object representing the input source to be scanned.

• List<Token>: The list of tokens generated by the scan process.

1. Create a new TokenList object to store the generated tokens.
2. Call the parseWithEvents method passing the source and base parameters, along with the current instance of the class. This method is responsible for parsing the input source and generating events based on the JSON syntax.
3. Return the populated tokenList which now contains the tokens generated during the parsing process.

The scan method is an overridden method in the JsonEventAbstractParser class. It accepts a CharSource object as a parameter and returns a list of Token objects.

Within the method, a new instance of TokenList is created. The parseWithEvents method is called with the provided source and base parameters. This method is responsible for parsing the source and generating appropriate events based on the JSON structure.

Once the parsing is completed, the tokenList, which contains the generated Token objects, is returned. The Token objects represent the different elements found in the JSON structure, such as keys, values, arrays, and objects.

The JsonEventStrictParser class is a strict JSON parser that extends the JsonEventAbstractParser class. It provides functionality for parsing JSON data in a strict manner.

public void parseWithEvents(CharSource source, final TokenEventListener event)

@Override
public void parseWithEvents(CharSource source, final TokenEventListener event) {
    int ch = source.nextSkipWhiteSpace();
    switch(ch) {
        case ParseConstants.OBJECT_START_TOKEN:
            parseObject(source, event);
            break;
        case ParseConstants.ARRAY_START_TOKEN:
            parseArray(source, event);
            break;
        case ParseConstants.TRUE_BOOLEAN_START:
            parseTrue(source, event);
            break;
        case ParseConstants.FALSE_BOOLEAN_START:
            parseFalse(source, event);
            break;
        case ParseConstants.NULL_START:
            parseNull(source, event);
            break;
        case ParseConstants.STRING_START_TOKEN:
            parseString(source, event);
            break;
        case ParseConstants.NUM_0:
        case ParseConstants.NUM_1:
        case ParseConstants.NUM_2:
        case ParseConstants.NUM_3:
        case ParseConstants.NUM_4:
        case ParseConstants.NUM_5:
        case ParseConstants.NUM_6:
        case ParseConstants.NUM_7:
        case ParseConstants.NUM_8:
        case ParseConstants.NUM_9:
        case ParseConstants.MINUS:
        case ParseConstants.PLUS:
            parseNumber(source, event);
            break;
        default:
            throw new UnexpectedCharacterException("Scanning JSON", "Unexpected character", source, (char) ch);
    }
    source.checkForJunk();
}

The parseWithEvents method in the JsonEventStrictParser class is responsible for parsing a JSON document step by step and triggering events based on the encountered tokens.

Here is a step-by-step description of what this method does:

1. It takes two parameters: source, which is the CharSource (a character source providing the JSON document), and event, which is the TokenEventListener (to handle events).

2. It reads the next character from the source and skips any leading whitespace.

3. It uses a switch statement to determine the type of token based on the read character:

   • If the token is an object start token ({), it calls the parseObject method, passing the source and event as parameters.

   • If the token is an array start token ([), it calls the parseArray method, passing the source and event as parameters.

   • If the token is a true boolean start token, it calls the parseTrue method, passing the source and event as parameters.

   • If the token is a false boolean start token, it calls the parseFalse method, passing the source and event as parameters.

   • If the token is a null start token, it calls the parseNull method, passing the source and event as parameters.

   • If the token is a string start token ("), it calls the parseString method, passing the source and event as parameters.

   • If the token is a numeric digit or a minus/plus sign, it calls the parseNumber method, passing the source and event as parameters.

   • If the token does not match any of the above cases, it throws an UnexpectedCharacterException with a descriptive error message.

4. After parsing the token, it checks for any additional junk characters in the source and throws an exception if any leftovers are found.

In summary, the parseWithEvents method reads each character from the input JSON document, identifies its type, and calls the appropriate parsing method. It also ensures that there are no unexpected characters or junk at the end of the document.

The parseWithEvents method in the JsonEventStrictParser class is used to parse a JSON input using events.

Here's what the method does:

1. It reads the next character from the input source and skips any whitespace.
2. It then checks the type of the character and performs the appropriate action:
   • If the character represents the start of an object ('{'), it calls the parseObject method.
   • If the character represents the start of an array ('['), it calls the parseArray method.
   • If the character represents the start of a true boolean value ('t'), it calls the parseTrue method.
   • If the character represents the start of a false boolean value ('f'), it calls the parseFalse method.
   • If the character represents the start of a null value ('n'), it calls the parseNull method.
   • If the character represents the start of a string ('"'), it calls the parseString method.
   • If the character represents a number (0-9, '-', '+'), or a decimal point, it calls the parseNumber method.
   • If none of the above cases match, it throws an UnexpectedCharacterException.
3. After parsing the value, it checks for any additional junk characters in the input source using the checkForJunk method.

Overall, the parseWithEvents method allows for parsing a JSON input by handling different JSON types and invoking appropriate event callbacks for each type.

private void parseArray(final CharSource source, final TokenEventListener event) {
    levelCheck(source);
    event.start(TokenTypes.ARRAY_TOKEN, source.getIndex(), source);
    boolean done = false;
    while (!done) {
        done = parseArrayItem(source, event);
        if (!done) {
            done = source.findCommaOrEndForArray();
        }
    }
    event.end(TokenTypes.ARRAY_TOKEN, source.getIndex(), source);
}

The parseArray method is a private method defined in the io.nats.jparse.parser.event.JsonEventStrictParser class. It takes two parameters: source of type CharSource and event of type TokenEventListener.

Here is a step-by-step description of what the parseArray method does based on its body:

1. It starts by calling a method called levelCheck passing the source parameter. This method performs some checks related to the level of the parsing.
2. It then calls the start method on the event parameter, passing TokenTypes.ARRAY_TOKEN, source.getIndex() (current index in the source), and source itself. This indicates the start of an array token to the TokenEventListener.
3. It initializes a boolean variable called done as false.
4. It enters a while loop that continues until done is true.
5. Inside the loop, it calls a method called parseArrayItem passing the source and event parameters. This method is responsible for parsing each item within the array.
6. After the parseArrayItem method returns, it checks if the done variable is still false.
   • If done is still false, it calls the findCommaOrEndForArray method on the source to find the next comma or end of the array.
   • If done is true, it exits the while loop.
7. After the while loop, it calls the end method on the event parameter, passing TokenTypes.ARRAY_TOKEN, source.getIndex() (current index in the source), and source itself. This indicates the end of the array token to the TokenEventListener.

In summary, the parseArray method is responsible for parsing an array from the source using the parseArrayItem method and notifying the TokenEventListener about the start and end of the array token.

The parseArray method is a private method defined in the JsonEventStrictParser class. It is responsible for parsing an array from a given CharSource while notifying an TokenEventListener about the encountered events.

Here is a breakdown of what the method does:

1. It performs a level check on the provided CharSource.
2. It notifies the TokenEventListener that the start of an array token has been encountered.
3. A loop is initiated until the parsing of the array is complete.
4. Inside the loop, it calls the parseArrayItem method to parse each item in the array. The TokenEventListener is notified about the parsed item.
5. After parsing an item, it checks if the parsing is complete by calling the findCommaOrEndForArray method on the CharSource. If a comma is found, the loop continues to parse the next item. If the end of the array is encountered, the loop is terminated.
6. Finally, it notifies the TokenEventListener that the end of the array token has been encountered, providing the index of the CharSource.

In summary, the parseArray method is responsible for parsing an array from a CharSource and notifying the TokenEventListener about the start and end of the array token, as well as each individual array item.

private boolean parseArrayItem(CharSource source, final TokenEventListener event) {
    char startChar = source.getCurrentChar();
    int ch = source.nextSkipWhiteSpace();
    switch(ch) {
        case ParseConstants.OBJECT_START_TOKEN:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseObject(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case ParseConstants.ARRAY_START_TOKEN:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseArray(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case ParseConstants.TRUE_BOOLEAN_START:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseTrue(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case ParseConstants.FALSE_BOOLEAN_START:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseFalse(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case ParseConstants.NULL_START:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseNull(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case ParseConstants.STRING_START_TOKEN:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseString(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            break;
        case ParseConstants.NUM_0:
        case ParseConstants.NUM_1:
        case ParseConstants.NUM_2:
        case ParseConstants.NUM_3:
        case ParseConstants.NUM_4:
        case ParseConstants.NUM_5:
        case ParseConstants.NUM_6:
        case ParseConstants.NUM_7:
        case ParseConstants.NUM_8:
        case ParseConstants.NUM_9:
        case ParseConstants.MINUS:
        case ParseConstants.PLUS:
            event.start(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            parseNumber(source, event);
            event.end(TokenTypes.ARRAY_ITEM_TOKEN, source.getIndex(), source);
            if (source.getCurrentChar() == ParseConstants.ARRAY_END_TOKEN || source.getCurrentChar() == ParseConstants.ARRAY_SEP) {
                if (source.getCurrentChar() == ParseConstants.ARRAY_END_TOKEN) {
                    source.next();
                    return true;
                }
            }
            break;
        case ParseConstants.ARRAY_END_TOKEN:
            if (startChar == ParseConstants.ARRAY_SEP) {
                throw new UnexpectedCharacterException("Parsing Array Item", "Trailing comma", source, (char) ch);
            }
            source.next();
            return true;
        default:
            throw new UnexpectedCharacterException("Parsing Array Item", "Unexpected character", source, (char) ch);
    }
    return false;
}

The parseArrayItem method in the JsonEventStrictParser class is responsible for parsing individual items in a JSON array. Here is a step-by-step description of what the method does:

1. The method takes two parameters: source, which is the input source containing the JSON array, and event, which is the event listener that will be notified of parsing events.

2. It starts by getting the current character from the source and storing it in the startChar variable.

3. The method then calls the nextSkipWhitespace method on the input source to skip any whitespace characters and get the next character in the source, which is stored in the ch variable.

4. The method enters a switch statement based on the value of ch.

5. If the value of ch is equal to ParseConstants.OBJECT_START_TOKEN (which represents the start of a JSON object), it notifies the event listener that an array item has started, and then calls the parseObject method to parse the JSON object. After the object is parsed, it notifies the event listener that the array item has ended.

6. If the value of ch is equal to ParseConstants.ARRAY_START_TOKEN (which represents the start of another JSON array), it follows a similar process as in step 5, but calls the parseArray method instead to parse the array.

7. If the value of ch is equal to ParseConstants.TRUE_BOOLEAN_START or ParseConstants.FALSE_BOOLEAN_START (which represent the start of a boolean value), it again follows a similar process as in step 5, but calls the parseTrue or parseFalse method respectively to parse the boolean value.

8. If the value of ch is equal to ParseConstants.NULL_START (which represents the start of a null value), it follows a similar process as in step 5, but calls the parseNull method to parse the null value.

9. If the value of ch is equal to ParseConstants.STRING_START_TOKEN (which represents the start of a string value), it follows a similar process as in step 5, but calls the parseString method to parse the string value.

10. If the value of ch is one of ParseConstants.NUM_0, ParseConstants.NUM_1, ..., ParseConstants.NUM_9, ParseConstants.MINUS, or ParseConstants.PLUS (which represent the start of a number), it again follows a similar process as in step 5, but calls the parseNumber method to parse the number value. It then checks if the current character in the source is either the end of the JSON array or a comma separator. If it is, it checks if the current character is the end of the JSON array, and if so, it returns true (indicating that the parsing of the array is complete).

11. If the value of ch is equal to ParseConstants.ARRAY_END_TOKEN, it checks if the startChar variable is equal to ParseConstants.ARRAY_SEP (which represents a trailing comma in the array). If it is, it throws an exception indicating that a trailing comma is not allowed. Otherwise, it moves to the next character in the source and returns true (indicating that the parsing of the array is complete).

12. If none of the above cases match, it throws an exception indicating that an unexpected character was encountered while parsing the array item.

13. Finally, the method returns false to indicate that the parsing of the array item is not complete.

The method parseArrayItem is used to parse an item within a JSON array. It takes a CharSource and a TokenEventListener as parameters.

First, it retrieves the current character from the CharSource and skips any whitespace characters. Then, it enters a switch statement based on the retrieved character.

• If the character indicates the start of an object ({), it invokes the parseObject method to further parse the object, and notifies the TokenEventListener of the start and end of the array item.
• If the character indicates the start of another array ([), it invokes the parseArray method to further parse the nested array, and notifies the TokenEventListener of the start and end of the array item.
• If the character indicates the start of a boolean true, it invokes the parseTrue method to parse the boolean value, and notifies the TokenEventListener of the start and end of the array item.
• If the character indicates the start of a boolean false, it invokes the parseFalse method to parse the boolean value, and notifies the TokenEventListener of the start and end of the array item.
• If the character indicates the start of a null value, it invokes the parseNull method to parse the value, and notifies the TokenEventListener of the start and end of the array item.
• If the character indicates the start of a string ("), it invokes the parseString method to parse the string value, and notifies the TokenEventListener of the start and end of the array item.
• If the character indicates the start of a number (0-9, minus sign, plus sign), it invokes the parseNumber method to parse the number value, and notifies the TokenEventListener of the start and end of the array item. It then checks if the current character is either the end of the array or a separator, and if so, it returns true to indicate that the parsing of the array item is complete.
• If the character indicates the end of the array (]), it checks if the previous character was a separator. If so, it throws an exception for a trailing comma. Otherwise, it advances to the next character and returns true to indicate the end of the parsing.

If none of the above cases match, it throws an exception for an unexpected character in the array item.

Finally, if the parsing is not complete, it returns false.

private void parseNumber(final CharSource source, final TokenEventListener event) {
    final int startIndex = source.getIndex();
    final NumberParseResult numberParse = source.findEndOfNumber();
    final int tokenType = numberParse.wasFloat() ? TokenTypes.FLOAT_TOKEN : TokenTypes.INT_TOKEN;
    event.start(tokenType, startIndex, source);
    event.end(tokenType, numberParse.endIndex(), source);
}

The parseNumber method in the JsonEventStrictParser class is responsible for parsing a number from a given character source and notifying the event listener about the parsed token.

Here is a step-by-step description of what the parseNumber method does:

1. Retrieve the current index in the character source using source.getIndex() and store it in startIndex variable.
2. Utilize the findEndOfNumber method from the CharSource class to locate the end position of the number being parsed. This method returns a NumberParseResult object, which contains information about whether the number was parsed as a float or an integer.
3. Determine the token type based on whether the number was parsed as a float or an integer. If it was a float, assign TokenTypes.FLOAT_TOKEN to the tokenType variable. Otherwise, assign TokenTypes.INT_TOKEN.
4. Notify the event listener that parsing of the number is starting by invoking event.start() method and passing the tokenType, startIndex, and the original source as arguments.
5. Notify the event listener that parsing of the number has ended by invoking event.end() method and passing the tokenType, the end index of the parsed number obtained from numberParse.endIndex(), and the original source as arguments.

Overall, the parseNumber method scans the character source for numbers, determines their types, and informs the event listener of the start and end positions of the parsed numbers using the appropriate token types.

The method parseNumber in class JsonEventStrictParser is used to parse a number from a CharSource object.

• It first gets the starting index of the number from the CharSource using source.getIndex().
• Then, it uses the findEndOfNumber method on the CharSource to determine the end of the number and obtain a NumberParseResult object.
• Based on whether the number was a float or an integer, it assigns the appropriate token type TokenTypes.FLOAT_TOKEN or TokenTypes.INT_TOKEN.
• It then calls the start and end methods on the TokenEventListener object event to notify the start and end of the number token, passing the token type, start index, end index, and the CharSource object.

private boolean parseKey(final CharSource source, final TokenEventListener event) {
    final char startChar = source.getCurrentChar();
    int ch = source.nextSkipWhiteSpace();
    event.start(TokenTypes.ATTRIBUTE_KEY_TOKEN, source.getIndex(), source);
    boolean found = false;
    switch(ch) {
        case ParseConstants.STRING_START_TOKEN:
            final int strStartIndex = source.getIndex();
            event.start(TokenTypes.STRING_TOKEN, strStartIndex + 1, source);
            final int strEndIndex;
            if (objectsKeysCanBeEncoded) {
                strEndIndex = source.findEndOfEncodedString();
            } else {
                strEndIndex = source.findEndString();
            }
            found = true;
            event.end(TokenTypes.STRING_TOKEN, strEndIndex, source);
            break;
        case ParseConstants.OBJECT_END_TOKEN:
            if (startChar == ParseConstants.OBJECT_ATTRIBUTE_SEP) {
                throw new UnexpectedCharacterException("Parsing key", "Unexpected character found", source);
            }
            return true;
        default:
            throw new UnexpectedCharacterException("Parsing key", "Unexpected character found", source);
    }
    boolean done = source.findObjectEndOrAttributeSep();
    if (!done && found) {
        event.end(TokenTypes.ATTRIBUTE_KEY_TOKEN, source.getIndex(), source);
    } else if (found && done) {
        throw new UnexpectedCharacterException("Parsing key", "Not found", source);
    }
    return done;
}

This method is defined in the JsonEventStrictParser class within the io.nats.jparse.parser.event package. It takes two parameters: a CharSource object named source and a TokenEventListener object named event. The method returns a boolean value.

• Get the starting character from the source object and store it in a local variable called startChar.

• Call the nextSkipWhiteSpace() method on the source object to move to the next non-whitespace character.
• Store the resulting character in a local variable named ch.

• Call the start() method on the event object, passing TokenTypes.ATTRIBUTE_KEY_TOKEN as the token type, the current index of the source, and the source object itself.

• Use a switch statement to check the type of the character ch.

• If ch is equal to ParseConstants.STRING_START_TOKEN:
  1. Store the current index of the source object in a local variable called strStartIndex.
  2. Call the start() method on the event object, passing TokenTypes.STRING_TOKEN as the token type, (strStartIndex + 1) as the start index, and the source object itself.
  3. Determine the end index of the string based on the value of objectsKeysCanBeEncoded.
  4. If objectsKeysCanBeEncoded is true, call the findEndOfEncodedString() method on the source object to find the end index of the string.
  5. If objectsKeysCanBeEncoded is false, call the findEndString() method on the source object to find the end index of the string.
  6. Set the found variable to true.
  7. Call the end() method on the event object, passing TokenTypes.STRING_TOKEN as the token type, the end index of the string, and the source object itself.

• If ch is equal to ParseConstants.OBJECT_END_TOKEN:
  • Check if the startChar is equal to ParseConstants.OBJECT_ATTRIBUTE_SEP.
  • If true, throw an UnexpectedCharacterException with the message "Unexpected character found" and the source object.
  • Return true.

• If none of the above cases match, throw an UnexpectedCharacterException with the message "Unexpected character found" and the source object.

• Call the findObjectEndOrAttributeSep() method on the source object and store the result in a boolean variable named done.

• If done is false and found is true, call the end() method on the event object, passing TokenTypes.ATTRIBUTE_KEY_TOKEN as the token type, the current index of the source, and the source object itself.

• If found is true and done is true, throw an UnexpectedCharacterException with the message "Not found" and the source object.

• This method returns the value of the done variable, indicating whether the parsing is done or not.

The parseKey method in the JsonEventStrictParser class is used to parse a key from a JSON input using a strict parsing approach.

Here's a step-by-step breakdown of how the method works:

1. It takes a CharSource object, which represents the source of characters to be parsed, and a TokenEventListener object, which listens to the events generated during parsing.

2. The method starts by capturing the current character of the source and reads the next character, skipping whitespace.

3. It notifies the event listener that it is starting to parse an attribute key token.

4. It evaluates the type of character read:

   • If the character is a string start token ("), it signifies the start of a string. The method then captures the starting index of the string and notifies the event listener that it is starting to parse a string token. It then identifies the end of the string, considering whether object keys can be encoded or not, and notifies the event listener that it has ended the string token.

   • If the character is an object end token (}), it checks if the start character of the key is the object attribute separator (:). If it is not, it throws an UnexpectedCharacterException indicating that an unexpected character was found while parsing the key. If it is, the method returns true, indicating that the parsing of the key is complete.

   • If none of the above conditions are met, it throws an UnexpectedCharacterException indicating that an unexpected character was found while parsing the key.

5. If the parsing is not yet complete and a valid key was found, the method attempts to find either the end of the object or the attribute separator.

6. If the parsing is not yet complete, but a valid key was found, the method notifies the event listener that it has ended the attribute key token.

7. If the parsing is complete but a valid key was found, it throws an UnexpectedCharacterException indicating that the key was not found.

8. Finally, the method returns whether the parsing is complete or not.

This method is useful for parsing individual keys from a JSON input and generating events for further processing.

private boolean parseValue(final CharSource source, final TokenEventListener event) {
    int ch = source.nextSkipWhiteSpace();
    event.start(TokenTypes.ATTRIBUTE_VALUE_TOKEN, source.getIndex(), source);
    switch(ch) {
        case ParseConstants.OBJECT_START_TOKEN:
            parseObject(source, event);
            break;
        case ParseConstants.ARRAY_START_TOKEN:
            parseArray(source, event);
            break;
        case ParseConstants.TRUE_BOOLEAN_START:
            parseTrue(source, event);
            break;
        case ParseConstants.FALSE_BOOLEAN_START:
            parseFalse(source, event);
            break;
        case ParseConstants.NULL_START:
            parseNull(source, event);
            break;
        case ParseConstants.STRING_START_TOKEN:
            parseString(source, event);
            break;
        case ParseConstants.NUM_0:
        case ParseConstants.NUM_1:
        case ParseConstants.NUM_2:
        case ParseConstants.NUM_3:
        case ParseConstants.NUM_4:
        case ParseConstants.NUM_5:
        case ParseConstants.NUM_6:
        case ParseConstants.NUM_7:
        case ParseConstants.NUM_8:
        case ParseConstants.NUM_9:
        case ParseConstants.MINUS:
        case ParseConstants.PLUS:
            parseNumber(source, event);
            break;
        default:
            throw new UnexpectedCharacterException("Parsing Value", "Unexpected character", source, ch);
    }
    source.skipWhiteSpace();
    switch(source.getCurrentChar()) {
        case ParseConstants.OBJECT_END_TOKEN:
            event.end(TokenTypes.ATTRIBUTE_VALUE_TOKEN, source.getIndex(), source);
            return true;
        case ParseConstants.OBJECT_ATTRIBUTE_SEP:
            event.end(TokenTypes.ATTRIBUTE_VALUE_TOKEN, source.getIndex(), source);
            return false;
        default:
            throw new UnexpectedCharacterException("Parsing Value", "Unexpected character", source, source.getCurrentChar());
    }
}

The parseValue method in the JsonEventStrictParser class is used to parse a single JSON value from the input source.

Here is a step-by-step description of what the method is doing based on its body:

1. The method starts by reading the next character from the input source and skipping any white space characters.

2. It then notifies the token event listener that a new attribute value token has started.

3. The method enters a switch case based on the value of the current character: a. If the current character is the start of an object ('{'), it calls the parseObject method to parse the object. b. If the current character is the start of an array ('['), it calls the parseArray method to parse the array. c. If the current character is the start of the true boolean value ('t'), it calls the parseTrue method to parse the boolean value true. d. If the current character is the start of the false boolean value ('f'), it calls the parseFalse method to parse the boolean value false. e. If the current character is the start of the null value ('n'), it calls the parseNull method to parse the null value. f. If the current character is the start of a string ('"'), it calls the parseString method to parse the string value. g. If the current character is a number or a minus or plus sign, it calls the parseNumber method to parse the numeric value. h. If none of the above cases match, it throws an UnexpectedCharacterException with an error message indicating that an unexpected character was encountered while parsing the value.

4. After parsing the value, the method skips any white space characters in the input source.

5. The method then enters another switch case based on the current character in the input source: a. If the current character is the end of an object ('}'), it notifies the token event listener that the attribute value token has ended and returns true. b. If the current character is the object attribute separator (','), it notifies the token event listener that the attribute value token has ended and returns false. c. If none of the above cases match, it throws an UnexpectedCharacterException with an error message indicating that an unexpected character was encountered while parsing the value.

In summary, the parseValue method in the JsonEventStrictParser class is responsible for parsing a single JSON value from the input source and notifying the token event listener about the start and end of the value token.

The parseValue method in the JsonEventStrictParser class is responsible for parsing a JSON value from a given source and notifying the token event listener about the parsed value.

The method starts by skipping any white space characters and then starts the parsing by identifying the type of the value based on the first character. It uses a switch statement to handle different types of values such as objects, arrays, booleans, null, strings, and numbers.

After parsing the value, it skips any remaining white space characters and checks the next character to determine the end of the value. If the next character is an object closing token (}), it notifies the token event listener and returns true. If the next character is an object attribute separator (:), it notifies the token event listener and returns false.

If the next character does not match any of the expected values, it throws an UnexpectedCharacterException with an appropriate error message.

Overall, the parseValue method is a critical part of the JSON parsing process and is responsible for parsing different types of JSON values and notifying the token event listener accordingly.

private void parseObject(final CharSource source, final TokenEventListener event) {
    levelCheck(source);
    event.start(TokenTypes.OBJECT_TOKEN, source.getIndex(), source);
    boolean done = false;
    while (!done) {
        done = parseKey(source, event);
        if (!done)
            done = parseValue(source, event);
    }
    if (source.getCurrentChar() != ParseConstants.OBJECT_END_TOKEN) {
        throw new UnexpectedCharacterException("Parsing Object", "Unexpected character", source, source.getCurrentCharSafe());
    }
    source.next();
    event.end(TokenTypes.OBJECT_TOKEN, source.getIndex(), source);
}

The method parseObject is defined in the class io.nats.jparse.parser.event.JsonEventStrictParser. It takes two parameters: source, which is of type CharSource, and event, which is of type TokenEventListener.

Here is a step-by-step description of what the method parseObject is doing:

1. It performs a level check, which is not explained in the given code snippet.
2. It starts the OBJECT_TOKEN event by calling event.start() method, passing the token type, the index of the source, and the source itself as parameters.
3. It initializes a boolean variable called done to false.
4. It enters a while loop that continues until done is true. This loop is used to parse the key-value pairs of the object.
5. Inside the loop, it calls the parseKey method passing the source and event as arguments, and assigns the returned value to done.
6. If parseKey did not parse a key successfully, it calls the parseValue method passing the source and event as arguments, and assigns the returned value to done.
7. If source.getCurrentChar() is not the OBJECT_END_TOKEN (which indicates the end of the object), it throws an UnexpectedCharacterException. The exception message states that it was parsing an object and encountered an unexpected character. It also includes the source and the current character as additional information.
8. It advances the source to the next character by calling source.next().
9. It ends the OBJECT_TOKEN event by calling event.end() method, passing the token type, the index of the source, and the source itself as parameters.

The method parseObject is responsible for parsing an object in the JSON input, iterating over its key-value pairs, and notifying the TokenEventListener about the start and end of the object.

The parseObject method is used to parse a JSON object string. It takes in a source input and a token event listener as parameters.

The method starts by performing a level check to ensure the input is valid. It then calls the event.start method to notify the listener that a JSON object token has been encountered.

A while loop is used to efficiently parse the key-value pairs within the object. Inside the loop, it first calls parseKey method to parse the key and notifies the event listener. If the key parsing is not yet done, it then calls parseValue method to parse the corresponding value and notifies the listener. This process continues until all key-value pairs have been parsed.

After the object's closing token is encountered, the method checks if it matches the expected object end token. If it doesn't, an exception is thrown. Otherwise, it calls source.next() to move the cursor to the next character and calls event.end to notify the listener that the object parsing is complete.

In summary, the parseObject method reads a JSON object string, validates its structure, parses its key-value pairs, and notifies an event listener about the start and end of the object token.

private void levelCheck(CharSource source) {
    nestLevel++;
    if (nestLevel > ParseConstants.NEST_LEVEL) {
        throw new UnexpectedCharacterException("Next level violation", "Too many levels " + nestLevel, source);
    }
}

The method levelCheck in the JsonEventStrictParser class is responsible for checking the nesting level of a JSON document. Here is a step-by-step description of what this method does:

1. It receives a CharSource object as a parameter, which represents the source of characters for parsing the JSON document.

2. The method increments the nestLevel variable by one. This variable keeps track of the current nesting level in the JSON document.

3. It checks if the nestLevel is greater than a constant value ParseConstants.NEST_LEVEL. This constant represents the maximum allowed nesting level in the JSON document.

4. If the nestLevel exceeds the maximum allowed level, the method throws an UnexpectedCharacterException with the message "Next level violation" and additional information about exceeding the allowed level.

5. If the nestLevel is within the allowed limit, the method continues execution without any further action.

Overall, the levelCheck method ensures that the nesting level of the JSON document does not exceed a certain threshold and throws an exception if the limit is violated. This check helps maintain the integrity and reliability of the parsing process.

The levelCheck method in the JsonEventStrictParser class is responsible for checking the nesting level of a JSON document.

This method increments the nestLevel variable by one, indicating that a new nested level has been encountered. If the nestLevel exceeds the maximum allowed nesting level defined in ParseConstants.NEST_LEVEL, an UnexpectedCharacterException is thrown, indicating that the JSON document has violated the maximum nesting level constraint.

The exception message includes the details of the violation, specifically mentioning the current nestLevel, and the source of the JSON document where the violation occurred.

The EmployeeDeptMain class is a public class that serves as the entry point for the employee and department management system. It provides functionality for managing employees and departments within an organization.

public static void main(String... args) {
    try {
        final String json = getJson();
        //final var engineeringEmployees = Path.atPath("departments[0].employees", json).asCollection().asArray();
        final File file = new File("./src/test/resources/json/depts.json");
        final RootNode rootNode = Json.toRootNode(Sources.fileSource(file));
        final ArrayNode engineeringEmployees = Path.atPath("departments[0].employees", rootNode).asCollection().asArray();
        final Node cindy = Path.atPath("[2]", engineeringEmployees);
        final Node cindyName = Path.atPath("[2].firstName", engineeringEmployees);
        final Node cindyId = Path.atPath(".id", cindy);
        final Node manager = Path.atPath("[2].manager", engineeringEmployees);
        System.out.println("      " + engineeringEmployees.toJsonString());
        System.out.println("      " + cindy.toJsonString());
        if (manager.asScalar().booleanValue()) {
            System.out.printf("This employee %s is a manager %s \n", cindyName, manager);
        }
        if (cindyName.asScalar().equalsString("Cindy")) {
            System.out.printf("The employee's name is  Cindy %s \n", cindyId);
        }
        if (cindyName instanceof CharSequence) {
            System.out.println("cirhyeName is a CharSequence");
        }
        if (cindyId instanceof Number) {
            System.out.println("cindyId is a Number");
        }
        if (engineeringEmployees instanceof List) {
            System.out.println("engineeringEmployees is a List " + engineeringEmployees.getClass().getName());
        }
        if (cindy instanceof Map) {
            System.out.println("cindy is a Map " + cindy.getClass().getName());
        }
        final Optional<ObjectNode> rick = engineeringEmployees.stream().map(node -> node.asCollection().asObject()).filter(objectNode -> objectNode.getString("firstName").equals("Rick")).findFirst();
        rick.ifPresent(node -> {
            System.out.println("Found  " + node);
            exploreNode(node);
        });
        final Optional<ObjectNode> rick2 = engineeringEmployees.findObjectNode(objectNode -> objectNode.getString("firstName").equals("Rick"));
        rick2.ifPresent(node -> {
            System.out.println("Found  " + node);
            exploreNode(node);
        });
        final List<Employee> employees = engineeringEmployees.mapObjectNode(on -> new Employee(on.getString("firstName"), on.getString("lastName"), on.getString("dob"), on.getBoolean("manager"), on.getInt("id"), on.getInt("managerId")));
        employees.forEach(System.out::println);
        final ArrayNode departmentsNode = Path.atPath("departments", json).asCollection().asArray();
        final List<Department> departments = departmentsNode.mapObjectNode(on -> new Department(on.getString("departmentName"), on.getArrayNode("employees").mapObjectNode(en -> new Employee(en.getString("firstName"), en.getString("lastName"), en.getString("dob"), en.getBoolean("manager"), en.getInt("id"), en.getInt("managerId")))));
        departments.forEach(System.out::println);
        parseBadJson();
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

The main method in class io.nats.jparse.examples.EmployeeDeptMain performs the following steps:

1. Calls the getJson() method to retrieve a JSON string.
2. Creates a File object pointing to the JSON file located at "./src/test/resources/json/depts.json".
3. Converts the file into a RootNode using the Json.toRootNode() method.
4. Retrieves the "employees" array from the "departments[0]" path in the RootNode and assigns it to the engineeringEmployees variable.
5. Retrieves the third object in the engineeringEmployees array and assigns it to the cindy variable.
6. Retrieves the value of the "firstName" property from the cindy node and assigns it to the cindyName variable.
7. Retrieves the value of the "id" property from the cindy node using a relative path and assigns it to the cindyId variable.
8. Retrieves the value of the "manager" property from the engineeringEmployees array at index 2 and assigns it to the manager variable.
9. Prints the engineeringEmployees array in JSON format.
10. Prints the cindy node in JSON format.
11. Checks if the manager node is a boolean value and prints a message if it is.
12. Checks if the cindyName node is equal to the string "Cindy" and prints a message if it is.
13. Checks if the cindyName node is an instance of CharSequence and prints a message if it is.
14. Checks if the cindyId node is an instance of Number and prints a message if it is.
15. Checks if the engineeringEmployees object is an instance of List and prints a message with its class name if it is.
16. Checks if the cindy object is an instance of Map and prints a message with its class name if it is.
17. Uses stream operations to find the first object in engineeringEmployees with "firstName" equal to "Rick" and assigns it to the rick optional object. If found, it prints the found node and calls exploreNode() method with the found node.
18. Uses the findObjectNode() method to find the object in engineeringEmployees with "firstName" equal to "Rick".
19. Assigns the found node to the rick2 optional object. If found, it prints the found node and calls exploreNode() method with the found node.
20. Maps each object in engineeringEmployees to an Employee object using the corresponding properties and collects them into a list.
21. Prints each Employee object in the employees list.
22. Retrieves the "departments" array from the JSON string and assigns it to the departmentsNode variable.
23. Maps each object in departmentsNode to a Department object using the corresponding properties and collects them into a list.
24. Prints each Department object in the departments list.
25. Calls the parseBadJson() method.
26. Catches any exception that occurs during the execution and prints the stack trace.

private static void parseBadJson() {
    //RootNode rootNode = toRootNode(niceJson("'hi mom"));
    //RootNode rootNode = toRootNode(niceJson("['aabc', \n  'def', \n 123f3f.9]"));
    //RootNode rootNode = toRootNode(niceJson("{'name':'rick', \n\n\n" +
    //        " 'age':19, 'height'=10}"));
}

The method parseBadJson() defined in class io.nats.jparse.examples.EmployeeDeptMain is used to parse invalid JSON input.

Here are the steps involved in this method:

1. Commented code: The method body contains multiple lines of commented code. These lines represent different variations of invalid JSON inputs.

2. RootNode object creation: The commented lines instantiate a RootNode object named rootNode. However, since these lines are commented out, they do not execute.

3. toRootNode() method: The toRootNode() method is called with an argument, niceJson(), which is used to simulate invalid JSON data. However, since these lines are commented out, the toRootNode() method is not executed.

4. niceJson() method: The niceJson() method is not defined in the given code snippet. Therefore, it is not involved in the execution of the parseBadJson() method.

In summary, the parseBadJson() method is designed to illustrate the parsing of invalid JSON inputs. However, since all the relevant code is commented out, this method does not perform any actual JSON parsing in its current state.

private static void exploreNode(ObjectNode node) {
    int id = node.getInt("id");
    String name = node.getString("firstName");
    String dob = node.getString("dob");
    boolean isManager = node.getBoolean("manager");
    int managerId = node.getInt("managerId");
    System.out.printf("%d %s %s %s %d \n", id, name, dob, isManager, managerId);
    final NumberNode idNode = node.getNumberNode("id");
    final StringNode nameNode = node.getStringNode("firstName");
    final StringNode dobNode = node.getStringNode("dob");
    final BooleanNode isManagerNode = node.getBooleanNode("manager");
    final NumberNode managerIdNode = node.getNumberNode("managerId");
    System.out.printf("%s %s %s %s %s \n", idNode, nameNode, dobNode, isManagerNode, managerIdNode);
    System.out.printf("%d %s %s %s %d \n", idNode.intValue(), nameNode.toString(), dobNode.toString(), isManagerNode.booleanValue(), managerIdNode.intValue());
}

The exploreNode method is defined in the EmployeeDeptMain class in the package io.nats.jparse.examples. Here is a step-by-step description of what the method does:

1. The method takes an ObjectNode as a parameter, which is a JSON object representing an employee's details.

2. The method extracts the values from specific fields of the JSON object using various get methods such as getInt, getString, and getBoolean. The extracted values are assigned to local variables.

3. The method prints the extracted values using System.out.printf method call in a formatted string.

4. The method then retrieves the same values again but this time using the getXNode methods, where X represents the type of each particular value (e.g., getNumberNode, getStringNode). The retrieved values are assigned to variables of respective types (NumberNode, StringNode, etc.).

5. The method prints the retrieved XNode values using System.out.printf method call in a formatted string.

6. Finally, the method prints the converted values from the XNode variables to their primitive types (e.g., intValue, toString, booleanValue) using System.out.printf method call in a formatted string.

The Department class is a final Class that represents a department in an organization. It provides functionality to manage and manipulate department related information.

The CloudEventMain class is a public class that serves as the entry point for processing cloud events. It contains the main method that initializes and runs the cloud event processing logic.

public static void main(String... args) {
    final File file = new File("./src/test/resources/cloudevents/glossaryEvent.json");
    final ObjectNode objectNode = Json.toRootNode(Sources.fileSource(file)).asObject();
    if (objectNode.getNode("subject").equalsContent("glossaryFeed")) {
        final String id = objectNode.getString("id");
        final String type = objectNode.getString("type");
        final String data = Json.serializeToString(objectNode.getNode("data"));
        System.out.printf("%s %s %s \n%s\n", "glossaryFeed", id, type, data);
    }
}

The main method in the CloudEventMain class is performing the following steps based on its body:

1. It defines a File object with the file path "./src/test/resources/cloudevents/glossaryEvent.json".

2. It uses the Sources.fileSource method to read the contents of the file and converts it to an ObjectNode using the Json.toRootNode method.

3. It checks if the value of the "subject" field in the objectNode is equal to "glossaryFeed" using the equalsContent method.

4. If the condition in step 3 is true, it retrieves the values of the "id", "type", and "data" fields from the objectNode.

5. It serializes the value of the "data" field to a JSON string using the Json.serializeToString method.

6. It prints the values of "glossaryFeed", "id", "type", and "data" to the console using the System.out.printf method. The values are formatted in the following format: "glossaryFeed id type data".

Please note that the actual execution of the code may have additional steps or error handling that is not mentioned in the provided code snippet.

The Employee class is a final class that represents an employee. It provides various methods and attributes to manage and retrieve information about an employee.

The Validation class is a public class used for implementing validation logic in software applications. It provides methods and functionality to validate various types of input data or user inputs. This class serves as a utility for performing validation checks and returning appropriate results or error messages.

public static void main(String... args) {
    try {
        final File file = new File("./src/test/resources/validation/");
        System.out.println("Event Strict Parser");
        final boolean showPass = false;
        final boolean showFail = false;
        validateParser(file, (JsonParser) Json.builder().setStrict(true).buildEventParser(), showFail, showPass);
        System.out.println("Strict Parser");
        final JsonParser jsonParser = Json.builder().setStrict(true).build();
        validateParser(file, jsonParser, showFail, showPass);
    } catch (Throwable ex) {
        ex.printStackTrace();
    }
}

The main method defined in the io.nats.jparse.Validation class performs the following steps:

1. It begins by trying to execute the code within a try block.

2. It creates a new File object and assigns it the path "./src/test/resources/validation/".

3. It prints the message "Event Strict Parser" to the console.

4. It initializes two boolean variables, showPass and showFail, and assigns each a value of false.

5. It calls the validateParser method with the file object and a JsonParser object created using the Json.builder() method. The JsonParser is configured to use strict parsing. The showFail and showPass variables are also passed to the validateParser method.

6. It prints the message "Strict Parser" to the console.

7. It creates a new JsonParser object by calling the Json.builder() method again and configuring it to use strict parsing.

8. It calls the validateParser method again with the file object, the newly created JsonParser, and the showFail and showPass variables.

9. If any exception or error occurs during the execution of the try block, it is caught by the catch block.

10. If an exception or error is caught, it is printed to the console using the printStackTrace method.

private static void validateParser(File file, JsonParser jsonParser, boolean showFail, boolean showPass) {
    int[] result1 = validate(file, "y_", showFail, showPass, jsonParser);
    int[] result2 = validate(file, "i_", showFail, showPass, jsonParser);
    int[] result3 = validate(file, "n_", showFail, showPass, jsonParser);
    System.out.printf("Passed Mandatory %d Failed %d \n", result1[0], result1[1]);
    System.out.printf("Passed Optional %d Failed %d \n", result2[0], result2[1]);
    System.out.printf("Passed Garbage %d Failed %d \n", result3[0], result3[1]);
}

The method validateParser is defined in the class io.nats.jparse.Validation. It takes four parameters: file, jsonParser, showFail, and showPass.

The method has the following steps:

1. It calls the validate method with the parameters file, "y_", showFail, showPass, and jsonParser. The result is stored in an integer array result1.
2. It calls the validate method again with the parameters file, "i_", showFail, showPass, and jsonParser. The result is stored in an integer array result2.
3. It calls the validate method once more with the parameters file, "n_", showFail, showPass, and jsonParser. The result is stored in an integer array result3.
4. It prints the number of passed and failed validations for the "Mandatory" category using the values in result1.
5. It prints the number of passed and failed validations for the "Optional" category using the values in result2.
6. It prints the number of passed and failed validations for the "Garbage" category using the values in result3.

The output will be in the following format:

Passed Mandatory <number of passed validations> Failed <number of failed validations>
Passed Optional <number of passed validations> Failed <number of failed validations>
Passed Garbage <number of passed validations> Failed <number of failed validations>

Please note that the actual values for the number of passed and failed validations will depend on the implementation of the validate method.

private static int[] validate(File file, String match, boolean showFail, boolean showPass, JsonParser jsonParser) {
    try {
        int pass = 0;
        int error = 0;
        for (File listFile : file.listFiles()) {
            if (listFile.getName().startsWith(match)) {
                final CharSource cs = Sources.fileSource(listFile);
                final String jsonString = cs.toString();
                //System.out.println("TESTING " + listFile);
                try {
                    RootNode root = jsonParser.parse(jsonString);
                    if (showPass) {
                        System.out.println("PASS! " + listFile);
                        System.out.println(cs);
                        System.out.println();
                    }
                    pass++;
                } catch (Exception ex) {
                    //ex.printStackTrace();
                    if (showFail) {
                        System.out.println("FAIL! " + listFile);
                        System.out.println(cs);
                        System.out.println();
                    }
                    error++;
                }
            }
        }
        return new int[] { pass, error };
    } catch (Throwable ex) {
        ex.printStackTrace();
    }
    return new int[] { -1, -1 };
}

The validate method is a static method defined in the io.nats.jparse.Validation class. Here is a step-by-step description of what the method does:

1. It takes the following parameters as input:

   • file: A File object representing a directory containing files to validate.
   • match: A String used to match filenames in the directory.
   • showFail: A boolean indicating whether to show failure messages.
   • showPass: A boolean indicating whether to show success messages.
   • jsonParser: A JsonParser object used to parse the JSON data.

2. The method starts by initializing two variables: pass and error to keep track of the number of successful and failed validations, respectively.

3. It then iterates over each File object in the directory using an enhanced for loop.

4. Inside the loop, it checks if the filename of the current File object starts with the match string.

5. If the filename matches, it creates a CharSource object using the listFile and reads its content into a String variable jsonString.

6. It then tries to parse the jsonString using the provided jsonParser object.

7. If the parsing is successful, it increments the pass variable.

8. If the showPass flag is true, it prints a success message along with the listFile and CharSource objects.

9. If the parsing fails and an exception is thrown, it increments the error variable.

10. If the showFail flag is true, it prints a failure message along with the listFile and CharSource objects.

11. After iterating through all the files in the directory, the method returns an int array containing the number of successful and failed validations.

12. If any Throwable is caught during the execution of the method, it prints the stack trace of the exception.

13. If any exception or error occurs during the execution of the method, it returns an int array with -1 for both the successful and failed validations.

That's a step-by-step description of what the validate method does based on its provided body.

The TestKeyLookUp class is a public class that provides functionality for looking up test keys.

void testStringKey()

@Test
void testStringKey() {
    final JsonParser parser = Json.builder().build();
    final String json1 = "'1'";
    final String json2 = "{'1':{'2':1}}";
    final Node key = getJsonRoot(parser, json1).getNode();
    final ObjectNode map = getJsonRoot(parser, json2).getObjectNode();
    final Optional<Node> value = map.getNode(key);
    assertTrue(value.isPresent());
    final Node innerMap = value.get();
    assertTrue(innerMap instanceof ObjectNode);
    final ObjectNode innerObject = (ObjectNode) innerMap;
    final long v = innerObject.getLong("2");
    assertEquals(1, v);
}

The testStringKey method in the io.nats.jparse.TestKeyLookUp class is a unit test for the StringKey functionality. Here is a step-by-step description of what this method is doing:

1. Creating a new instance of the JsonParser by calling Json.builder().build().
2. Defining two String variables, json1 and json2, containing the JSON strings "'1'" and "{'1':{'2':1}}" respectively.
3. Calling the getJsonRoot method, passing the JsonParser and json1 as arguments, to obtain the root node of the JSON from json1. Storing the result in a Node variable called key.
4. Calling the getJsonRoot method again, passing the JsonParser and json2 as arguments, to obtain the root node of the JSON from json2. Storing the result in a ObjectNode variable called map.
5. Calling the getNode method on the map object, passing the key as the argument, to retrieve the value associated with the given key. Storing the result in an Optional<Node> variable called value.
6. Asserting that value is present (i.e., not null).
7. Calling the get method on value to retrieve the actual Node object. Storing the result in a Node variable called innerMap.
8. Asserting that innerMap is an instance of ObjectNode.
9. Casting innerMap to ObjectNode and storing the result in an ObjectNode variable called innerObject.
10. Calling the getLong method on innerObject, passing "2" as the argument, to retrieve the value associated with the key "2". Storing the result in a long variable called v.
11. Asserting that the value of v is equal to 1.

The Json class provides static utility methods for working with JSON data. It includes methods for parsing JSON data into various data structures, converting data structures to JSON, and scanning JSON data for tokens.

public static String niceJson(String json) {
    char[] chars = json.toCharArray();
    StringBuilder sb = new StringBuilder(chars.length);
    for (char c : chars) {
        if (c == '\'') {
            sb.append('"');
        } else if (c == '`') {
            sb.append('\\');
        } else {
            sb.append(c);
        }
    }
    return sb.toString();
}
```## Path

The `Path` class provides utility methods for working with JSON paths. It includes methods for parsing JSON paths, looking up nodes at specified paths, and converting paths to `PathNode` objects. This class is used in conjunction with other classes such as `Node`, `Json`, and `PathNode` to manipulate and traverse JSON data.
### public static Node atPath(final PathNode path, final Node rootNode) 
```java
public static Node atPath(final PathNode path, final Node rootNode) {
    Iterator<PathElement> iterator = path.iterator();
    Node node = rootNode;
    PathElement pathElement = null;
    try {
        while (iterator.hasNext()) {
            pathElement = iterator.next();
            switch(node.type()) {
                case OBJECT:
                    final ObjectNode objectNode = (ObjectNode) node;
                    final CharSequence key = pathElement.asKey().toCharSequence();
                    node = objectNode.getNode(key);
                    break;
                case ARRAY:
                    final ArrayNode arrayNode = (ArrayNode) node;
                    node = arrayNode.getNodeAt(pathElement.asIndex().intValue());
                    break;
                default:
                    if (node.isCollection()) {
                        node = node.asCollection().getNode(pathElement.asKey().toCharSequence());
                    } else {
                        throw new PathException("Looking up Path", "Path not found at " + path + " path element key " + pathElement.asKey().toString(), node.charSource(), node.rootElementToken().startIndex);
                    }
            }
        }
    } catch (Exception ex) {
        throw new IllegalStateException("Path not found at " + path + " path element index " + pathElement.value());
    }
    return node;
}

The atPath method is a static method defined in the Path class in the io.nats.jparse package. This method is used to navigate and retrieve a specific node in a JSON structure based on a given path.

public static Node atPath(final PathNode path, final Node rootNode)

• path (type: PathNode): The path to be followed to retrieve the desired node.
• rootNode (type: Node): The root node of the JSON structure from which the desired node is to be retrieved.

• Node: The node found at the given path.

• The method starts by obtaining an iterator for the given path.
• It then initializes the node variable with the rootNode parameter.
• A pathElement variable is also initialized to null.

The method then enters a try-catch block, where the main logic of the method is described:

• Inside a while loop, the method checks if there are more elements in the path using the iterator's hasNext() method.
• If there are more elements, it retrieves the next path element using the iterator's next() method and assigns it to the pathElement variable.
• Based on the type of the current node, the method follows one of the three cases:
  • If the node is of type OBJECT, it casts the node to an ObjectNode, retrieves the key from the path element, and uses it to get the corresponding node from the object using the getNode(key) method. This new node is assigned to the node variable.
  • If the node is of type ARRAY, it casts the node to an ArrayNode and retrieves the node at the index specified by the path element using the getNodeAt(index) method. This new node is assigned to the node variable.
  • If none of the above cases match, it checks if the node is a collection using the isCollection() method. If it is, it retrieves the node based on the path element's key using the getNode(key) method. Otherwise, it throws a PathException indicating that the path was not found.
• The while loop continues until all elements in the path have been processed.

If there is any exception thrown during the execution of the while loop, it is caught in the catch block:

• The catch block throws an IllegalStateException indicating that the path was not found based on the path and pathElement parameters.

Finally, the method returns the node found at the given path.

Note: The specific implementation details of the Node and PathNode classes are not provided in this code snippet. The behavior of the method may vary depending on the actual implementation of these classes.

The BenchMark class is annotated with @State(value = Scope.Benchmark), which signifies that it represents a state object for benchmarking purposes. This class is intended to be used in benchmarking scenarios, providing a state for measuring the performance of methods or code snippets.

public static void main(String... args) throws Exception {
    try {
        JsonParser fastParser = Json.builder().setStrict(false).build();
        fastParser.parse(doublesJsonData).asArray().getDoubleArray();
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    System.out.println("DONE");
    //
    //        try {
    //            long startTime = System.currentTimeMillis();
    //
    //            JsonParser fastParser = Json.builder().setStrict(false).build();
    //
    //            for (int i = 0; i < 10_500_000; i++) {
    //
    //                final ObjectNode objectNode = fastParser.parse(glossaryEvent).asObject();
    //                if (objectNode.getNode("subject").equalsContent("glossaryFeed")) {
    //                    final String id = objectNode.getStringNode("id").toUnencodedString();
    //                    final String type = objectNode.getStringNode("type").toUnencodedString();
    //                    final String description = objectNode.getStringNode("description").toUnencodedString();
    //                    final String data = Json.serializeToString(objectNode.getNode("data"));
    //
    //                    if (i % 1_000_000 == 0) {
    //                        System.out.printf("Elapsed time %s %s \n", ((System.currentTimeMillis() - startTime) / 1000.0), data);
    //                    }
    //                }
    //
    //                final JsonIterator iter = JsonIterator.parse(glossaryEvent);
    //                final Map<String, Object> map = iter.read(mapTypeRefJI);
    //                if (map.get("subject").equals("glossaryFeed")) {
    //                    final String id =  (String) map.get("id");
    //                    final String type = (String) map.get("type");
    //                    final String description = (String) map.get("description");
    //                    final String data = JsonStream.serialize(map.get("data"));
    //                    if (i % 1_000_000 == 0) {
    //                        System.out.printf("Elapsed time %s %s \n", ((System.currentTimeMillis() - startTime) / 1000.0), data);
    //                    }
    //                }
    //                final HashMap<String, Object> map = mapper.readValue(glossaryEvent, mapTypeRef);
    //                if (map.get("subject").equals("glossaryFeed")) {
    //                    final String id =  (String) map.get("id");
    //                    final String type = (String) map.get("type");
    //                    final String description = (String) map.get("description");
    //                    final String data = mapper.writeValueAsString(map.get("data"));
    //                }
    //
    //
    //            }
    //            System.out.println("Total Elapsed time " + ((System.currentTimeMillis() - startTime) / 1000.0));
    //
    //        } catch (Exception ex) {
    //            ex.printStackTrace();
    //        }
}

The main method in class io.nats.jparse.BenchMark is divided into multiple sections, each performing a different task. Let's break it down step by step:

1. The method begins with a try-catch block to handle any exceptions that may occur during execution.

2. Inside the try block, a JsonParser object named fastParser is created using the Json.builder() method. The setStrict(false) method is called to configure the parser to be non-strict.

3. The fastParser object then parses the JSON data stored in the doublesJsonData variable. The parsed data is treated as an array and the getDoubleArray() method is called to retrieve an array of doubles.

4. If an exception occurs during parsing, it is caught in the catch block and the stack trace is printed.

5. After the catch block, the string "DONE" is printed to the console.

6. The code is then commented out, starting from try { long startTime = System.currentTimeMillis(); and ending with System.out.println("Total Elapsed time " + ((System.currentTimeMillis() - startTime) / 1000.0)); }.

7. In the commented out code, a startTime variable is initialized with the current system time.

8. Inside a loop that iterates 10,500,000 times, the following actions are performed:

   a. The glossaryEvent is parsed by the fastParser object and the result is treated as an ObjectNode.

   b. If the "subject" field of the objectNode is equal to "glossaryFeed", the following fields are extracted from the objectNode: "id", "type", "description" and "data". The data field is serialized as a string using Json.serializeToString() method.

   c. If the loop index i is a multiple of 1,000,000, the elapsed time since startTime is printed to the console along with the serialized data.

   d. The glossaryEvent is parsed by JsonIterator and the result is stored in a Map<String, Object>.

   e. If the "subject" field of the map is equal to "glossaryFeed", the following fields are extracted: "id", "type", "description" and "data". The data field is serialized as a string using JsonStream.serialize() method.

   f. If the loop index i is a multiple of 1,000,000, the elapsed time since startTime is printed to the console along with the serialized data.

   g. The glossaryEvent is deserialized into a HashMap<String, Object> using an unspecified mapper object and mapTypeRef.

   h. If the "subject" field of the map is equal to "glossaryFeed", the following fields are extracted: "id", "type", "description" and "data". The data field is serialized as a string using mapper.writeValueAsString() method.

9. Finally, the total elapsed time since startTime is calculated and printed to the console.

10. If an exception occurs during execution, it is caught in the catch block and the stack trace is printed.

This is the step-by-step description of the main method based on its body.

// @Benchmark // public void cloudEventJsonIter(Blackhole bh) throws Exception

//
//    @Benchmark
//    public void cloudEventJsonIter(Blackhole bh) throws Exception{
//        final JsonIterator iter = JsonIterator.parse(glossaryEvent);
//        final Map<String, Object> map = iter.read(mapTypeRefJI);
//        if (map.get("subject").equals("glossaryFeed")) {
//                final String id =  (String) map.get("id");
//                final String type = (String) map.get("type");
//                final String description = (String) map.get("description");
//                final String data = JsonStream.serialize(map.get("data"));
//                bh.consume(new Object[]{id, type, data, description});
//        }
//    }
//
//    @Benchmark
//    public void cloudEventJackson(Blackhole bh) throws JsonProcessingException {
//        final HashMap<String, Object> map = mapper.readValue(glossaryEvent, mapTypeRef);
//        if (map.get("subject").equals("glossaryFeed")) {
//            final String id =  (String) map.get("id");
//            final String type = (String) map.get("type");
//            final String description = (String) map.get("description");
//            final String data = mapper.writeValueAsString(map.get("data"));
//            bh.consume(new Object[]{id, type, data, description});
//        }
//    }
//
//    @Benchmark
//    public void cloudEventJParse(Blackhole bh) throws JsonProcessingException {
//        final ObjectNode objectNode = fastParser.parse(glossaryEvent).asObject();
//        if (objectNode.getNode("subject").equalsContent("glossaryFeed")) {
//            final String id = objectNode.getStringNode("id").toUnencodedString();
//            final String type = objectNode.getStringNode("type").toUnencodedString();
//            final String description = objectNode.getStringNode("description").toUnencodedString();
//            final String data = Json.serializeToString(objectNode.getNode("data"));
//            bh.consume(new Object[]{id, type, data, description});
//        }
//    }
//
@Benchmark
public void jParseFastFloatArray(Blackhole bh) {
    bh.consume(this.fastParser.parse(doublesJsonData).asArray().getFloatArray());
}

The method jParseFastFloatArray is a benchmark method defined in the class io.nats.jparse.BenchMark. It is used to compare the performance of parsing a JSON array of floating-point numbers using a specific parser called fastParser.

Here is a step-by-step description of what the method is doing:

1. It takes a parameter bh of type Blackhole. This is an object provided by the benchmark framework that can be used to consume the result of the benchmark, preventing the compiler from optimizing away the benchmarked code.

2. The method executes the following code:

bh.consume(this.fastParser.parse(doublesJsonData).asArray().getFloatArray());

a. The `fastParser` parses the `doublesJsonData`, which is a JSON array of floating-point numbers.
b. The parsed result is treated as an array using the `asArray()` method.
c. The `getFloatArray()` method is called on the parsed array to get an array of floating-point numbers.
d. The result of `getFloatArray()` is consumed by the `Blackhole` object, ensuring that the benchmarked code is not optimized away.

3. The method does not return any value.

Overall, the jParseFastFloatArray method benchmarks the parsing performance of the fastParser for a JSON array of floating-point numbers and consumes the result using the Blackhole object.

The CharArrayOffsetCharSource class is a concrete implementation of the CharSource abstract class and the ParseConstants interface. It represents a character source backed by a character array, where the starting position of the character sequence is indicated by an offset. This class provides methods for parsing integer, long, float, and double values from the character sequence. It also includes a validation method to check if a substring represents a valid integer. Additionally, it implements an errorDetails method that generates a detailed error message based on the current character being processed and the current parsing state.

public static String debugCharDescription(int c) {
    String charString;
    if (c == ' ') {
        charString = "[SPACE]";
    } else if (c == '\t') {
        charString = "[TAB]";
    } else if (c == '\n') {
        charString = "[NEWLINE]";
    } else if (c == ETX) {
        charString = "ETX";
    } else {
        charString = "'" + (char) c + "'";
    }
    charString = charString + " with an int value of " + c;
    return charString;
}

The debugCharDescription method in the CharArrayOffsetCharSource class is responsible for providing a textual description of a given character based on its ASCII value.

Here is the step-by-step description of what this method does:

1. The method takes an integer value c as input.
2. It initializes a variable called charString to hold the description of the character.
3. It checks if the input character c is equal to a space character. If true, it sets charString to the string "[SPACE]".
4. If the input character c is a tab character, it sets charString to the string "[TAB]".
5. If the input character c is a newline character, it sets charString to the string "[NEWLINE]".
6. If c is equal to a special character identified as ETX, it sets charString to the string "ETX".
7. If the character c does not match any of the above conditions, it appends the character to charString by converting the ASCII value of c to a character using (char) c. For example, if c is 65, the character 'A' will be appended as "'A'".
8. Finally, the method appends " with an int value of " and the value of c to the current value of charString.
9. The method returns the final value of charString, which represents the description of the character based on its ASCII value.

public int next()

@Override
public int next() {
    if (index + 1 >= sourceEndIndex) {
        index = sourceEndIndex;
        return ETX;
    }
    return data[++index];
}

This method is overridden from the parent class to provide the functionality of iterating over the characters in the underlying char array source.

1. Check if the current index (index) incremented by 1 is greater than or equal to the end index of the source array (sourceEndIndex).
   • If true, set index to sourceEndIndex and return the ETX constant, which indicates the end of the stream.
2. Otherwise, increment index by 1 and return the character at the updated index in the data array.

Note: The data array is the char array source, and index is a variable that keeps track of the current position in the array. The ETX constant represents the end of the stream.

public int findAttributeEnd()

@Override
public int findAttributeEnd() {
    int index = this.index;
    final char[] data = this.data;
    final int end = this.sourceEndIndex;
    loop: for (; index < end; index++) {
        char ch = data[index];
        switch(ch) {
            case NEW_LINE_WS:
            case CARRIAGE_RETURN_WS:
            case TAB_WS:
            case SPACE_WS:
            case ATTRIBUTE_SEP:
                this.index = index;
                break loop;
        }
    }
    return index;
}

The findAttributeEnd method is defined in the CharArrayOffsetCharSource class and is used to find the end index of an attribute. Here is a step-by-step description of how the method works:

1. The method overrides the findAttributeEnd method defined in the parent class.

2. It initializes the local variable index with the value of the instance variable this.index. This variable represents the current index position in the character array.

3. It creates a local variable data and assigns it the value of the instance variable this.data. This variable represents the character array from which the attribute is being extracted.

4. It creates a local variable end and assigns it the value of the instance variable this.sourceEndIndex. This variable represents the end index of the character array.

5. It enters a loop that iterates from the current index position (index) to the end index (end) of the character array.

6. Within each iteration of the loop, it retrieves the character at the current index position (index) from the character array and assigns it to the variable ch.

7. It checks the value of ch using a switch statement.

8. If ch matches any of the case values NEW_LINE_WS, CARRIAGE_RETURN_WS, TAB_WS, SPACE_WS, or ATTRIBUTE_SEP, it updates the instance variable this.index with the value of index and breaks out of the loop labeled loop.

9. After the loop ends, it returns the value of index, which represents the end index of the attribute.

In summary, the findAttributeEnd method iterates through a character array starting from the current index position and looks for specific characters that indicate the end of an attribute. Once a matching character is found, it updates the instance variable this.index and returns the end index.

public boolean findChar(char c)

@Override
public boolean findChar(char c) {
    int index = this.index;
    final char[] data = this.data;
    final int end = sourceEndIndex;
    for (; index < end; index++) {
        if (data[index] == c) {
            this.index = index;
            return true;
        }
    }
    return false;
}

The findChar method is used to search for a specific character within a character array. Here is a step-by-step description of what the method does:

1. The method receives a character c as a parameter.
2. It assigns the current index of the CharArrayOffsetCharSource object to the local variable index.
3. It retrieves the character array data from the CharArrayOffsetCharSource object.
4. It retrieves the end index of the source from the CharArrayOffsetCharSource object and assigns it to the local variable end.
5. It starts a loop that iterates from the current index index until the end index end.
6. Within each iteration, it checks if the character at position index within the data array is equal to the character c.
7. If a match is found, it updates the current index of the CharArrayOffsetCharSource object to the value of index and returns true.
8. If no match is found after iterating through the entire array, it simply returns false.
9. The method is marked as @Override, indicating that it overrides a method from a superclass or interface.

Overall, the findChar method performs a linear search for a specific character c within the character array data. It updates the current index of the CharArrayOffsetCharSource object if a match is found and returns true. Otherwise, it returns false indicating that the character was not found.

public void checkForJunk()

@Override
public void checkForJunk() {
    int index = this.index;
    final char[] data = this.data;
    final int end = this.sourceEndIndex;
    int ch = ETX;
    for (; index < end; index++) {
        ch = data[index];
        switch(ch) {
            case NEW_LINE_WS:
            case CARRIAGE_RETURN_WS:
            case TAB_WS:
            case SPACE_WS:
                continue;
            default:
                throw new UnexpectedCharacterException("Junk", "Unexpected extra characters", this);
        }
    }
}

The checkForJunk method, defined in the io.nats.jparse.source.CharArrayOffsetCharSource class, is used to check for any junk characters in the provided character array.

Here is a step-by-step description of what the method does:

1. It starts by initializing variables: index with the current index position in the character array, data with the provided character array, end with the end index of the character array, and ch with the ASCII value of ETX (End-of-Text).

2. It enters a for loop that iterates from the current index to the end index of the character array.

3. Inside the loop, it assigns the value of data[index] to ch, which represents the current character being checked.

4. It uses a switch statement to check the value of ch against predefined cases. The cases being checked are:

   a) NEW_LINE_WS: Represents a new line whitespace character. b) CARRIAGE_RETURN_WS: Represents a carriage return whitespace character. c) TAB_WS: Represents a tab whitespace character. d) SPACE_WS: Represents a space whitespace character.

   If ch matches any of the above cases, the loop continues to the next iteration without executing any further code. This means that if the current character is a whitespace character, it is considered valid and not classified as junk.

5. If the value of ch does not match any of the cases above, it means that an unexpected character (considered as junk) has been encountered in the character array. In this case, an UnexpectedCharacterException is thrown with the message "Junk" and "Unexpected extra characters". The this reference, representing the current instance of the CharArrayOffsetCharSource class, is passed as an argument to the exception.

6. The for loop continues to the next iteration, and steps 3-5 are repeated until all characters in the character array have been checked.

By the end of the method, if no UnexpectedCharacterException is thrown, it means that there are no junk characters found in the provided character array.

public int nextSkipWhiteSpace()

@Override
public int nextSkipWhiteSpace() {
    int index = this.index + 1;
    final char[] data = this.data;
    final int endIndex = sourceEndIndex;
    int ch = ETX;
    loop: for (; index < endIndex; index++) {
        ch = data[index];
        switch(ch) {
            case NEW_LINE_WS:
            case CARRIAGE_RETURN_WS:
            case TAB_WS:
            case SPACE_WS:
                continue;
            default:
                break loop;
        }
    }
    this.index = index;
    return index == endIndex ? ETX : ch;
}

The nextSkipWhiteSpace method is defined in the CharArrayOffsetCharSource class in the io.nats.jparse.source package.

This method is used to skip white space characters in the data array starting from the current index. It returns the index of the next non-white space character, or ETX (end of text) if there are no more characters.

Here is a step-by-step description of what the method does:

1. Increment index by 1 to start from the next character.
2. Store the reference to the data array in a local variable named data.
3. Store the value of sourceEndIndex in a local variable named endIndex.
4. Create a variable ch and initialize it with the ETX value.
5. Start a loop that will iterate from the current index until the endIndex.
6. Inside the loop, assign the character at data[index] to ch.
7. Use a switch statement to check the value of ch.
   • If ch is equal to NEW_LINE_WS or CARRIAGE_RETURN_WS or TAB_WS or SPACE_WS, continue to the next iteration of the loop.
   • Otherwise, break out of the loop.
8. Update the index with the value of index.
9. Return ETX if the index is equal to endIndex, otherwise return the value of ch.

This method effectively skips any white space characters (including new lines, carriage returns, tabs, and spaces) in the data array until a non-white space character is encountered. It then returns the index of that non-white space character. If there are no more characters after skipping white space, it returns the ETX value.

public char skipWhiteSpace()

@Override
public char skipWhiteSpace() {
    int index = this.index;
    final char[] data = this.data;
    final int endIndex = sourceEndIndex;
    char ch;
    loop: for (; index < endIndex; index++) {
        ch = data[index];
        switch(ch) {
            case NEW_LINE_WS:
            case CARRIAGE_RETURN_WS:
            case TAB_WS:
            case SPACE_WS:
                continue;
            default:
                break loop;
        }
    }
    this.index = index;
    return data[index];
}

The skipWhiteSpace method in the CharArrayOffsetCharSource class is used to skip any white space characters (spaces, tabs, new lines, and carriage returns) in the character array.

Here is a step-by-step description of what the method is doing:

1. It first initializes a local variable index with the current value of this.index, which represents the current position in the character array.
2. It also initializes a local variable data with the reference to the character array this.data that contains the source data.
3. It gets the endIndex from the sourceEndIndex instance variable, which represents the end position in the character array.
4. It declares a variable ch to store the current character being examined.
5. It enters a loop that iterates over the character array starting from the current index till the endIndex.
6. Inside the loop, it checks the character at the current index data[index] against a set of white space characters: NEW_LINE_WS, CARRIAGE_RETURN_WS, TAB_WS, and SPACE_WS.
7. If the character matches any of the white space characters, the loop continues to the next iteration without performing any action.
8. If the character does not match any of the white space characters, it breaks out of the loop using the break loop; statement.
9. After the loop completes, it updates the index instance variable with the current index value, representing the new position after skipping white space.
10. Finally, it returns the character at that position data[index] from the character array.

So, the skipWhiteSpace method essentially advances the position in the character array to the next non-white space character and returns that character.

public String toEncodedStringIfNeeded(int startIndex, int endIndex)

@Override
public String toEncodedStringIfNeeded(int startIndex, int endIndex) {
    final int start = startIndex + sourceStartIndex;
    final int end = endIndex + sourceStartIndex;
    if (CharArrayUtils.hasEscapeChar(data, start, end)) {
        return getEncodedString(startIndex, endIndex);
    } else {
        return this.getString(startIndex, endIndex);
    }
}

The toEncodedStringIfNeeded method in the io.nats.jparse.source.CharArrayOffsetCharSource class is used to convert a portion of a character array into a string representation if it contains escape characters.

Here is a step-by-step description of what the method does:

1. The method overrides the toEncodedStringIfNeeded method from the ancestor class.

2. The method takes two parameters - startIndex and endIndex, which denote the range of characters to be converted to a string.

3. It calculates the actual start index and end index within the data character array by adding the startIndex and endIndex to the sourceStartIndex instance variable.

4. It checks if the portion of the character array from the calculated start index to end index (inclusive) contains any escape characters using the CharArrayUtils.hasEscapeChar method.

5. If the portion contains escape characters, it calls the getEncodedString method with the startIndex and endIndex parameters to obtain the encoded string representation.

6. If the portion does not contain any escape characters, it calls the getString method with the startIndex and endIndex parameters to obtain the regular string representation.

7. Finally, it returns the obtained string representation either with escape characters encoded or without any encoding based on the presence of escape characters within the portion of the character array specified by the startIndex and endIndex.

public NumberParseResult findEndOfNumberFast()

@Override
public NumberParseResult findEndOfNumberFast() {
    int i = index + 1;
    char ch = 0;
    final char[] data = this.data;
    final int endIndex = this.sourceEndIndex;
    for (; i < endIndex; i++) {
        ch = data[i];
        switch(ch) {
            case NEW_LINE_WS:
            case CARRIAGE_RETURN_WS:
            case TAB_WS:
            case SPACE_WS:
            case ATTRIBUTE_SEP:
            case ARRAY_SEP:
            case OBJECT_END_TOKEN:
            case ARRAY_END_TOKEN:
                index = i;
                return new NumberParseResult(i - sourceStartIndex, false);
            case NUM_0:
            case NUM_1:
            case NUM_2:
            case NUM_3:
            case NUM_4:
            case NUM_5:
            case NUM_6:
            case NUM_7:
            case NUM_8:
            case NUM_9:
                break;
            case DECIMAL_POINT:
                index = i;
                return findEndOfFloatFast();
            case EXPONENT_MARKER:
            case EXPONENT_MARKER2:
                index = i;
                return parseFloatWithExponentFast();
            default:
                throw new IllegalStateException("Unexpected character " + ch + " at index " + index);
        }
    }
    index = i;
    return new NumberParseResult(i - sourceStartIndex, false);
}

The method findEndOfNumberFast in the class io.nats.jparse.source.CharArrayOffsetCharSource is used to find the end position of a number within a character array.

Here is a step-by-step breakdown of what this method does:

1. It initializes the local variable i to the value of index + 1.

2. It initializes the local variable ch to 0.

3. It assigns the value of data (a char array) to the local variable data.

4. It assigns the value of sourceEndIndex (the end index of the source) to the local variable endIndex.

5. It starts a loop from i until it reaches endIndex.

6. Inside the loop, it retrieves the character at index i from the data array and assigns it to ch.

7. It uses a switch statement to handle different cases based on the value of ch.

   • If ch matches any of the specified cases (NEW_LINE_WS, CARRIAGE_RETURN_WS, TAB_WS, SPACE_WS, ATTRIBUTE_SEP, ARRAY_SEP, OBJECT_END_TOKEN, ARRAY_END_TOKEN), it updates the value of index to i and returns a new NumberParseResult object with the length of the number (i - sourceStartIndex) and a boolean indicating that the number does not have a decimal point or exponent.

   • If ch matches any digit character (NUM_0, NUM_1, NUM_2, ..., NUM_9), it continues to the next iteration of the loop.

   • If ch matches the decimal point character (DECIMAL_POINT), it updates the value of index to i and calls the findEndOfFloatFast method to find the end of a floating-point number.

   • If ch matches the exponent marker characters (EXPONENT_MARKER, EXPONENT_MARKER2), it updates the value of index to i and calls the parseFloatWithExponentFast method to parse the number with exponent notation.

   • If none of the above cases match, it throws an IllegalStateException with an error message indicating the unexpected character and its index.

8. After the loop ends, it updates the value of index to i.

9. It returns a new NumberParseResult object with the length of the number (i - sourceStartIndex) and a boolean indicating that the number does not have a decimal point or exponent.

private NumberParseResult findEndOfFloatFast() {
    int i = index + 1;
    char ch = 0;
    final char[] data = this.data;
    final int endIndex = this.sourceEndIndex;
    for (; i < endIndex; i++) {
        ch = data[i];
        switch(ch) {
            case NEW_LINE_WS:
            case CARRIAGE_RETURN_WS:
            case TAB_WS:
            case SPACE_WS:
            case ATTRIBUTE_SEP:
            case ARRAY_SEP:
            case OBJECT_END_TOKEN:
            case ARRAY_END_TOKEN:
                index = i;
                return new NumberParseResult(i - sourceStartIndex, true);
            case NUM_0:
            case NUM_1:
            case NUM_2:
            case NUM_3:
            case NUM_4:
            case NUM_5:
            case NUM_6:
            case NUM_7:
            case NUM_8:
            case NUM_9:
                break;
            case EXPONENT_MARKER:
            case EXPONENT_MARKER2:
                index = i;
                return parseFloatWithExponentFast();
            default:
                throw new UnexpectedCharacterException("Parsing JSON Float Number", "Unexpected character", this, ch, i);
        }
    }
    index = i;
    return new NumberParseResult(i - sourceStartIndex, true);
}

The findEndOfFloatFast method in the io.nats.jparse.source.CharArrayOffsetCharSource class is responsible for finding the end of a float number in a JSON source.

Here is a step-by-step description of what the method does:

1. Initialize the variable i with the value of index + 1. This indicates the starting index of the float number.
2. Initialize the variable ch with the value 0.
3. Get a reference to the data array and store it in a local variable.
4. Get the endIndex of the source and store it in a local variable.
5. Start a loop from i to endIndex.
6. Get the character at index i from the data array and store it in the variable ch.
7. Switch on the value of ch to perform different actions based on its type.
   • If ch is a white space character (e.g., NEW_LINE_WS, CARRIAGE_RETURN_WS, TAB_WS, SPACE_WS), comma (ATTRIBUTE_SEP), curly brace (OBJECT_END_TOKEN), or square bracket (ARRAY_END_TOKEN), set the index to i and return a NumberParseResult object indicating the number of characters parsed and that parsing is successful.
   • If ch is a digit character (NUM_0, NUM_1, NUM_2, ..., NUM_9), continue with the loop to parse the next character.
   • If ch is an exponent marker character (EXPONENT_MARKER, EXPONENT_MARKER2), set the index to i and call the parseFloatWithExponentFast() method to parse the number with exponent notation.
   • If ch is any other character, throw an UnexpectedCharacterException indicating that an unexpected character is encountered while parsing a JSON float number.
8. After the loop completes, set the index to i to indicate the end index of the float number.
9. Return a NumberParseResult object indicating the number of characters parsed and a flag indicating a successful parse.

Note: The specific values (e.g., NEW_LINE_WS, CARRIAGE_RETURN_WS, TAB_WS, etc.) mentioned in the switch cases are assumed to be constants defined elsewhere in the code.

private NumberParseResult parseFloatWithExponentFast() {
    int i = index + 1;
    char ch = 0;
    int signOperator = 0;
    final char[] data = this.data;
    final int end = sourceEndIndex;
    for (; i < end; i++) {
        ch = data[i];
        switch(ch) {
            case NEW_LINE_WS:
            case CARRIAGE_RETURN_WS:
            case TAB_WS:
            case SPACE_WS:
            case ATTRIBUTE_SEP:
            case ARRAY_SEP:
            case OBJECT_END_TOKEN:
            case ARRAY_END_TOKEN:
                index = i;
                return new NumberParseResult(i - sourceStartIndex, true);
            case MINUS:
            case PLUS:
                signOperator++;
                if (signOperator > 1) {
                    throw new IllegalStateException("Too many sign operators when parsing exponent of float");
                }
                break;
            case NUM_0:
            case NUM_1:
            case NUM_2:
            case NUM_3:
            case NUM_4:
            case NUM_5:
            case NUM_6:
            case NUM_7:
            case NUM_8:
            case NUM_9:
                break;
            default:
                throw new IllegalStateException("Unexpected character " + ch + " at index " + index);
        }
    }
    index = i;
    return new NumberParseResult(i - sourceStartIndex, true);
}

This method is defined in the io.nats.jparse.source.CharArrayOffsetCharSource class.

1. Initialize a variable i with the value of index + 1.
2. Initialize a variable ch with a value of 0.
3. Initialize a variable signOperator with a value of 0.
4. Get the character array data from the instance of CharArrayOffsetCharSource.
5. Get the end index end of the character source.
6. Enter a loop starting from i until end.
7. Get the character at index i from the data array and assign it to ch.
8. Enter a switch statement based on the value of ch:
   • If ch matches any of the following cases:
     • NEW_LINE_WS, CARRIAGE_RETURN_WS, TAB_WS, SPACE_WS, ATTRIBUTE_SEP, ARRAY_SEP, OBJECT_END_TOKEN, or ARRAY_END_TOKEN,
     • Update the index variable to i and return a new NumberParseResult object with the difference i - sourceStartIndex and a value of true.
   • If ch matches either MINUS or PLUS,
     • Increment the signOperator variable by 1.
     • If signOperator is greater than 1, throw an IllegalStateException with the message "Too many sign operators when parsing exponent of float".
   • If ch matches any of the following cases:
     • NUM_0, NUM_1, NUM_2, NUM_3, NUM_4, NUM_5, NUM_6, NUM_7, NUM_8, or NUM_9,
     • Continue to the next iteration of the loop.
   • If ch does not match any of the above cases, throw an IllegalStateException with the message "Unexpected character ch at index index".
9. After the loop, update the index variable to i.
10. Return a new NumberParseResult object with the difference i - sourceStartIndex and a value of true.

public int findEndOfEncodedStringFast()

@Override
public int findEndOfEncodedStringFast() {
    int i = ++index;
    final char[] data = this.data;
    final int end = sourceEndIndex;
    boolean controlChar = false;
    for (; i < end; i++) {
        char ch = data[i];
        switch(ch) {
            case CONTROL_ESCAPE_TOKEN:
                controlChar = !controlChar;
                continue;
            case STRING_END_TOKEN:
                if (!controlChar) {
                    index = i + 1;
                    return i;
                }
                controlChar = false;
                break;
            default:
                controlChar = false;
                break;
        }
    }
    throw new IllegalStateException("Unable to find closing for String");
}

The findEndOfEncodedStringFast() method, defined in the io.nats.jparse.source.CharArrayOffsetCharSource class, is used to find the closing position of an encoded string within a character array.

Here is a step-by-step description of how the method works:

1. The method starts by incrementing the index variable by 1 and assigning its value to i.

2. It then retrieves the character array (data) and the end index (end) from the source.

3. The method initializes a boolean variable controlChar to false. This variable keeps track of whether a control character (such as an escape character) has been encountered.

4. A for loop is initiated, iterating through each character in the character array, starting from index i and going up to end.

5. Within the loop, the current character (ch) is retrieved.

6. A switch statement is used to check the value of the current character:

   a. If the character is equal to CONTROL_ESCAPE_TOKEN, the controlChar variable is toggled (flipped) by assigning it the opposite value (true becomes false, false becomes true), and the loop continues to the next iteration.

   b. If the character is equal to STRING_END_TOKEN, and controlChar is false (indicating that it's not within a control sequence), then the method updates the index variable to be equal to i + 1, and returns the current value of i. This signifies that the closing position of the encoded string has been found.

   c. If the character does not match either of the above cases, the controlChar variable is set to false, indicating that it is not within a control sequence.

7. If none of the characters within the loop match the conditions to find the closing position of the encoded string, the method throws an IllegalStateException with a message stating "Unable to find closing for String". This serves as an indication that the closing position could not be found.

In summary, the findEndOfEncodedStringFast() method iterates through a character array, checking each character to determine the closing position of an encoded string. It considers control characters and checks for the end token to determine when the closing position is reached.

private int findEndOfStringControlEncode(int i) {
    final char[] data = this.data;
    final int length = data.length;
    char ch = 0;
    ch = data[i];
    switch(ch) {
        case CONTROL_ESCAPE_TOKEN:
        case STRING_END_TOKEN:
        case 'n':
        case 'b':
        case '/':
        case 'r':
        case 't':
        case 'f':
            return i;
        case 'u':
            return findEndOfHexEncoding(i);
        default:
            throw new UnexpectedCharacterException("Parsing JSON String", "Unexpected character while finding closing for String", this, ch, i);
    }
}

The findEndOfStringControlEncode method is defined in the io.nats.jparse.source.CharArrayOffsetCharSource class and takes an integer i as input. Below is a step-by-step description of what the method is doing:

1. The method begins by declaring a local variable data, which is assigned the value of this.data. this.data refers to a char array that represents the source data being processed.
2. A local variable length is declared and assigned the length of the data array.
3. A local variable ch of type char is declared and initialized to 0.
4. The character at index i of the data array is assigned to ch.
5. A switch statement is used to perform different actions based on the value of ch.
   • If ch is equal to CONTROL_ESCAPE_TOKEN, STRING_END_TOKEN, 'n', 'b', '/', 'r', 't', or 'f', the method simply returns i. These characters represent the control escape token and various escape sequences commonly found in JSON strings.
   • If ch is equal to 'u', the method calls the findEndOfHexEncoding method with i as an argument and returns the result. This suggests that findEndOfHexEncoding is responsible for finding the end of a hexadecimal encoding, which is likely used to decode Unicode characters in the JSON string.
   • If none of the above cases match, it means that an unexpected character was encountered while trying to find the closing for a string. In this case, an UnexpectedCharacterException is thrown with a descriptive error message, including the current source (this), the unexpected character ch, and the current index i.

That concludes the step-by-step description of the findEndOfStringControlEncode method.

public int findEndOfEncodedString()

@Override
public int findEndOfEncodedString() {
    int i = ++index;
    final char[] data = this.data;
    final int length = data.length;
    char ch = 0;
    for (; i < length; i++) {
        ch = data[i];
        switch(ch) {
            case CONTROL_ESCAPE_TOKEN:
                i = findEndOfStringControlEncode(i + 1);
                continue;
            case STRING_END_TOKEN:
                index = i + 1;
                return i;
            default:
                if (ch >= SPACE_WS) {
                    continue;
                }
                throw new UnexpectedCharacterException("Parsing JSON String", "Unexpected character while finding closing for String", this, ch, i);
        }
    }
    throw new UnexpectedCharacterException("Parsing JSON Encoded String", "Unable to find closing for String", this, ch, i);
}

The findEndOfEncodedString method is defined in the CharArrayOffsetCharSource class in the io.nats.jparse.source package. Here is a step-by-step description of what this method does:

1. Declare a local variable i and initialize it with the value of ++index. This increments the value of the index variable by 1 and assigns the updated value to i.
2. Retrieve the data array from this object. This is the character array that the method operates on.
3. Get the length of the data array and store it in the length variable.
4. Declare a variable ch and initialize it with 0.
5. Start a loop that iterates through the array from the current value of i to the end of the array (length).
6. Get the character at the current index i from the data array and assign it to ch.
7. Use a switch statement to perform different actions based on the value of ch:
   • If ch is equal to the CONTROL_ESCAPE_TOKEN constant, call the findEndOfStringControlEncode method with the argument i + 1 and assign its return value to i. This method is not provided, so we can't describe its exact behavior.
   • If ch is equal to the STRING_END_TOKEN constant, update the value of the index variable to i + 1 and return the current value of i.
   • If none of the above conditions are true, check if ch is greater than or equal to the SPACE_WS constant. If it is, continue to the next iteration of the loop.
   • If none of the conditions above are true, throw an UnexpectedCharacterException with a message indicating that an unexpected character was encountered while finding the closing of a string. The exception includes information about the current CharSource, the unexpected character ch, and its position i.
8. If the loop completes without finding the closing of the string, throw an UnexpectedCharacterException with a message indicating that the closing for the string could not be found. The exception includes information about the current CharSource, the last character ch encountered, and its position i.

private int findEndOfHexEncoding(int index) {
    final char[] data = this.data;
    final int length = data.length;
    if (isHex(data[++index]) && isHex(data[++index]) && isHex(data[++index]) && isHex(data[++index])) {
        return index;
    } else {
        throw new UnexpectedCharacterException("Parsing hex encoding in a string", "Unexpected character", this);
    }
}

The method findEndOfHexEncoding is defined in the class io.nats.jparse.source.CharArrayOffsetCharSource. It takes an index as a parameter and returns an integer.

Here is a step-by-step description of what the method does:

1. The method starts by getting the data array and its length from the current instance of CharArrayOffsetCharSource.

2. It then checks if the character at the next index in the data array is a valid hexadecimal character (isHex). It does this repeatedly for the next 4 characters by incrementing the index for each check.

3. If all 4 characters are valid hexadecimal characters, the method returns the current value of index.

4. If any of the characters are not valid hexadecimal characters, the method throws an UnexpectedCharacterException. The exception message states that it occurred while parsing a hex encoding in a string, and the unexpected character is included in the message. The this reference is passed as an argument to provide additional context.

In summary, the findEndOfHexEncoding method scans the data array starting from the given index and checks if the next 4 characters form a valid hex encoding. If they do, it returns the index. If not, it throws an exception.

private boolean isHex(char datum) {
    switch(datum) {
        case 'A':
        case 'B':
        case 'C':
        case 'D':
        case 'E':
        case 'F':
        case 'a':
        case 'b':
        case 'c':
        case 'd':
        case 'e':
        case 'f':
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            return true;
        default:
            return false;
    }
}

The isHex method in the io.nats.jparse.source.CharArrayOffsetCharSource class is used to determine whether a given character is a hexadecimal digit. Here is a step-by-step description of what the method does:

1. The method takes a single parameter datum, which represents the character to be tested.

2. The method uses a switch statement to check the value of the datum character.

3. If the datum character is any of the following characters: 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f', '0', '1', '2', '3', '4', '5', '6', '7', '8', or '9', then the method returns true. These characters represent valid hexadecimal digits.

4. If the datum character is not one of the specified hexadecimal digits, the default case is executed, and the method returns false.

5. So overall, the isHex method determines whether a character is a hexadecimal digit by checking if it falls within the specified range of valid hexadecimal characters. If the character is within the range, the method returns true; otherwise, it returns false.

public int findEndString()

@Override
public int findEndString() {
    int i = ++index;
    final char[] data = this.data;
    final int length = data.length;
    char ch = 0;
    for (; i < length; i++) {
        ch = data[i];
        switch(ch) {
            case STRING_END_TOKEN:
                index = i;
                return i;
            default:
                if (ch >= SPACE_WS) {
                    continue;
                }
                throw new UnexpectedCharacterException("Parsing JSON String", "Unexpected character while finding closing for String", this, ch, i);
        }
    }
    throw new UnexpectedCharacterException("Parsing JSON String", "Unable to find closing for String", this, ch, i);
}

This findEndString method is defined in the CharArrayOffsetCharSource class and it overrides the same method from the superclass.

Here is a step-by-step description of what this method does:

1. It starts by incrementing the index variable.
2. It retrieves the data array and its length from the class instance.
3. It declares a ch variable and sets it to 0.
4. It enters a loop from the incremented index up to the length of the data array.
5. Inside the loop, it assigns the current character of the data array to ch.
6. It checks for a switch case where ch is equal to the STRING_END_TOKEN.
   • If so, it updates the index variable to the current index and returns the index.
   • If not, it continues to the next step.
7. It then checks if ch is greater than or equal to SPACE_WS. If true, it continues to the next iteration of the loop.
8. If the character doesn't match the switch case and is not greater than SPACE_WS, it throws an UnexpectedCharacterException with the appropriate message, passing in this object, ch, and the current index.
9. If the loop completes without finding a match, it throws an UnexpectedCharacterException with the appropriate message, passing in this object, ch, and the current index.

Note: The specific values for STRING_END_TOKEN and SPACE_WS are not included in the code snippet provided and may be defined elsewhere in the codebase or imported from another class or module.

public NumberParseResult findEndOfNumber()

@Override
public NumberParseResult findEndOfNumber() {
    final char startCh = getCurrentChar();
    final int startIndex = index;
    char ch = startCh;
    int i = index + 1;
    final char[] data = this.data;
    final int endIndex = this.sourceEndIndex;
    loop: for (; i < endIndex; i++) {
        ch = data[i];
        switch(ch) {
            case NEW_LINE_WS:
            case CARRIAGE_RETURN_WS:
            case TAB_WS:
            case SPACE_WS:
            case ATTRIBUTE_SEP:
            case ARRAY_SEP:
            case OBJECT_END_TOKEN:
            case ARRAY_END_TOKEN:
                break loop;
            case NUM_0:
            case NUM_1:
            case NUM_2:
            case NUM_3:
            case NUM_4:
            case NUM_5:
            case NUM_6:
            case NUM_7:
            case NUM_8:
            case NUM_9:
                break;
            case DECIMAL_POINT:
                if (startCh == MINUS) {
                    final int numLenSoFar = i - startIndex;
                    if (numLenSoFar == 1) {
                        throw new UnexpectedCharacterException("Parsing JSON Number", "Unexpected character", this, ch, i);
                    }
                }
                index = i;
                return findEndOfFloat();
            case EXPONENT_MARKER:
            case EXPONENT_MARKER2:
                index = i;
                return parseFloatWithExponent();
            default:
                throw new UnexpectedCharacterException("Parsing JSON Number", "Unexpected character", this, ch, i);
        }
    }
    index = i;
    final int numLength = i - startIndex;
    switch(startCh) {
        case NUM_0:
            if (numLength != 1) {
                throw new UnexpectedCharacterException("Parsing JSON Int Number", "Int can't start with a 0 ", this, startCh, startIndex);
            }
            break;
        case PLUS:
            throw new UnexpectedCharacterException("Parsing JSON Int Number", "Int can't start with a plus ", this, startCh, startIndex);
        case MINUS:
            switch(numLength) {
                case 1:
                    throw new UnexpectedCharacterException("Parsing JSON Int Number", "Int can't be only a minus, number is missing", this, startCh, startIndex);
                case 2:
                    break;
                default:
                    if (data[startIndex + 1] == NUM_0) {
                        throw new UnexpectedCharacterException("Parsing JSON Int Number", "0 can't be after minus sign", this, startCh, startIndex);
                    }
            }
    }
    return new NumberParseResult(i - this.sourceStartIndex, false);
}