Packages

final class Parser[F[_], A] extends BaseParser[F, A]

Parser is able to parse chunks of data (encoded as Option[ByteBuffer] instances) and parse asynchronously. You can use the factory methods in the companion object to instantiate an async parser.

The async parser's fields are described below:

The (state, curr, stack) triple is used to save and restore parser state between async calls. State also helps encode extra information when streaming or unwrapping an array.

The (data, len, allocated) triple is used to manage the underlying data the parser is keeping track of. As new data comes in, data may be expanded if not enough space is available.

The offset parameter is used to drive the outer async parsing. It stores similar information to curr but is kept separate to avoid "corrupting" our snapshot.

The done parameter is used internally to help figure out when the atEof() parser method should return true. This will be set when apply(None) is called.

The streamMode parameter controls how the asynchronous parser will be handling multiple values. There are three states:

1: An array is being unwrapped. Normal JSON array rules apply (Note that if the outer value observed is not an array, this mode will toggle to the -1 mode).

0: A stream of individual JSON elements separated by whitespace are being parsed. We can return each complete element as we parse it.

-1: No streaming is occuring. Only a single JSON value is allowed.

Annotations
@SuppressWarnings()
Linear Supertypes
BaseParser[F, A], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Parser
  2. BaseParser
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def absorb(s: String)(implicit F: Sync[F]): F[Either[ParseException, A]]
    Definition Classes
    BaseParser
    Annotations
    @SuppressWarnings()
  5. final def absorb(bytes: Array[Byte])(implicit F: Sync[F]): F[Either[ParseException, A]]
    Definition Classes
    BaseParser
    Annotations
    @SuppressWarnings()
  6. final def absorb(buf: ByteBuffer)(implicit F: Sync[F]): F[Either[ParseException, A]]
    Definition Classes
    BaseParser
    Annotations
    @SuppressWarnings()
  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. final def at(i: Int, k: Int): CharSequence

    Access a byte range as a string.

    Access a byte range as a string.

    Since the underlying data are UTF-8 encoded, i and k must occur on unicode boundaries. Also, the resulting String is not guaranteed to have length (k - i).

    Attributes
    protected[this]
    Definition Classes
    BaseParser
    Annotations
    @SuppressWarnings()
  9. final def at(i: Int): Char
    Attributes
    protected[this]
    Definition Classes
    BaseParser
    Annotations
    @SuppressWarnings()
  10. final def atEof(i: Int): Boolean
    Attributes
    protected[this]
    Definition Classes
    BaseParser
  11. final def byte(i: Int): Byte

    This is a specialized accessor for the case where our underlying data are bytes not chars.

    This is a specialized accessor for the case where our underlying data are bytes not chars.

    Attributes
    protected[this]
    Definition Classes
    BaseParser
    Annotations
    @SuppressWarnings()
  12. def checkpoint(state: Int, i: Int, ring: Long, offset: Int, fallback: BList): Unit

    We use this to keep track of the last recoverable place we've seen.

    We use this to keep track of the last recoverable place we've seen. If we hit an AsyncException, we can later resume from this point.

    This method is called during every loop of rparse, and the arguments are the exact arguments we can pass to rparse to continue where we left off.

    Attributes
    protected[this]
  13. def churn(): Either[ParseException, A]

    More data has been received, consume as much as possible.

    More data has been received, consume as much as possible.

    Attributes
    protected[this]
    Definition Classes
    Parser → BaseParser
    Annotations
    @SuppressWarnings()
  14. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  15. final def column(i: Int): Int
    Attributes
    protected[this]
    Definition Classes
    BaseParser
  16. final var curr: Int
    Attributes
    protected[this]
    Definition Classes
    BaseParser
  17. def descape(s: CharSequence): Char

    Generate a Char from the hex digits of "ሴ" (i.e.

    Generate a Char from the hex digits of "ሴ" (i.e. "1234").

    NOTE: This is only capable of generating characters from the basic plane. This is why it can only return Char instead of Int.

    Attributes
    protected[this]
    Annotations
    @SuppressWarnings()
  18. final def die(i: Int, msg: String): Nothing

    Used to generate error messages with character info and offsets.

    Used to generate error messages with character info and offsets.

    Attributes
    protected[this]
    Definition Classes
    BaseParser
    Annotations
    @SuppressWarnings()
  19. final var done: Boolean
    Attributes
    protected[this]
    Definition Classes
    BaseParser
  20. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  21. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  22. final def error(msg: String): Nothing

    Used to generate messages for internal errors.

    Used to generate messages for internal errors.

    This should only be used in situations where a possible bug in the parser was detected. For errors in user-provided JSON, use die().

    Attributes
    protected[this]
    Definition Classes
    BaseParser
  23. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  24. final def finish(implicit F: Sync[F]): F[Either[ParseException, A]]
    Definition Classes
    BaseParser
  25. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  26. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  27. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  28. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  29. final def newline(i: Int): Unit
    Attributes
    protected[this]
    Definition Classes
    BaseParser
  30. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  31. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  32. final var offset: Int
    Attributes
    protected[this]
    Definition Classes
    BaseParser
  33. def parse(i: Int): Int

    Parse and return the next JSON value and the position beyond it.

    Parse and return the next JSON value and the position beyond it.

    Attributes
    protected[this]
    Annotations
    @SuppressWarnings()
  34. def parseFalse(i: Int): Unit

    Parse the JSON constant "false".

    Parse the JSON constant "false".

    Note that this method assumes that the first character has already been checked.

    Attributes
    protected[this]
    Annotations
    @SuppressWarnings()
  35. def parseNull(i: Int): Unit

    Parse the JSON constant "null".

    Parse the JSON constant "null".

    Note that this method assumes that the first character has already been checked.

    Attributes
    protected[this]
    Annotations
    @SuppressWarnings()
  36. def parseNum(i: Int): Int

    Parse the given number, and add it to the given context.

    Parse the given number, and add it to the given context.

    We don't actually instantiate a number here, but rather pass the string of for future use. Facades can choose to be lazy and just store the string. This ends up being way faster and has the nice side-effect that we know exactly how the user represented the number.

    Attributes
    protected[this]
    Annotations
    @SuppressWarnings()
  37. def parseNumSlow(i: Int): Int

    Parse the given number, and add it to the given context.

    Parse the given number, and add it to the given context.

    This method is a bit slower than parseNum() because it has to be sure it doesn't run off the end of the input.

    Normally (when operating in rparse in the context of an outer array or object) we don't need to worry about this and can just grab characters, because if we run out of characters that would indicate bad input. This is for cases where the number could possibly be followed by a valid EOF.

    This method has all the same caveats as the previous method.

    Attributes
    protected[this]
    Annotations
    @SuppressWarnings()
  38. def parseString(i: Int, key: Boolean): Int

    Parse the JSON string starting at 'i' and save it into the plate.

    Parse the JSON string starting at 'i' and save it into the plate. If key is true, save the string with 'nestMap', otherwise use 'str'.

    Attributes
    protected[this]
    Annotations
    @SuppressWarnings()
  39. def parseStringSimple(i: Int): Int

    See if the string has any escape sequences.

    See if the string has any escape sequences. If not, return the end of the string. If so, bail out and return -1.

    This method expects the data to be in UTF-8 and accesses it as bytes. Thus we can just ignore any bytes with the highest bit set.

    Attributes
    protected[this]
    Annotations
    @SuppressWarnings()
  40. def parseTrue(i: Int): Unit

    Parse the JSON constant "true".

    Parse the JSON constant "true".

    Note that this method assumes that the first character has already been checked.

    Attributes
    protected[this]
    Annotations
    @SuppressWarnings()
  41. final def reset(i: Int): Int
    Attributes
    protected[this]
    Definition Classes
    BaseParser
  42. def rparse(state: Int, j: Int, ring: Long, offset: Int, fallback: BList): Int

    Tail-recursive parsing method to do the bulk of JSON parsing.

    Tail-recursive parsing method to do the bulk of JSON parsing.

    This single method manages parser states, data, etc. Except for parsing non-recursive values (like strings, numbers, and constants) all important work happens in this loop (or in methods it calls, like reset()).

    Currently the code is optimized to make use of switch statements. Future work should consider whether this is better or worse than manually constructed if/else statements or something else. Also, it may be possible to reorder some cases for speed improvements.

    Attributes
    protected[this]
    Annotations
    @tailrec() @SuppressWarnings()
  43. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  44. def toString(): String
    Definition Classes
    AnyRef → Any
  45. final def unsafeData(): Array[Byte]
    Attributes
    protected[this]
    Definition Classes
    BaseParser
  46. final def unsafeLen(): Int
    Attributes
    protected[this]
    Definition Classes
    BaseParser
  47. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  48. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  49. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )

Inherited from BaseParser[F, A]

Inherited from AnyRef

Inherited from Any

Ungrouped