final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final val ARRBEG: Int(6)

Valid parser states.

Attributes: protected[this]
Definition Classes: Parser
Annotations: @inline()

final val ARREND: Int(4)

Attributes: protected[this]
Definition Classes: Parser
Annotations: @inline()

final val DATA: Int(1)

Attributes: protected[this]
Definition Classes: Parser
Annotations: @inline()

final val KEY: Int(2)

Attributes: protected[this]
Definition Classes: Parser
Annotations: @inline()

final val OBJBEG: Int(7)

Attributes: protected[this]
Definition Classes: Parser
Annotations: @inline()

final val OBJEND: Int(5)

Attributes: protected[this]
Definition Classes: Parser
Annotations: @inline()

final val SEP: Int(3)

Attributes: protected[this]
Definition Classes: Parser
Annotations: @inline()

final def absorb(buf: ByteBuffer): Unit

Attributes: protected[this]

var allocated: Int

Attributes: protected[quasar.blueeyes.json]

final def apply(input: Input): (AsyncParse, AsyncParser)

final def asInstanceOf[T0]: T0

Definition Classes: Any

final def at(i: Int, k: Int): 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: AsyncParser → Parser

final def at(i: Int): Char

Read the byte/char at 'i' as a Char.

Note that this should not be used on potential multi-byte sequences.

Attributes: protected[this]
Definition Classes: AsyncParser → Parser

final def atEof(i: Int): Boolean

Return true iff 'i' is at or beyond the end of the input (EOF).

Attributes: protected[this]
Definition Classes: AsyncParser → Parser

final def byte(i: Int): Byte

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

Attributes: protected[this]
Definition Classes: AsyncParser → ByteBasedParser

final def checkpoint(state: Int, i: Int, stack: List[Context]): 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]
Definition Classes: AsyncParser → Parser

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @native() @throws( ... )

final def close(): Unit

Should be called when parsing is finished.

Attributes: protected[this]
Definition Classes: AsyncParser → Parser

final def column(i: Int): Int

Attributes: protected[this]
Definition Classes: AsyncParser → Parser

final def copy(): AsyncParser

Attributes: protected[this]

var curr: Int

Attributes: protected[quasar.blueeyes.json]

var data: Array[Byte]

Attributes: protected[quasar.blueeyes.json]

final def descape(s: String): 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]
Definition Classes: Parser

def die(i: Int, msg: String): Nothing

Used to generate error messages with character info and byte addresses.

Attributes: protected[this]
Definition Classes: Parser

var done: Boolean

Attributes: protected[quasar.blueeyes.json]

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def error(msg: String): Nothing

Used to generate messages for internal errors.

Attributes: protected[this]
Definition Classes: Parser

def feed(b: Input): (AsyncParse, AsyncParser)

Attributes: protected[quasar.blueeyes.json]

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native()

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native()

final def is(i: Int, j: Int, str: String): Boolean

Return true iff the bytes/chars from 'i' until 'j' are equal to 'str'.

Attributes: protected[this]
Definition Classes: Parser

final def is(i: Int, c: Char): Boolean

Return true iff the byte/char at 'i' is equal to 'c'.

Attributes: protected[this]
Definition Classes: Parser

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

var len: Int

Attributes: protected[quasar.blueeyes.json]

var line: Int

Attributes: protected[this]

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

final def newline(i: Int): Unit

Attributes: protected[this]
Definition Classes: AsyncParser → Parser

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

var offset: Int

Attributes: protected[quasar.blueeyes.json]

final def parse(i: Int): (JValue, Int)

Parse and return the "next" JSON value as well as the position beyond it.

Parse and return the "next" JSON value as well as the position beyond it. This method is used by both parse() as well as parseMany().

Attributes: protected[this]
Definition Classes: Parser

final def parseFalse(i: Int): JFalse.type

Parse the JSON constant "false".

Attributes: protected[this]
Definition Classes: Parser

final def parseNull(i: Int): JNull.type

Parse the JSON constant "null".

Attributes: protected[this]
Definition Classes: Parser

final def parseNum(i: Int, ctxt: Context): Int

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

We don't actually instantiate a number here, but rather save the string for future use. This ends up being way faster and has the nice side-effect that we know exactly how the user represented the number.

It would probably be possible to keep track of the whether the number is expected to be whole, decimal, etc. but we don't do that at the moment.

Attributes: protected[this]
Definition Classes: Parser

final def parseNumSlow(i: Int, ctxt: Context): Int

This number parser is a bit slower because it has to be sure it doesn't run off the end of the input.

This number parser is a bit slower 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 objedct) we don't have to worry about this and can just grab characters, because if we run out of characters that would indicate bad input.

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

Attributes: protected[this]
Definition Classes: Parser

final def parseString(i: Int, ctxt: Context): Int

Parse the string according to JSON rules, and add to the given context.

This method expects the data to be in UTF-8 and accesses it as bytes.

Attributes: protected[this]
Definition Classes: ByteBasedParser → Parser

final def parseStringSimple(i: Int, ctxt: Context): 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]
Definition Classes: ByteBasedParser

final def parseTrue(i: Int): JTrue.type

Parse the JSON constant "true".

Attributes: protected[this]
Definition Classes: Parser

var pos: Int

Attributes: protected[this]

final def reset(i: Int): Int

The reset() method is used to signal that we're working from the given position, and any previous data can be released.

The reset() method is used to signal that we're working from the given position, and any previous data can be released. Some parsers (e.g. StringParser) will ignore release, while others (e.g. PathParser) will need to use this information to release and allocate different areas.

Attributes: protected[this]
Definition Classes: AsyncParser → Parser

final def rparse(state: Int, j: Int, stack: List[Context]): (JValue, Int)

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.

Attributes: protected[this]
Definition Classes: Parser
Annotations: @tailrec()

var stack: List[Context]

Attributes: protected[quasar.blueeyes.json]

var state: Int

Attributes: protected[quasar.blueeyes.json]

var streamMode: Int

Attributes: protected[quasar.blueeyes.json]

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

def toString(): String

Definition Classes: AnyRef → Any

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @native() @throws( ... )

Packages

AsyncParser

Companion object AsyncParser

final class AsyncParser extends ByteBasedParser

Instance Constructors

Value Members

Inherited from ByteBasedParser

Inherited from Parser

Inherited from AnyRef

Inherited from Any

Ungrouped