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.
import play.api.libs.json._, Json._ type Opts = 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:
import play.api.libs.json._ JsObject(Seq( "key1" -> JsString("value"), "key2" -> JsNumber(123), "key3" -> JsObject(Seq("key31" -> JsString("value31"))) )) == Json.obj( "key1" -> "value", "key2" -> 123, "key3" -> Json.obj("key31" -> "value31")) JsArray(Seq(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.
import play.api.libs.json.Json case class Foo(v: String) 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
import play.api.libs.json.Json Json.using[Json.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).
import play.api.libs.json.{ Json, JsString } Json.asciiStringify(JsString("some\\u005Ctext\\u005C")) // => "some\\u005Ctext\\u005C" Json.stringify(JsString("some\\u005Ctext\\u005C")) // => "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[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @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: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[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.functional.syntax._ import play.api.libs.json.{ Json, JsonConfiguration, __ } case class User(userName: String, age: Int) val userFormat1 = 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: val userFormat2 = ( (__ \ 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.{ Format, Json } object DayOfWeek extends Enumeration { type DayOfWeek = Value val Mon = Value("Monday") val Tue = Value("Tuesday") val Wed = Value("Wednesday") // etc. implicit val format1: Format[DayOfWeek] = Json.formatEnum(DayOfWeek) // or 'this' if defining directly in Enum implicit val format2: 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).
import play.api.libs.json.Json val res0 = Json.obj( "field1" -> Json.obj( "field11" -> "value11", "field12" -> Json.arr("alpha", 123L) ) ) // => {"field1":{"field11":"value11","field12":["alpha",123]}} Json.prettyPrint(res0) // => // { // "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.functional.syntax._ import play.api.libs.json.{ Json, JsonConfiguration, __ } case class User(userName: String, age: Int) implicit val userReads1 = 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 userReads2 = ( (__ \ 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.
import play.api.libs.json.Json val input = Json.obj( "field1" -> Json.obj( "field11" -> "value11", "field12" -> Json.arr("alpha", 123L) ) ) Json.stringify(input) // => {"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.valueWrites[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
- @throws( ... ) @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.functional.syntax._ import play.api.libs.json.{ Json, JsonConfiguration, __ } case class User(userName: String, age: Int) implicit val userWrites1 = 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 userWrites2 = ( (__ \ implicitly[JsonConfiguration].naming("userName")).write[String] and (__ \ implicitly[JsonConfiguration].naming("age")).write[Int] )(unlift(User.unapply))
- object MacroOptions