Class JsonParserSequence

All Implemented Interfaces:
Closeable, AutoCloseable, Versioned

public class JsonParserSequence extends JsonParserDelegate
Helper class that can be used to sequence multiple physical JsonParsers to create a single logical sequence of tokens, as a single JsonParser.

Fairly simple use of JsonParserDelegate: only need to override nextToken() to handle transition

  • Field Details

    • _parsers

      protected final JsonParser[] _parsers
      Parsers other than the first one (which is initially assigned as delegate)
    • _checkForExistingToken

      protected final boolean _checkForExistingToken
      Configuration that determines whether state of parsers is first verified to see if parser already points to a token (that is, JsonParser.hasCurrentToken() returns true), and if so that token is first return before JsonParser.nextToken() is called. If enabled, this check is made; if disabled, no check is made and JsonParser.nextToken() is always called for all parsers.

      Default setting is false (for backwards-compatibility) so that possible existing token is not considered for parsers.

    • _nextParserIndex

      protected int _nextParserIndex
      Index of the next parser in _parsers.
    • _hasToken

      protected boolean _hasToken
      Flag used to indicate that `JsonParser.nextToken()` should not be called, due to parser already pointing to a token.
  • Constructor Details

    • JsonParserSequence

      protected JsonParserSequence(boolean checkForExistingToken, JsonParser[] parsers)
  • Method Details

    • createFlattened

      public static JsonParserSequence createFlattened(boolean checkForExistingToken, JsonParser first, JsonParser second)
      Method that will construct a sequence (possibly a sequence) that contains all given sub-parsers. All parsers given are checked to see if they are sequences: and if so, they will be "flattened", that is, contained parsers are directly added in a new sequence instead of adding sequences within sequences. This is done to minimize delegation depth, ideally only having just a single level of delegation.
      Parameters:
      checkForExistingToken - Flag passed to be assigned as _checkForExistingToken for resulting sequence
      first - First parser to traverse
      second - Second parser to traverse
      Returns:
      Sequence instance constructed
    • addFlattenedActiveParsers

      protected void addFlattenedActiveParsers(List<JsonParser> listToAddIn)
    • close

      public void close() throws JacksonException
      Description copied from class: JsonParser
      Closes the parser so that no further iteration or data access can be made; will also close the underlying input source if parser either owns the input source, or feature StreamReadFeature.AUTO_CLOSE_SOURCE is enabled. Whether parser owns the input source depends on factory method that was used to construct instance (so check JsonFactory for details, but the general idea is that if caller passes in closable resource (such as InputStream or Reader) parser does NOT own the source; but if it passes a reference (such as File or URL and creates stream or reader it does own them.
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Overrides:
      close in class JsonParserDelegate
      Throws:
      JacksonException
    • nextToken

      public JsonToken nextToken() throws JacksonException
      Description copied from class: JsonParser
      Main iteration method, which will advance stream enough to determine type of the next token, if any. If none remaining (stream has no content other than possible white space before ending), null will be returned.
      Overrides:
      nextToken in class JsonParserDelegate
      Returns:
      Next token from the stream, if any found, or null to indicate end-of-input
      Throws:
      JacksonException - for low-level read issues
      StreamReadException - for decoding problems
    • skipChildren

      public JsonParser skipChildren() throws JacksonException
      Need to override, re-implement similar to how method defined in ParserMinimalBase, to keep state correct here.
      Overrides:
      skipChildren in class JsonParserDelegate
      Returns:
      This parser, to allow call chaining
      Throws:
      JacksonException - for low-level read issues
      StreamReadException - for decoding problems
    • nextName

      public String nextName() throws JacksonException
      Description copied from class: JsonParser
      Method that fetches next token (as if calling JsonParser.nextToken()) and verifies whether it is JsonToken.PROPERTY_NAME; if it is, returns same as JsonParser.currentName(), otherwise null.

      NOTE: in Jackson 2.x method was called nextFieldName()

      Overrides:
      nextName in class JsonParserDelegate
      Returns:
      Name of the the JsonToken.PROPERTY_NAME parser advanced to, if any; null if next token is of some other type
      Throws:
      JacksonException - for low-level read issues
      StreamReadException - for decoding problems
    • nextName

      public boolean nextName(SerializableString str) throws JacksonException
      Description copied from class: JsonParser
      Method that fetches next token (as if calling JsonParser.nextToken()) and verifies whether it is JsonToken.PROPERTY_NAME with specified name and returns result of that comparison. It is functionally equivalent to:
        return (nextToken() == JsonToken.PROPERTY_NAME) && str.getValue().equals(currentName());
      
      but may be faster for parser to verify, and can therefore be used if caller expects to get such a property name from input next.

      NOTE: in Jackson 2.x method was called nextFieldName()

      Overrides:
      nextName in class JsonParserDelegate
      Parameters:
      str - Property name to compare next token to (if next token is JsonToken.PROPERTY_NAME)
      Returns:
      True if parser advanced to JsonToken.PROPERTY_NAME with specified name; false otherwise (different token or non-matching name)
      Throws:
      JacksonException - for low-level read issues
      StreamReadException - for decoding problems
    • nextNameMatch

      public int nextNameMatch(PropertyNameMatcher matcher) throws JacksonException
      Description copied from class: JsonParser
      Method that tries to match next token from stream as JsonToken.PROPERTY_NAME, and if so, further match it to one of pre-specified (field) names. If match succeeds, property index (non-negative `int`) is returned; otherwise one of marker constants from PropertyNameMatcher.
      Overrides:
      nextNameMatch in class JsonParserDelegate
      Parameters:
      matcher - Matcher that will handle actual matching
      Returns:
      Index of the matched property name, if non-negative, or a negative error code otherwise (see PropertyNameMatcher for details)
      Throws:
      JacksonIOException - for low-level read issues
      StreamReadException - for decoding problems
      JacksonException
    • containedParsersCount

      public int containedParsersCount()
      Method that is most useful for debugging or testing; returns actual number of underlying parsers sequence was constructed with (nor just ones remaining active)
      Returns:
      Number of actual underlying parsers this sequence has
    • switchToNext

      protected boolean switchToNext()
      Method that will switch active delegate parser from the current one to the next parser in sequence, if there is another parser left: if so, the next parser will become the active delegate parser.
      Returns:
      True if switch succeeded; false otherwise
    • switchAndReturnNext

      protected JsonToken switchAndReturnNext() throws JacksonException
      Throws:
      JacksonException