JSONParser

Type Members

type Elem = Char

Definition Classes
JSONParser → Parsers
case class Error extends NoSuccess with Product with Serializable

Definition Classes
Parsers
case class Failure extends NoSuccess with Product with Serializable

Definition Classes
Parsers
type Input = Reader[Elem]

Definition Classes
Parsers
sealed abstract class NoSuccess extends ParseResult[Nothing]

Definition Classes
Parsers
trait OnceParser[+T] extends Parser[T]

Definition Classes
Parsers
sealed abstract class ParseResult[+T] extends AnyRef

Definition Classes
Parsers
abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

Definition Classes
Parsers
case class Success[+T] extends ParseResult[T] with Product with Serializable

Definition Classes
Parsers
case class ~[+a, +b] extends Product with Serializable

Definition Classes
Parsers

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

Definition Classes
Parsers
def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

Definition Classes
Parsers
def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
implicit def accept(e: Elem): Parser[Elem]

Definition Classes
Parsers
def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

Definition Classes
Parsers
def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
lazy val achar: Parser[Char]
lazy val anInt: Parser[Long]
lazy val array: Parser[List[Any]]
final def asInstanceOf[T0]: T0

Definition Classes
Any
lazy val bchar: Parser[Char]
def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

Definition Classes
Parsers
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def commit[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
lazy val digit: Parser[Elem]
lazy val digit19: Parser[Elem]
lazy val digits: Parser[List[Elem]]
lazy val e: Parser[Int]
def elem(e: Elem): Parser[Elem]

Definition Classes
Parsers
def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

Definition Classes
Parsers
lazy val elements: Parser[List[Any]]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def err(msg: String): Parser[Nothing]

Definition Classes
Parsers
lazy val exp: Parser[Int]
def failure(msg: String): Parser[Nothing]

Definition Classes
Parsers
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
implicit def flatten2[A, B, C](f: (A, B) ⇒ C): (~[A, B]) ⇒ C

Definition Classes
ImplicitConversions
implicit def flatten3[A, B, C, D](f: (A, B, C) ⇒ D): (~[~[A, B], C]) ⇒ D

Definition Classes
ImplicitConversions
implicit def flatten4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (~[~[~[A, B], C], D]) ⇒ E

Definition Classes
ImplicitConversions
implicit def flatten5[A, B, C, D, E, F](f: (A, B, C, D, E) ⇒ F): (~[~[~[~[A, B], C], D], E]) ⇒ F

Definition Classes
ImplicitConversions
lazy val frac: Parser[String]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def guard[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit def headOptionTailToFunList[A, T](f: (List[A]) ⇒ T): (~[A, Option[List[A]]]) ⇒ T

Definition Classes
ImplicitConversions
lazy val hexDigit: Parser[Elem]
lazy val intExp: Parser[Double]
lazy val intFrac: Parser[Double]
lazy val intFracExp: Parser[Double]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val isfalse: Parser[Boolean]
lazy val isnull: Parser[Empty.type]
lazy val istrue: Parser[Boolean]
lazy val jsonObject: Parser[Map[String, Any]]
def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

Definition Classes
Parsers
lazy val manyCharInt: Parser[Double]
lazy val members: Parser[List[(String, Any)]]
def mkList[T]: (~[T, List[T]]) ⇒ List[T]

Definition Classes
Parsers
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def not[T](p: ⇒ Parser[T]): Parser[Unit]

Definition Classes
Parsers
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
lazy val number: Parser[Double]
def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

Definition Classes
Parsers
lazy val pair: Parser[(String, Any)]
def pairChar(in: Char): Boolean
lazy val pairId: Parser[String]
def parse(in: String): Box[Any]

Parse a JSON structure.
Parse a JSON structure. A JSON structure is a JSON array or JSON object (which may contain other arrays or objects). See http://json.org for details about the JSON format.
In the parsed results, each JSON object is returned as a Map[String,Any] that maps JSON object names to JSON values. Each JSON array is returned as and a List[Any] that contains JSON objects and/or JSON arrays.
returns
a Box containig the root JSON object or JSON array.
def phrase[T](p: Parser[T]): Parser[T]

Definition Classes
Parsers
def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1[T](first: ⇒ Parser[T], p: ⇒ Parser[T]): Parser[List[T]]

A parser generator for non-empty repetitions.
A parser generator for non-empty repetitions.
rep1(f, p) first uses f' (which must succeed) and then repeatedly uses p' to parse the input until p' fails (the result is aList' of the consecutive results of f' and p')
first
a Parser' that parses the first piece of input
p
a Parser' that is to be applied successively to the rest of the input (if any)
returns
A parser that returns a list of results produced by first applying f' and then repeatedlyp' to the input (it only succeeds if f' matches).

Definition Classes
SafeSeqParser → Parsers
def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

A parser generator for non-empty repetitions.
A parser generator for non-empty repetitions.
rep1sep(first, p, q) starts by using first', followed by repeatedly uses of p' interleaved with q' to parse the input, untilp' fails. first' must succeed (the result is a List' of the consecutive results of first' and p')
p
a Parser' that is to be applied successively to the input
q
a Parser' that parses the elements that separate the elements parsed by p' (interleaved with q')
returns
A parser that returns a list of results produced by repeatedly applying p' to the input (and that only succeeds ifp' matches at least once). The results of p' are collected in a list. The results of q' are discarded.

Definition Classes
SafeSeqParser → Parsers
def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

Definition Classes
Parsers
lazy val spaces: Parser[List[Elem]]
implicit def strToInput(in: String): Input
lazy val string: Parser[String]
def success[T](v: T): Parser[T]

Definition Classes
Parsers
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
lazy val theValue: Parser[Any]
def toString(): String

Definition Classes
AnyRef → Any
def unapply(in: Any): Option[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
@throws( ... )
lazy val whitespace: Parser[Elem]

Deprecated Value Members

def lastNoSuccess: NoSuccess

Definition Classes
Parsers
Annotations
@deprecated
Deprecated
(Since version 2.10.0) lastNoSuccess was not thread-safe and will be removed in 2.11.0
def lastNoSuccess_=(x: NoSuccess): Unit

Definition Classes
Parsers
Annotations
@deprecated
Deprecated
(Since version 2.10.0) lastNoSuccess was not thread-safe and will be removed in 2.11.0

object JSONParser extends SafeSeqParser with ImplicitConversions

Type Members

type Elem = Char

case class Error extends NoSuccess with Product with Serializable

case class Failure extends NoSuccess with Product with Serializable

type Input = Reader[Elem]

sealed abstract class NoSuccess extends ParseResult[Nothing]

trait OnceParser[+T] extends Parser[T]

sealed abstract class ParseResult[+T] extends AnyRef

abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

case class Success[+T] extends ParseResult[T] with Product with Serializable

case class ~[+a, +b] extends Product with Serializable

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

implicit def accept(e: Elem): Parser[Elem]

def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

lazy val achar: Parser[Char]

lazy val anInt: Parser[Long]

lazy val array: Parser[List[Any]]

final def asInstanceOf[T0]: T0

lazy val bchar: Parser[Char]

def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

def clone(): AnyRef

def commit[T](p: ⇒ Parser[T]): Parser[T]

lazy val digit: Parser[Elem]

lazy val digit19: Parser[Elem]

lazy val digits: Parser[List[Elem]]

lazy val e: Parser[Int]

def elem(e: Elem): Parser[Elem]

def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

lazy val elements: Parser[List[Any]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def err(msg: String): Parser[Nothing]

lazy val exp: Parser[Int]

def failure(msg: String): Parser[Nothing]

def finalize(): Unit

implicit def flatten2[A, B, C](f: (A, B) ⇒ C): (~[A, B]) ⇒ C

implicit def flatten3[A, B, C, D](f: (A, B, C) ⇒ D): (~[~[A, B], C]) ⇒ D

implicit def flatten4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (~[~[~[A, B], C], D]) ⇒ E

implicit def flatten5[A, B, C, D, E, F](f: (A, B, C, D, E) ⇒ F): (~[~[~[~[A, B], C], D], E]) ⇒ F

lazy val frac: Parser[String]

final def getClass(): Class[_]

def guard[T](p: ⇒ Parser[T]): Parser[T]

def hashCode(): Int

implicit def headOptionTailToFunList[A, T](f: (List[A]) ⇒ T): (~[A, Option[List[A]]]) ⇒ T

lazy val hexDigit: Parser[Elem]

lazy val intExp: Parser[Double]

lazy val intFrac: Parser[Double]

lazy val intFracExp: Parser[Double]

final def isInstanceOf[T0]: Boolean

lazy val isfalse: Parser[Boolean]

lazy val isnull: Parser[Empty.type]

lazy val istrue: Parser[Boolean]

lazy val jsonObject: Parser[Map[String, Any]]

def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

lazy val manyCharInt: Parser[Double]

lazy val members: Parser[List[(String, Any)]]

def mkList[T]: (~[T, List[T]]) ⇒ List[T]

final def ne(arg0: AnyRef): Boolean

def not[T](p: ⇒ Parser[T]): Parser[Unit]

final def notify(): Unit

final def notifyAll(): Unit

lazy val number: Parser[Double]

def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

lazy val pair: Parser[(String, Any)]

def pairChar(in: Char): Boolean