Json

object Json extends JsonFacade

Helper functions to handle JsValues.

Source: Json.scala

Linear Supertypes

JsonFacade, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

Json
JsonFacade
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

trait DefaultValues extends AnyRef
Flag to indicate the macros can use the type default values (e.g.
Flag to indicate the macros can use the type default values (e.g. default values for the case class parameters) when applicable.
```
MacroOptions with DefaultValues
```

sealed trait JsValueWrapper extends AnyRef

Next is the trait that allows Simplified Json syntax :

Example :

JsObject(Seq(
   "key1" -> JsString("value"),
   "key2" -> JsNumber(123),
   "key3" -> JsObject(Seq("key31" -> JsString("value31")))
)) == Json.obj( "key1" -> "value", "key2" -> 123, "key3" -> obj("key31" -> "value31"))

JsArray(JsString("value"), JsNumber(123), JsBoolean(true)) == Json.arr( "value", 123, true )

There is an implicit conversion from any Type with a Json Writes to JsValueWrapper which is an empty trait that shouldn't end into unexpected implicit conversions.

sealed trait MacroOptions extends AnyRef
Compile-time base options for macro usage.
Compile-time base options for macro usage.
```
Json.using[Json.MacroOptions].format[Foo]
// equivalent to Json.format[Foo]
```
type WithDefaultValues = MacroOptions with DefaultValues
Alias for MacroOptions with DefaultValues
Alias for MacroOptions with DefaultValues
```
Json.using[WithDefaultValues]
```
final class WithOptions[Opts <: MacroOptions] extends JsonFacade
JSON facade with some macro options.
JSON facade with some macro options.
Opts
the compile-time options

Value Members

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
def arr(items: JsValueWrapper*): JsArray
Returns a JsArray with given items.
Returns a JsArray with given items.

Definition Classes
Json → JsonFacade
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asciiStringify(json: JsValue): String
Converts a JsValue to its string representation, escaping all non-ascii characters using \uXXXX syntax.
Converts a JsValue to its string representation, escaping all non-ascii characters using \uXXXX syntax.
This is particularly useful when the output JSON will be executed as javascript, since JSON is not a strict subset of javascript (see JSON: The JavaScript subset that isn't).
```
scala> Json.asciiStringify(JsString("some\u2028text\u2029"))
res0: String = "some\u2028text\u2029"

scala> Json.stringify(JsString("some\u2028text\u2029"))
res1: String = "sometext"
```
json
the JsValue to convert A String with the json representation with all non-ascii characters escaped.

Definition Classes
Json → JsonFacade
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
def configured[Opts <: MacroOptions](implicit config: Aux[Opts]): WithOptions[Opts]
Returns a JsonFacade using the current JSON configuration.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

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

macro def format[A]: OFormat[A]

Creates a OFormat[T] by resolving, at compile-time, the case class fields or sealed family, and the required implicits.

If any missing implicit is discovered, compiler will break with corresponding error.

A

the type for which the handler must be materialized

import play.api.libs.json.Json

case class User(userName: 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 = (
   (__ \ implicitly[JsonConfiguration].naming("userName")).format[String] and
   (__ \ implicitly[JsonConfiguration].naming("age")).format[Int]
)(User.apply, unlift(User.unapply))

def formatEnum[E <: Enumeration](enum: E): Format[Json.formatEnum.E.Value]

Creates a Format[E] by automatically creating Reads[E] and Writes[E] for any Enumeration E

import play.api.libs.json.Json

object DayOfWeek extends Enumeration {

 type DayOfWeek = Value

 val Mon = Value("Monday")
 val Tue = Value("Tuesday")
 val Wed = Value("Wednesday")
 // etc.

  implicit val format: Format[DayOfWeek] = Json.formatEnum(DayOfWeek)
  // or 'this' if defining directly in Enum
  implicit val format: Format[DayOfWeek] = Json.formatEnum(this)
}

Json.toJson(Mon) will produce "Monday"

E: type of Enum
enum: Enumeration object

def fromJson[T](json: JsValue)(implicit fjs: Reads[T]): JsResult[T]
Converts a JsValue to a value of requested type T.
Converts a JsValue to a value of requested type T.
T
The type of conversion result, only supported if a Reads implicit is available for.
json
the JsValue to convert

Definition Classes
Json → JsonFacade
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
def obj(fields: (String, JsValueWrapper)*): JsObject
Returns a JsObject with given fields.
Returns a JsObject with given fields.
fields
the object fields specified as pairs of name and value

Definition Classes
Json → JsonFacade
def parse(input: Array[Byte]): JsValue
Parses some bytes representing a JSON input, and returns it as a JsValue.
Parses some bytes representing a JSON input, and returns it as a JsValue.
The character encoding used will be automatically detected as UTF-8, UTF-16 or UTF-32, as per the heuristics in RFC-4627.
input
the byte array to parse

Definition Classes
Json → JsonFacade
def parse(input: InputStream): JsValue
Parses a stream representing a JSON input, and returns it as a JsValue.
Parses a stream representing a JSON input, and returns it as a JsValue.
input
the InputStream to parse

Definition Classes
Json → JsonFacade
def parse(input: String): JsValue
Parses a String representing a JSON input, and returns it as a JsValue.
Parses a String representing a JSON input, and returns it as a JsValue.
input
the String to parse

Definition Classes
Json → JsonFacade
def prettyPrint(json: JsValue): String
Converts a JsValue to its pretty string representation using default pretty printer (line feeds after each fields and 2-spaces indentation).
Converts a JsValue to its pretty string representation using default 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 ]
  }
}
```
json
the JsValue to convert A String with the json representation.

Definition Classes
Json → JsonFacade

macro def reads[A]: Reads[A]

Creates a Reads[A] by resolving, at compile-time, the case class fields or sealed family, and the required implicits.

If any missing implicit is discovered, compiler will break with corresponding error.

A

the type for which the handler must be materialized

import play.api.libs.json.Json

case class User(userName: 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 = (
   (__ \ implicitly[JsonConfiguration].naming("userName")).read[String] and
   (__ \ implicitly[JsonConfiguration].naming("age")).read[Int]
)(User)

def stringify(json: JsValue): String

Converts 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]}}

json: the JsValue to convert
returns: a String with the json representation

Definition Classes: Json → JsonFacade

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

Definition Classes
AnyRef
def toBytes(json: JsValue): Array[Byte]
Converts a JsValue to bytes (using UTF-8 encoding).
Converts a JsValue to bytes (using UTF-8 encoding).
json
the JsValue to convert
returns
an Array[Byte] representing the UTF-8-encoded JSON

Definition Classes
Json → JsonFacade
implicit def toJsFieldJsValueWrapper[T](field: T)(implicit w: Writes[T]): JsValueWrapper
def toJsObject[T](o: T)(implicit tjs: OWrites[T]): JsObject
Converts any object writeable value to a JsObject.
Converts any object writeable value to a JsObject.
A value is writeable as an object, if a OWrites implicit is available for its type.
T
the type of the value to be written as JsObject
o
the value to convert as JSON object

Definition Classes
Json → JsonFacade
def toJson[T](o: T)(implicit tjs: Writes[T]): JsValue
Converts any writeable value to a JsValue.
Converts any writeable value to a JsValue.
A value is writeable if a Writes implicit is available for its type.
T
the type of the value to be written as JSON
o
the value to convert as JSON

Definition Classes
Json → JsonFacade
def toString(): String

Definition Classes
AnyRef → Any
def using[Opts <: MacroOptions]: WithOptions[Opts]
Returns an inference context to call the JSON macros, using explicit compile-time options.
Returns an inference context to call the JSON macros, using explicit compile-time options.
Opts
the compile-time options
macro def valueFormat[A]: Format[A]
Creates a OFormat[T] by resolving, if T is a ValueClass (see valueReads and valueWrites).
Creates a OFormat[T] by resolving, if T is a ValueClass (see valueReads and valueWrites).
If any missing implicit is discovered, compiler will break with corresponding error.
A
the type for which the handler must be materialized
```
import play.api.libs.json.{ Format, Json }

final class User(val name: String) extends AnyVal

implicit val userFormat: Format[User] = Json.valueFormat[User]
```
macro def valueReads[A]: Reads[A]
Creates a Reads[A], if A is a ValueClass, by resolving at compile-time the Reads for the underlying type.
Creates a Reads[A], if A is a ValueClass, by resolving at compile-time the Reads for the underlying type.
If any missing implicit is discovered, compiler will break with corresponding error.
A
the type for which the handler must be materialized
```
import play.api.libs.json.{ Json, Reads }

final class IdText(val value: String) extends AnyVal

// Based on provided Reads[String] corresponding to `value: String`
val r: Reads[IdText] = Json.valueReads
```
macro def valueWrites[A]: Writes[A]
Creates a OWrites[T], if T is a ValueClass, by resolving at compile-time the Writes for the underlying type.
Creates a OWrites[T], if T is a ValueClass, by resolving at compile-time the Writes for the underlying type.
If any missing implicit is discovered, compiler will break with corresponding error.
A
the type for which the handler must be materialized
```
import play.api.libs.json.{ Json, Writes }

final class TextId(val value: String) extends AnyVal

// Based on provided Writes[String] corresponding to `value: String`
val w: Writes[TextId] = Json.writes[TextId]
```
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( ... )

macro def writes[A]: OWrites[A]

Creates a OWrites[T] by resolving, at compile-time, the case class fields or sealed family, and the required implicits.

If any missing implicit is discovered, compiler will break with corresponding error.

A

the type for which the handler must be materialized

import play.api.libs.json.Json

case class User(userName: 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 = (
   (__ \ implicitly[JsonConfiguration].naming("userName")).write[String] and
   (__ \ implicitly[JsonConfiguration].naming("age")).write[Int]
)(unlift(User.unapply))

Packages

Play

Access the current Play application

Read configuration

Use the logger

Define a Plugin

Create adhoc applications (for testing)

Json

object Json extends JsonFacade

Type Members

Value Members

Inherited from JsonFacade

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Play

Access the current Play application

Read configuration

Use the logger

Define a Plugin

Create adhoc applications (for testing)

Json 

object Json extends JsonFacade

Type Members

Value Members

Inherited from JsonFacade

Inherited from AnyRef

Inherited from Any

Ungrouped

Json