Packages

object Json extends JsonFacade

Helper functions to handle JsValues.

Source
Json.scala
Linear Supertypes
JsonFacade, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Json
  2. JsonFacade
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. 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
  2. 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.

  3. 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]
  4. type WithDefaultValues = MacroOptions with DefaultValues

    Alias for MacroOptions with DefaultValues

    Alias for MacroOptions with DefaultValues

    Json.using[WithDefaultValues]
  5. 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

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def arr(items: JsValueWrapper*): JsArray

    Returns a JsArray with given items.

    Returns a JsArray with given items.

    Definition Classes
    JsonJsonFacade
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. 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
    JsonJsonFacade
  7. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  8. def configured[Opts <: MacroOptions](implicit config: Aux[Opts]): WithOptions[Opts]

    Returns a JsonFacade using the current JSON configuration.

  9. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  10. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  11. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  12. 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))
  13. 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

    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

  14. 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
    JsonJsonFacade
  15. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  16. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  19. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  20. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  21. 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
    JsonJsonFacade
  22. 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
    JsonJsonFacade
  23. 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
    JsonJsonFacade
  24. 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
    JsonJsonFacade
  25. 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
    JsonJsonFacade
  26. 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)
  27. 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
    JsonJsonFacade
  28. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  29. 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
    JsonJsonFacade
  30. implicit def toJsFieldJsValueWrapper[T](field: T)(implicit w: Writes[T]): JsValueWrapper
  31. 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
    JsonJsonFacade
  32. 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
    JsonJsonFacade
  33. def toString(): String
    Definition Classes
    AnyRef → Any
  34. 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

  35. 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]
  36. 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
  37. 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]
  38. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  39. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  40. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  41. 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))
  42. object MacroOptions

Inherited from JsonFacade

Inherited from AnyRef

Inherited from Any

Ungrouped