Json

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def arr(fields: JsValueWrapper*): JsArray

final def asInstanceOf[T0]: T0

def asciiStringify(json: JsValue): String

Convert a JsValue to its string representation, escaping all non-ascii characters using \uXXXX syntax.

scala> Json.asciiStringify(JsString("some\u2028text\u2029"))
res0: String = "some\u2028text\u2029"

scala> Json.stringify(JsString("some\u2028text\u2029"))
res1: String = "sometext"

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

macro def format[A]: OFormat[A]

Creates a Format[T] by resolving case class fields & required implicits at COMPILE-time

import play.api.libs.json.Json

case class User(name: String, age: Int)

implicit val userWrites = Json.format[User]
// macro-compiler replaces Json.format[User] by injecting into compile chain
// the exact code you would write yourself. This is strictly equivalent to:
implicit val userWrites = (
   (__ \ 'name).format[String] and
   (__ \ 'age).format[Int]
)(User.apply, unlift(User.unapply))

def fromJson[T](json: JsValue)(implicit fjs: Reads[T]): JsResult[T]

Provided a Reads implicit for that type is available, convert a JsValue to any type.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def obj(fields: (String, JsValueWrapper)*): JsObject

def parse(input: Array[Byte]): JsValue

Parse a byte array representing a json, and return it as a JsValue.

def parse(input: InputStream): JsValue

Parse an InputStream representing a json, and return it as a JsValue.

def parse(input: String): JsValue

Parse a String representing a json, and return it as a JsValue.

def prettyPrint(json: JsValue): String

Convert a JsValue to its pretty string representation using default Jackson pretty printer (line feeds after each fields and 2-spaces indentation).

scala> Json.stringify(Json.obj(
  "field1" -> Json.obj(
    "field11" -> "value11",
    "field12" -> Json.arr("alpha", 123L)
  )
))
res0: String = {"field1":{"field11":"value11","field12":["alpha",123]}}

scala> Json.prettyPrint(res0)
res1: String =
{
  "field1" : {
    "field11" : "value11",
    "field12" : [ "alpha", 123 ]
  }
}

macro def reads[A]: Reads[A]

Creates a Reads[T] by resolving case class fields & required implicits at COMPILE-time.

import play.api.libs.json.Json

case class User(name: String, age: Int)

implicit val userReads = Json.reads[User]
// macro-compiler replaces Json.reads[User] by injecting into compile chain
// the exact code you would write yourself. This is strictly equivalent to:
implicit val userReads = (
   (__ \ 'name).read[String] and
   (__ \ 'age).read[Int]
)(User)

def stringify(json: JsValue): String

Convert a JsValue to its string representation.

scala> Json.stringify(Json.obj(
  "field1" -> Json.obj(
    "field11" -> "value11",
    "field12" -> Json.arr("alpha", 123L)
  )
))
res0: String = {"field1":{"field11":"value11","field12":["alpha",123]}}

scala> Json.stringify(res0)
res1: String = {"field1":{"field11":"value11","field12":["alpha",123]}}

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

implicit def toJsFieldJsValueWrapper[T](field: T)(implicit w: Writes[T]): JsValueWrapper

def toJson[T](o: T)(implicit tjs: Writes[T]): JsValue

Provided a Writes implicit for its type is available, convert any object into a JsValue.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

macro def writes[A]: OWrites[A]

Creates a Writes[T] by resolving case class fields & required implicits at COMPILE-time

import play.api.libs.json.Json

case class User(name: String, age: Int)

implicit val userWrites = Json.writes[User]
// macro-compiler replaces Json.writes[User] by injecting into compile chain
// the exact code you would write yourself. This is strictly equivalent to:
implicit val userWrites = (
   (__ \ 'name).write[String] and
   (__ \ 'age).write[Int]
)(unlift(User.unapply))

def fromJson[A](implicit arg0: Reads[A]): Enumeratee[JsValue, A]

Transform a stream of JsValue to a stream of A, keeping only successful results

val jsonStream: Enumerator[JsValue] = ???
val fooStream: Enumerator[Foo] = jsonStream &> Json.fromJson

def toJson[A](implicit arg0: Writes[A]): Enumeratee[A, JsValue]

Transform a stream of A to a stream of JsValue

val fooStream: Enumerator[Foo] = ???
val jsonStream: Enumerator[JsValue] = fooStream &> Json.toJson