Module `Data_encoding.Json`Source

Sourcetype json = [

| `O of (string * json) list
| `Bool of bool
| `Float of float
| `A of json list
| `Null
| `String of string

]

In memory JSON data, compatible with Ezjsonm.

Sourcetype t = json

Sourcetype schema = Json_schema.schema

Sourceval encoding : json Encoding.t

Encodes raw JSON data (BSON is used for binary).

Sourceval schema_encoding : schema Encoding.t

Encodes a JSON schema (BSON encoded for binary).

Sourceval convert : 'a Encoding.t -> 'a Json_encoding.encoding

Create a Json_encoding.encoding from an encoding.

Sourceval schema : ?definitions_path:string -> 'a Encoding.t -> schema

Generate a schema from an encoding.

Source

val construct : 
  ?include_default_fields:[ `Always | `Auto | `Never ] ->
  't Encoding.t ->
  't ->
  json

Construct a JSON object from an encoding.

Sourcetype jsonm_lexeme = [

| `Null
| `Bool of bool
| `String of string
| `Float of float
| `Name of string
| `As
| `Ae
| `Os
| `Oe

]

Sourceval construct_seq : 't Encoding.t -> 't -> jsonm_lexeme Seq.t

construct_seq enc t is a representation of t as a sequence of json lexeme (jsonm_lexeme Seq.t). This sequence is lazy: lexemes are computed on-demand.

Source

val string_seq_of_jsonm_lexeme_seq : 
  newline:bool ->
  chunk_size_hint:int ->
  jsonm_lexeme Seq.t ->
  string Seq.t

string_seq_of_jsonm_lexeme_seq ~newline ~chunk_size_hint s is a sequence of strings, the concatenation of which is a valid textual representation of the json value represented by s. Each string chunk is roughly chunk_size_hint long (except the last one that may be shorter).

With the newline parameter set to true, a single newline character is appended to the textual representation.

Forcing one element of the resulting string sequence forces multiple elements of the underlying lexeme sequence. Once enough lexemes have been forced that roughly chunk_size_hint characters are needed to represent them, the representation is returned and the rest of the sequence is held lazily.

Note that most chunks split at a lexeme boundary. This may not be true for string literals or float literals, the representation of which may be spread across multiple chunks.

Source

val small_string_seq_of_jsonm_lexeme_seq : 
  newline:bool ->
  jsonm_lexeme Seq.t ->
  string Seq.t

Source

val blit_instructions_seq_of_jsonm_lexeme_seq : 
  newline:bool ->
  buffer:bytes ->
  jsonm_lexeme Seq.t ->
  (Bytes.t * int * int) Seq.t

blit_instructions_seq_of_jsonm_lexeme_seq ~newline ~buffer json is a sequence of (buff, offset, length) such that the concatenation of the sub-strings thus designated represents the json value in text form.

The intended use is to blit each of the substring onto whatever output the consumer decides. In most cases, the Sequence's buff is physically equal to buffer. This is not always true and one cannot rely on that fact. E.g., when the json includes a long string literal, the function might instruct the consumer to blit from that literal directly.

This function performs few allocations, especially of fresh strings.

Note that once the next element of the sequence is forced, the blit instructions become invalid: the content of buff may have been rewritten by the side effect of forcing the next element.

raises [Invalid_argument]
if Bytes.length buffer is less than 32.

Sourceval destruct : ?bson_relaxation:bool -> 't Encoding.t -> json -> 't

Destruct a JSON object into a value. Fail with an exception if the JSON object and encoding do not match.

parameter [bson_relaxation]
(default to false) works around a limitation of the BSON format. Specifically, in BSON, top-level arrays are represented as number-indexed objects. When bson_relaxation is true, then the destructor attempts to automatically translate the indistinguishable values as guided by the encoding.

JSON Error.

Sourcetype path = path_item list

Sourceand path_item = [

| `Field of string
(*
A field in an object.
*)
| `Index of int
(*
An index in an array.
*)
| `Star
(*
Any / every field or index.
*)
| `Next
(*
The next element after an array.
*)

]

A set of accessors that point to a location in a JSON object.

Sourceexception Cannot_destruct of path * exn

Exception raised by destructors, with the location in the original JSON structure and the specific error.

Sourceexception Unexpected of string * string

Unexpected kind of data encountered, with the expectation.

Sourceexception No_case_matched of exn list

Some union couldn't be destructed, with the reasons for each case.

Sourceexception Bad_array_size of int * int

Array of unexpected size encountered, with the expectation.

Sourceexception Missing_field of string

Missing field in an object.

Sourceexception Unexpected_field of string

Supernumerary field in an object.

Source

val print_error : 
  ?print_unknown:(Format.formatter -> exn -> unit) ->
  Format.formatter ->
  exn ->
  unit

Sourceval cannot_destruct : ('a, Format.formatter, unit, 'b) format4 -> 'a

Helpers for writing encoders.

Sourceval wrap_error : ('a -> 'b) -> 'a -> 'b

Sourceval from_string : string -> (json, string) result

Read a JSON document from a string.

Sourceval to_string : ?newline:bool -> ?minify:bool -> json -> string

Write a JSON document to a string. This goes via an intermediate buffer and so may be slow on large documents.

Sourceval pp : Format.formatter -> json -> unit

package data-encoding

Module Data_encoding.JsonSource

Module `Data_encoding.Json`Source