little.json

Provides extension methods and implicit conversions.

Provides JSON utilities.

import little.json.*
import little.json.Implicits.given
import scala.language.implicitConversions

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

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

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

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

given userToJson: JsonOutput[User] with
 def apply(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 little.json.*
import little.json.Implicits.given
import scala.language.implicitConversions

val user = JsonArrayBuilder()
 .add(1000)
 .add("jza")
 .add(Set("jza", "sudo"))
 .build()

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

Defines JSON boolean.

Provides JSON boolean factory.

Defines JSON exception.

Represents JSON false.

Defines JSON generator.

import java.io.StringWriter
import little.json.*
import little.json.Implicits.given
import scala.language.implicitConversions

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

try
 out.writeStartObject()          // start root object
 out.write("id", 1000)
 out.write("name", "jza")
 out.writeStartArray("groups")   // start nested array
 out.write("jza")
 out.write("adm")
 out.write("sudo")
 out.writeEnd()                  // end nested array
 out.writeStartObject("info")    // start nested object
 out.write("home", "/home/jza")
 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("jza") }
 assert { json("groups") == Json.arr("jza", "adm", "sudo") }
 assert { json("info") == Json.obj("home" -> "/home/jza", "storage" -> "8 GiB") }
finally
 out.close()

Provides JSON generator factory.

Defines JSON generator error.

Defines JSON input conversion.

import little.json.*
import little.json.Implicits.given
import scala.language.implicitConversions

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

// Define how to convert JsonValue to User
given jsonToUser: JsonInput[User] with
 def apply(json: JsonValue) = User(json("id"), json("name"))

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 little.json.*
import little.json.Implicits.given
import scala.language.implicitConversions

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

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

Defines JSON output conversion.

import little.json.*
import little.json.Implicits.given
import scala.language.implicitConversions

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

// Define how to convert User to JsonValue
given userToJson: JsonOutput[User] with
 def apply(u: User) = Json.obj("id" -> u.id, "name" -> u.name)

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

Defines JSON parser.

import little.json.*
import little.json.Implicits.given
import scala.language.implicitConversions

import JsonParser.Event

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

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("jza") }

 // Get field name and value
 assert { parser.next() == Event.FieldName("groups") }
 assert { parser.next() == Event.StartArray } // start nested array
 assert { parser.next() == Event.Value("jza") }
 assert { parser.next() == Event.Value("adm") }
 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 little.json.*
import little.json.Implicits.given
import scala.language.implicitConversions

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

try
 val user = in.read()
 assert { user("id").as[Int] == 1000 }
 assert { user("name").as[String] == "jza" }
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 little.json.*
import little.json.Implicits.given
import scala.language.implicitConversions

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

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

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

Provides JSON writer factory.