grapple.json

Provides JSON utilities.

import scala.language.implicitConversions

import grapple.json.{ *, given }

// Create JSON object
val user = Json.obj("id" -> 1000, "name" -> "lupita")

// Create JSON array
val info = Json.arr(user, "/home/lupita", 8L * 1024 * 1024 * 1024)

// Parse JSON text
val root = Json.parse("""{ "id": 0, "name": "root" }""")

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

given userOutput: JsonOutput[User] with
 def write(u: User) = Json.obj("id" -> u.id, "name" -> u.name)

// Convert value to JSON object
val nobody = Json.toJson(User(65534, "nobody"))

Defines JSON array.

Provides JSON array factory.

Defines JSON array builder.

import scala.language.implicitConversions

import grapple.json.{ *, given }

val user = JsonArrayBuilder()
 .add(1000)
 .add("lupita")
 .add(Set("lupita", "sudoer"))
 .build()

assert { user(0).as[Int] == 1000 }
assert { user(1).as[String] == "lupita" }
assert { user(2).as[Set[String]] == Set("lupita", "sudoer") }

Defines JSON boolean.

Provides JSON boolean factory.

Defines JSON exception.

Represents JSON false.

Defines JSON generator.

import java.io.StringWriter

import scala.language.implicitConversions

import grapple.json.{ *, given }

val buf = StringWriter()
val out = JsonGenerator(buf)

try
 out.writeStartObject()          // start root object
 out.write("id", 1000)
 out.write("name", "lupita")
 out.writeStartArray("groups")   // start nested array
 out.write("lupita")
 out.write("admin")
 out.write("sudoer")
 out.writeEnd()                  // end nested array
 out.writeStartObject("info")    // start nested object
 out.write("home", "/home/lupita")
 out.write("storage", "8 GiB")
 out.writeEnd()                  // end nested object
 out.writeEnd()                  // end root object
 out.flush()

 val json = Json.parse(buf.toString)
 assert { json("id") == JsonNumber(1000) }
 assert { json("name") == JsonString("lupita") }
 assert { json("groups") == Json.arr("lupita", "admin", "sudoer") }
 assert { json("info") == Json.obj("home" -> "/home/lupita", "storage" -> "8 GiB") }
finally
 out.close()

Provides JSON generator factory.

Defines JSON generator error.

Defines JSON input conversion.

import scala.language.implicitConversions

import grapple.json.{ *, given }

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

// Define how to convert JsonValue to User
given userInput: JsonInput[User] =
 case json: JsonObject => User(json("id"), json("name"))
 case _                => throw IllegalArgumentException("Expected JSON object")

val json = Json.obj("id" -> 0, "name" -> "root")
assert { json.as[User] == User(0, "root") }

Defines JSON null.

Represents JSON null.

Defines JSON number.

Provides JSON number factory.

Defines JSON object.

Provides JSON object factory.

Defines JSON object builder.

import scala.language.implicitConversions

import grapple.json.{ *, given }

val user = JsonObjectBuilder()
 .add("id", 1000)
 .add("name", "lupita")
 .add("groups", Set("lupita", "sudoer"))
 .build()

assert { user("id").as[Int] == 1000 }
assert { user("name").as[String] == "lupita" }
assert { user("groups").as[Set[String]] == Set("lupita", "sudoer") }

Defines JSON output conversion.

import scala.language.implicitConversions

import grapple.json.{ *, given }

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

// Define how to convert User to JsonValue
given userOutput: JsonOutput[User] =
 user => Json.obj("id" -> user.id, "name" -> user.name)

val users = Json.arr(User(0, "root"), User(1000, "lupita"))
assert { users(0) == Json.obj("id" -> 0, "name" -> "root") }
assert { users(1) == Json.obj("id" -> 1000, "name" -> "lupita") }

Defines JSON parser.

import scala.language.implicitConversions

import grapple.json.{ *, given }
import grapple.json.JsonParser.Event

val parser = JsonParser("""{ "id": 1000, "name": "lupita", "groups": ["lupita", "admin"] }""")

try
 // Get first event (start root object)
 assert { parser.next() == Event.StartObject }

 // Get field name and value
 assert { parser.next() == Event.FieldName("id") }
 assert { parser.next() == Event.Value(1000) }

 // Get field name and value
 assert { parser.next() == Event.FieldName("name") }
 assert { parser.next() == Event.Value("lupita") }

 // Get field name and value
 assert { parser.next() == Event.FieldName("groups") }
 assert { parser.next() == Event.StartArray } // start nested array
 assert { parser.next() == Event.Value("lupita") }
 assert { parser.next() == Event.Value("admin") }
 assert { parser.next() == Event.EndArray }   // end nested array

 // Get final event (end root object)
 assert { parser.next() == Event.EndObject }

 // No more events
 assert { !parser.hasNext }
finally
 parser.close()

Provides JSON parser factory and other utilities.

Defines JSON parser error.

Defines JSON reader.

import scala.language.implicitConversions

import grapple.json.{ *, given }

val in = JsonReader("""{ "id": 1000, "name": "lupita" }""")

try
 val user = in.read()
 assert { user("id").as[Int] == 1000 }
 assert { user("name").as[String] == "lupita" }
finally
 in.close()

Provides JSON reader factory.

Defines JSON string.

Provides JSON string factory.

Defines JSON structure.

Represents JSON true.

Defines JSON value.

Defines JSON writer.

import java.io.StringWriter

import scala.language.implicitConversions

import grapple.json.{ *, given }

val buf = StringWriter()
val out = JsonWriter(buf)

try
 val user = Json.obj("id" -> 1000, "name" -> "lupita")
 out.write(user)

 val json = Json.parse(buf.toString)
 assert { json == user }
finally
 out.close()

Provides JSON writer factory.

Converts Array to JsonArray.

Converts BigDecimal to JsonNumber.

Converts BigInt to JsonNumber.

Converts Boolean to JsonBoolean.

Converts Byte to JsonNumber.

Converts Double to JsonNumber.

Converts Right to JsonValue using right converter or converts Left using left.

Converts Failure to JsonNull.

Converts Float to JsonNumber.

Converts Int to JsonNumber.

Converts Iterable to JsonArray.

Applies conversion using JsonInput.

Applies conversion using JsonOutput.

Converts JsonValue to BigDecimal.

Converts JsonValue to BigInt.

Converts JsonValue to Boolean.

Converts JsonValue to Byte.

Converts JsonValue to collection of converted values.

Converts JsonValue to Double.

Converts JsonValue to Right using right converter or to Left using left if right is unsuccessful.

Converts JsonValue to Float.

Converts JsonValue to Int.

Casts JsonValue to JsonArray.

Casts JsonValue to JsonBoolean.

Casts JsonValue to JsonNull.

Casts JsonValue to JsonNumber.

Casts JsonValue to JsonObject.

Casts JsonValue to JsonString.

Returns JsonValue as is.

This instance is required to perform actions such as the following:

import scala.language.implicitConversions

import grapple.json.{ Json, JsonValue, given }

val json = Json.obj("values" -> Json.arr("abc", 123, true))

// Requires jsonValueToJsonValue
val list = json("values").as[List[JsonValue]]

Converts JsonValue to Long.

Converts JsonValue to Some or returns None if value is JsonNull.

Converts JsonValue to Short.

Converts JsonValue to String.

Converts JsonValue to Success or returns Failure if unsuccessful.

Converts Left to JsonValue.

Converts Long to JsonNumber.

Converts Map to JsonObject.

Converts None to JsonNull.

Converts Some to JsonValue or returns JsonNull if None.

Converts Right to JsonValue.

Converts Short to JsonNumber.

Converts String to JsonString.

Applies conversion using JsonInput[JsonArray].

Applies conversion using JsonInput[JsonObject].

Converts Success to JsonValue or returns JsonNull if Failure.

Converts (String, T) to (String, JsonValue).