object JSONParser

object JSONParser

 extends SafeSeqParser with ImplicitConversions

Source: JSONParser.scala(24)


def this


achar.. lazy val achar Parser[Char]
anInt.. lazy val anInt Parser[Long]
array.. lazy val array Parser[List[Any]]
bchar.. lazy val bchar Parser[Char]
digit.. lazy val digit Parser[Char]
digit19.. lazy val digit19 Parser[Char]
digits.. lazy val digits Parser[List[Char]]
e.. lazy val e Parser[Int]
elements.. lazy val elements Parser[List[Any]]
exp.. lazy val exp Parser[Int]
frac.. lazy val frac Parser[String]
hexDigit.. lazy val hexDigit Parser[Char]
intExp.. lazy val intExp Parser[Double]
intFrac.. lazy val intFrac Parser[Double]
intFracExp.. lazy val intFracExp Parser[Double]
isfalse.. lazy val isfalse Parser[Boolean]
isnull.. lazy val isnull Parser[Empty]
istrue.. lazy val istrue Parser[Boolean]
jsonObject.. lazy val jsonObject Parser[Map[String, Any]]
lastNoSuccess.. var lastNoSuccess NoSuccess Parsers
manyCharInt.. lazy val manyCharInt Parser[Double]
members.. lazy val members Parser[List[(String, Any)]]
number.. lazy val number Parser[Double]
pair.. lazy val pair Parser[(String, Any)]
pairId.. lazy val pairId Parser[String]
spaces.. lazy val spaces Parser[List[Char]]
string.. lazy val string Parser[String]
theValue.. lazy val theValue Parser[Any]
whitespace.. lazy val whitespace Parser[Char]


!=.. final def !=(arg0 : Any) Boolean Any
!=.. final def !=(arg0 : Object) Boolean AnyRef
==.. final def ==(arg0 : Object) Boolean AnyRef
==.. final def ==(arg0 : Any) Boolean Any
OnceParser.. def OnceParser[T](arg0 : (Reader) => ParseResult[T]) Parser[T] with OnceParser[T] Parsers
Parser.. def Parser[T](arg0 : (Reader) => ParseResult[T]) Parser[T] Parsers
accept.. def accept[ES](arg0 : ES) Parser[List[Elem]] Parsers
accept.. def accept[U](arg0 : String, arg1 : PartialFunction[Elem, U]) Parser[U] Parsers
accept.. implicit def accept(arg0 : Elem) Parser[Elem] Parsers
acceptIf.. def acceptIf(arg0 : (Elem) => Boolean) Parser[Elem] Parsers
acceptMatch.. def acceptMatch[U](arg0 : String, arg1 : PartialFunction[Elem, U]) Parser[U] Parsers
acceptSeq.. def acceptSeq[ES](arg0 : ES) Parser[List[Elem]] Parsers
asInstanceOf.. final def asInstanceOf[T0] T0 Any
chainl1.. def chainl1[T, U](arg0 : => Parser[T], arg1 : => Parser[U], arg2 : => Parser[(T, U) => T]) Parser[T] Parsers
chainl1.. def chainl1[T](arg0 : => Parser[T], arg1 : => Parser[(T, T) => T]) Parser[T] Parsers
chainr1.. def chainr1[T, U](arg0 : => Parser[T], arg1 : => Parser[(T, U) => U], arg2 : (T, U) => U, arg3 : U) Parser[U] Parsers
clone.. protected def clone Object AnyRef
commit.. def commit[T](arg0 : => Parser[T]) Parser[T] Parsers
elem.. def elem(arg0 : Elem) Parser[Elem] Parsers
elem.. def elem(arg0 : String, arg1 : (Elem) => Boolean) Parser[Elem] Parsers
eq.. final def eq(arg0 : Object) Boolean AnyRef
equals.. def equals(arg0 : Any) Boolean AnyRef
err.. def err(arg0 : String) Parser[Nothing] Parsers
failure.. def failure(arg0 : String) Parser[Nothing] Parsers
finalize.. protected def finalize Unit AnyRef
flatten2.. implicit def flatten2[A, B, C](arg0 : (A, B) => C) (~[A, B]) => C ImplicitConversions
flatten3.. implicit def flatten3[A, B, C, D](arg0 : (A, B, C) => D) (~[~[A, B], C]) => D ImplicitConversions
flatten4.. implicit def flatten4[A, B, C, D, E](arg0 : (A, B, C, D) => E) (~[~[~[A, B], C], D]) => E ImplicitConversions
flatten5.. implicit def flatten5[A, B, C, D, E, F](arg0 : (A, B, C, D, E) => F) (~[~[~[~[A, B], C], D], E]) => F ImplicitConversions
getClass.. final def getClass Class[Any] AnyRef
hashCode.. def hashCode Int AnyRef
headOptionTailToFunList.. implicit def headOptionTailToFunList[A, T](arg0 : (List[A]) => T) (~[A, Option[List[A]]]) => T ImplicitConversions
isInstanceOf.. final def isInstanceOf[T0] Boolean Any
log.. def log[T](arg0 : => Parser[T]) Parser[T] Parsers
mkList.. def mkList[T] (~[T, List[T]]) => List[T] Parsers
ne.. final def ne(arg0 : Object) Boolean AnyRef
not.. def not[T](arg0 : => Parser[T]) Parser[Unit] Parsers
notify.. final def notify Unit AnyRef
notifyAll.. final def notifyAll Unit AnyRef
opt.. def opt[T](arg0 : => Parser[T]) Parser[Option[T]] Parsers
pairChar.. def pairChar(in : Char) Boolean
parse.. def parse(in : String)
Parse a JSON structure [details]
A JSON structure is a JSON array or JSON object (which may contain other arrays or objects). See 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.
- a Box containig the root JSON object or JSON array.
phrase.. def phrase[T](arg0 : Parser[T]) Parser[T] Parsers
positioned.. def positioned[T <: Positional](arg0 : => Parser[T]) Parser[T] Parsers
rep.. def rep[T](arg0 : => Parser[T]) Parser[List[T]] Parsers
rep1.. override def rep1[T](first : => Parser[T], p : => Parser[T])
A parser generator for non-empty repetitions [details]

rep1(f, p) first uses `f' (which must succeed) and then repeatedly uses `p' to parse the input until `p' fails (the result is a `List' of the consecutive results of `f' and `p')

p - a `Parser' that is to be applied successively to the rest of the input (if any)
first - a `Parser' that parses the first piece of input
- A parser that returns a list of results produced by first applying `f' and then repeatedly `p' to the input (it only succeeds if `f' matches).
Parser[List[T]] SafeSeqParser
rep1.. def rep1[T](arg0 : => Parser[T]) Parser[List[T]] Parsers
rep1sep.. override def rep1sep[T](p : => Parser[T], q : => Parser[Any])
A parser generator for non-empty repetitions [details]

rep1sep(first, p, q) starts by using `first', followed by repeatedly uses of `p' interleaved with `q' to parse the input, until `p' 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')
first - a `Parser' that is to be applied to the first element of input
- A parser that returns a list of results produced by repeatedly applying `p' to the input (and that only succeeds if `p' matches at least once). The results of `p' are collected in a list. The results of `q' are discarded.
Parser[List[T]] SafeSeqParser
repN.. def repN[T](arg0 : Int, arg1 : => Parser[T]) Parser[List[T]] Parsers
repsep.. def repsep[T](arg0 : => Parser[T], arg1 : => Parser[Any]) Parser[List[T]] Parsers
strToInput.. implicit def strToInput(in : String) Reader
success.. def success[T](arg0 : T) Parser[T] Parsers
synchronized.. final def synchronized[T0](arg0 : T0) T0 AnyRef
toString.. def toString String AnyRef
unapply.. def unapply(in : Any) Option[Any]
wait.. final def wait Unit AnyRef
wait.. final def wait(arg0 : Long) Unit AnyRef
wait.. final def wait(arg0 : Long, arg1 : Int) Unit AnyRef
Copyright (c) 2006-2010 WorldWide Conferencing, LLC. All Rights Reserved.