object Json extends JsonFacade
- Alphabetic
- By Inheritance
- Json
- JsonFacade
- AnyRef
- Any
- Hide All
- Show All
- 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 :
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
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- 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: AnyRef): 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.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 ECreates a
Format[E]
by automatically creating Reads[E] and Writes[E] for any Enumeration Eimport 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[_ <: AnyRef]
- 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.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.
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, ifT
is a ValueClass (see valueReads and valueWrites).Creates a
OFormat[T]
by resolving, ifT
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]
, ifA
is a ValueClass, by resolving at compile-time theReads
for the underlying type.Creates a
Reads[A]
, ifA
is a ValueClass, by resolving at compile-time theReads
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]
, ifT
is a ValueClass, by resolving at compile-time theWrites
for the underlying type.Creates a
OWrites[T]
, ifT
is a ValueClass, by resolving at compile-time theWrites
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(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- 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.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))
- object MacroOptions