···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
-
       
  type t = (string * Jsont.json) list

     

       
8
       
 
       


     

       
9
       
-
       
  let empty = []

     

       
10
       
-
       
  let is_empty = function [] -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type t = {

     
···

       
64
       
 
       
let jsont =

     

       
65
       
 
       
  let kind = "Attachment" in

     

       
66
       
 
       
  let doc = "An attachment object" in

     

       
67
       
-
       
  let unknown_mems :

     

       
68
       
-
       
      (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       
69
       
-
       
    let open Jsont.Object.Mems in

     

       
70
       
-
       
    let dec_empty () = [] in

     

       
71
       
-
       
    let dec_add _meta (name : string) value acc =

     

       
72
       
-
       
      ((name, Jsont.Meta.none), value) :: acc

     

       
73
       
-
       
    in

     

       
74
       
-
       
    let dec_finish _meta mems =

     

       
75
       
-
       
      List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       
76
       
-
       
    in

     

       
77
       
-
       
    let enc =

     

       
78
       
-
       
      {

     

       
79
       
-
       
        enc =

     

       
80
       
-
       
          (fun (type acc)

     

       
81
       
-
       
            (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       
82
       
-
       
            unknown

     

       
83
       
-
       
            (acc : acc)

     

       
84
       
-
       
          ->

     

       
85
       
-
       
            List.fold_left

     

       
86
       
-
       
              (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       
87
       
-
       
              acc unknown);

     

       
88
       
-
       
      }

     

       
89
       
-
       
    in

     

       
90
       
-
       
    map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       
91
       
-
       
  in

     

       
92
       
 
       
  let create_obj url mime_type title size_in_bytes duration_in_seconds unknown =

     

       
93
       
 
       
    create ~url ~mime_type ?title ?size_in_bytes ?duration_in_seconds ~unknown

     

       
94
       
 
       
      ()

     
···

       
100
       
 
       
  |> Jsont.Object.opt_mem "size_in_bytes" Jsont.int64 ~enc:size_in_bytes

     

       
101
       
 
       
  |> Jsont.Object.opt_mem "duration_in_seconds" Jsont.int

     

       
102
       
 
       
       ~enc:duration_in_seconds

     

       
103
       
-
       
  |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

       
104
       
 
       
  |> Jsont.Object.finish

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
+
       
  type t = Jsont.json

     

       
8
       
 
       


     

       
9
       
+
       
  let empty = Jsont.Object ([], Jsont.Meta.none)

     

       
10
       
+
       
  let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type t = {

     
···

       
64
       
 
       
let jsont =

     

       
65
       
 
       
  let kind = "Attachment" in

     

       
66
       
 
       
  let doc = "An attachment object" in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
67
       
 
       
  let create_obj url mime_type title size_in_bytes duration_in_seconds unknown =

     

       
68
       
 
       
    create ~url ~mime_type ?title ?size_in_bytes ?duration_in_seconds ~unknown

     

       
69
       
 
       
      ()

     
···

       
75
       
 
       
  |> Jsont.Object.opt_mem "size_in_bytes" Jsont.int64 ~enc:size_in_bytes

     

       
76
       
 
       
  |> Jsont.Object.opt_mem "duration_in_seconds" Jsont.int

     

       
77
       
 
       
       ~enc:duration_in_seconds

     

       
78
       
+
       
  |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:unknown

     

       
79
       
 
       
  |> Jsont.Object.finish

     

···

       
18
       
 
       
(** {1 Unknown Fields} *)

     

       
19
       
 
       


     

       
20
       
 
       
module Unknown : sig

     

       
21
       
-
       
  type t = (string * Jsont.json) list

     

       
22
       
-
       
  (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       
23
       
-
       
      from custom extensions or future spec versions. *)

     

       
24
       
 
       


     

       
25
       
 
       
  val empty : t

     

       
26
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
18
       
 
       
(** {1 Unknown Fields} *)

     

       
19
       
 
       


     

       
20
       
 
       
module Unknown : sig

     

       
21
       
+
       
  type t = Jsont.json

     

       
22
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
23
       
+
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
24
       
 
       


     

       
25
       
 
       
  val empty : t

     

       
26
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
-
       
  type t = (string * Jsont.json) list

     

       
8
       
 
       


     

       
9
       
-
       
  let empty = []

     

       
10
       
-
       
  let is_empty = function [] -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type t = {

     
···

       
44
       
 
       
let jsont =

     

       
45
       
 
       
  let kind = "Author" in

     

       
46
       
 
       
  let doc = "An author object with at least one field set" in

     

       
47
       
-
       
  (* Custom mems map for Unknown.t that strips metadata from names *)

     

       
48
       
-
       
  let unknown_mems :

     

       
49
       
-
       
      (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       
50
       
-
       
    let open Jsont.Object.Mems in

     

       
51
       
-
       
    let dec_empty () = [] in

     

       
52
       
-
       
    let dec_add _meta (name : string) value acc =

     

       
53
       
-
       
      ((name, Jsont.Meta.none), value) :: acc

     

       
54
       
-
       
    in

     

       
55
       
-
       
    let dec_finish _meta mems =

     

       
56
       
-
       
      List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       
57
       
-
       
    in

     

       
58
       
-
       
    let enc =

     

       
59
       
-
       
      {

     

       
60
       
-
       
        enc =

     

       
61
       
-
       
          (fun (type acc)

     

       
62
       
-
       
            (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       
63
       
-
       
            unknown

     

       
64
       
-
       
            (acc : acc)

     

       
65
       
-
       
          ->

     

       
66
       
-
       
            List.fold_left

     

       
67
       
-
       
              (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       
68
       
-
       
              acc unknown);

     

       
69
       
-
       
      }

     

       
70
       
-
       
    in

     

       
71
       
-
       
    map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       
72
       
-
       
  in

     

       
73
       
 
       
  (* Constructor that matches the jsont object map pattern *)

     

       
74
       
 
       
  let create_obj name url avatar unknown =

     

       
75
       
 
       
    create ?name ?url ?avatar ~unknown ()

     
···

       
78
       
 
       
  |> Jsont.Object.opt_mem "name" Jsont.string ~enc:name

     

       
79
       
 
       
  |> Jsont.Object.opt_mem "url" Jsont.string ~enc:url

     

       
80
       
 
       
  |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:avatar

     

       
81
       
-
       
  |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

       
82
       
 
       
  |> Jsont.Object.finish

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
+
       
  type t = Jsont.json

     

       
8
       
 
       


     

       
9
       
+
       
  let empty = Jsont.Object ([], Jsont.Meta.none)

     

       
10
       
+
       
  let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type t = {

     
···

       
44
       
 
       
let jsont =

     

       
45
       
 
       
  let kind = "Author" in

     

       
46
       
 
       
  let doc = "An author object with at least one field set" in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
47
       
 
       
  (* Constructor that matches the jsont object map pattern *)

     

       
48
       
 
       
  let create_obj name url avatar unknown =

     

       
49
       
 
       
    create ?name ?url ?avatar ~unknown ()

     
···

       
52
       
 
       
  |> Jsont.Object.opt_mem "name" Jsont.string ~enc:name

     

       
53
       
 
       
  |> Jsont.Object.opt_mem "url" Jsont.string ~enc:url

     

       
54
       
 
       
  |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:avatar

     

       
55
       
+
       
  |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:unknown

     

       
56
       
 
       
  |> Jsont.Object.finish

     

···

       
17
       
 
       
(** {1 Unknown Fields} *)

     

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
-
       
  type t = (string * Jsont.json) list

     

       
21
       
-
       
  (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       
22
       
-
       
      from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
17
       
 
       
(** {1 Unknown Fields} *)

     

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
+
       
  type t = Jsont.json

     

       
21
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
22
       
+
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
-
       
  type t = (string * Jsont.json) list

     

       
8
       
 
       


     

       
9
       
-
       
  let empty = []

     

       
10
       
-
       
  let is_empty = function [] -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type t = { type_ : string; url : string; unknown : Unknown.t }

     
···

       
22
       
 
       
let jsont =

     

       
23
       
 
       
  let kind = "Hub" in

     

       
24
       
 
       
  let doc = "A hub endpoint" in

     

       
25
       
-
       
  let unknown_mems :

     

       
26
       
-
       
      (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       
27
       
-
       
    let open Jsont.Object.Mems in

     

       
28
       
-
       
    let dec_empty () = [] in

     

       
29
       
-
       
    let dec_add _meta (name : string) value acc =

     

       
30
       
-
       
      ((name, Jsont.Meta.none), value) :: acc

     

       
31
       
-
       
    in

     

       
32
       
-
       
    let dec_finish _meta mems =

     

       
33
       
-
       
      List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       
34
       
-
       
    in

     

       
35
       
-
       
    let enc =

     

       
36
       
-
       
      {

     

       
37
       
-
       
        enc =

     

       
38
       
-
       
          (fun (type acc)

     

       
39
       
-
       
            (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       
40
       
-
       
            unknown

     

       
41
       
-
       
            (acc : acc)

     

       
42
       
-
       
          ->

     

       
43
       
-
       
            List.fold_left

     

       
44
       
-
       
              (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       
45
       
-
       
              acc unknown);

     

       
46
       
-
       
      }

     

       
47
       
-
       
    in

     

       
48
       
-
       
    map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       
49
       
-
       
  in

     

       
50
       
 
       
  let create_obj type_ url unknown = create ~type_ ~url ~unknown () in

     

       
51
       
 
       
  Jsont.Object.map ~kind ~doc create_obj

     

       
52
       
 
       
  |> Jsont.Object.mem "type" Jsont.string ~enc:type_

     

       
53
       
 
       
  |> Jsont.Object.mem "url" Jsont.string ~enc:url

     

       
54
       
-
       
  |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

       
55
       
 
       
  |> Jsont.Object.finish

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
+
       
  type t = Jsont.json

     

       
8
       
 
       


     

       
9
       
+
       
  let empty = Jsont.Object ([], Jsont.Meta.none)

     

       
10
       
+
       
  let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type t = { type_ : string; url : string; unknown : Unknown.t }

     
···

       
22
       
 
       
let jsont =

     

       
23
       
 
       
  let kind = "Hub" in

     

       
24
       
 
       
  let doc = "A hub endpoint" in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
25
       
 
       
  let create_obj type_ url unknown = create ~type_ ~url ~unknown () in

     

       
26
       
 
       
  Jsont.Object.map ~kind ~doc create_obj

     

       
27
       
 
       
  |> Jsont.Object.mem "type" Jsont.string ~enc:type_

     

       
28
       
 
       
  |> Jsont.Object.mem "url" Jsont.string ~enc:url

     

       
29
       
+
       
  |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:unknown

     

       
30
       
 
       
  |> Jsont.Object.finish

     

···

       
17
       
 
       
(** {1 Unknown Fields} *)

     

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
-
       
  type t = (string * Jsont.json) list

     

       
21
       
-
       
  (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       
22
       
-
       
      from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
17
       
 
       
(** {1 Unknown Fields} *)

     

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
+
       
  type t = Jsont.json

     

       
21
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
22
       
+
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
-
       
  type t = (string * Jsont.json) list

     

       
8
       
 
       


     

       
9
       
-
       
  let empty = []

     

       
10
       
-
       
  let is_empty = function [] -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type content = [ `Html of string | `Text of string | `Both of string * string ]

     
···

       
166
       
 
       
  let enc_references t = t.references in

     

       
167
       
 
       
  let enc_unknown t = t.unknown in

     

       
168
       
 
       


     

       
169
       
-
       
  let unknown_mems :

     

       
170
       
-
       
      (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       
171
       
-
       
    let open Jsont.Object.Mems in

     

       
172
       
-
       
    let dec_empty () = [] in

     

       
173
       
-
       
    let dec_add _meta (name : string) value acc =

     

       
174
       
-
       
      ((name, Jsont.Meta.none), value) :: acc

     

       
175
       
-
       
    in

     

       
176
       
-
       
    let dec_finish _meta mems =

     

       
177
       
-
       
      List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       
178
       
-
       
    in

     

       
179
       
-
       
    let enc =

     

       
180
       
-
       
      {

     

       
181
       
-
       
        enc =

     

       
182
       
-
       
          (fun (type acc)

     

       
183
       
-
       
            (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       
184
       
-
       
            unknown

     

       
185
       
-
       
            (acc : acc)

     

       
186
       
-
       
          ->

     

       
187
       
-
       
            List.fold_left

     

       
188
       
-
       
              (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       
189
       
-
       
              acc unknown);

     

       
190
       
-
       
      }

     

       
191
       
-
       
    in

     

       
192
       
-
       
    map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       
193
       
-
       
  in

     

       
194
       
-
       


     

       
195
       
 
       
  Jsont.Object.map ~kind ~doc make_from_json

     

       
196
       
 
       
  |> Jsont.Object.mem "id" Jsont.string ~enc:enc_id

     

       
197
       
 
       
  |> Jsont.Object.opt_mem "content_html" Jsont.string ~enc:enc_content_html

     
···

       
214
       
 
       
       (Jsont.list Reference.jsont)

     

       
215
       
 
       
       ~enc:enc_references

     

       
216
       
 
       
  |> Jsont.Object.opt_mem "_extensions" Jsont.json_object ~enc:(fun _t -> None)

     

       
217
       
-
       
  |> Jsont.Object.keep_unknown unknown_mems ~enc:enc_unknown

     

       
218
       
 
       
  |> Jsont.Object.finish

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
+
       
  type t = Jsont.json

     

       
8
       
 
       


     

       
9
       
+
       
  let empty = Jsont.Object ([], Jsont.Meta.none)

     

       
10
       
+
       
  let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type content = [ `Html of string | `Text of string | `Both of string * string ]

     
···

       
166
       
 
       
  let enc_references t = t.references in

     

       
167
       
 
       
  let enc_unknown t = t.unknown in

     

       
168
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
169
       
 
       
  Jsont.Object.map ~kind ~doc make_from_json

     

       
170
       
 
       
  |> Jsont.Object.mem "id" Jsont.string ~enc:enc_id

     

       
171
       
 
       
  |> Jsont.Object.opt_mem "content_html" Jsont.string ~enc:enc_content_html

     
···

       
188
       
 
       
       (Jsont.list Reference.jsont)

     

       
189
       
 
       
       ~enc:enc_references

     

       
190
       
 
       
  |> Jsont.Object.opt_mem "_extensions" Jsont.json_object ~enc:(fun _t -> None)

     

       
191
       
+
       
  |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:enc_unknown

     

       
192
       
 
       
  |> Jsont.Object.finish

     

···

       
27
       
 
       
(** {1 Unknown Fields} *)

     

       
28
       
 
       


     

       
29
       
 
       
module Unknown : sig

     

       
30
       
-
       
  type t = (string * Jsont.json) list

     

       
31
       
-
       
  (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       
32
       
-
       
      from custom extensions or future spec versions. *)

     

       
33
       
 
       


     

       
34
       
 
       
  val empty : t

     

       
35
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
27
       
 
       
(** {1 Unknown Fields} *)

     

       
28
       
 
       


     

       
29
       
 
       
module Unknown : sig

     

       
30
       
+
       
  type t = Jsont.json

     

       
31
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
32
       
+
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
33
       
 
       


     

       
34
       
 
       
  val empty : t

     

       
35
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
12
       
 
       
module Item = Item

     

       
13
       
 
       


     

       
14
       
 
       
module Unknown = struct

     

       
15
       
-
       
  type t = (string * Jsont.json) list

     

       
16
       
 
       


     

       
17
       
-
       
  let empty = []

     

       
18
       
-
       
  let is_empty = function [] -> true | _ -> false

     

       
19
       
 
       
end

     

       
20
       
 
       


     

       
21
       
 
       
type t = {

     
···

       
85
       
 
       
let jsont =

     

       
86
       
 
       
  let kind = "JSON Feed" in

     

       
87
       
 
       
  let doc = "A JSON Feed document" in

     

       
88
       
-
       
  let unknown_mems :

     

       
89
       
-
       
      (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       
90
       
-
       
    let open Jsont.Object.Mems in

     

       
91
       
-
       
    let dec_empty () = [] in

     

       
92
       
-
       
    let dec_add _meta (name : string) value acc =

     

       
93
       
-
       
      ((name, Jsont.Meta.none), value) :: acc

     

       
94
       
-
       
    in

     

       
95
       
-
       
    let dec_finish _meta mems =

     

       
96
       
-
       
      List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       
97
       
-
       
    in

     

       
98
       
-
       
    let enc =

     

       
99
       
-
       
      {

     

       
100
       
-
       
        enc =

     

       
101
       
-
       
          (fun (type acc)

     

       
102
       
-
       
            (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       
103
       
-
       
            unknown

     

       
104
       
-
       
            (acc : acc)

     

       
105
       
-
       
          ->

     

       
106
       
-
       
            List.fold_left

     

       
107
       
-
       
              (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       
108
       
-
       
              acc unknown);

     

       
109
       
-
       
      }

     

       
110
       
-
       
    in

     

       
111
       
-
       
    map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       
112
       
-
       
  in

     

       
113
       
 
       


     

       
114
       
 
       
  (* Helper constructor that sets version automatically *)

     

       
115
       
 
       
  let make_from_json _version title home_page_url feed_url description

     
···

       
149
       
 
       
  |> Jsont.Object.opt_mem "expired" Jsont.bool ~enc:expired

     

       
150
       
 
       
  |> Jsont.Object.opt_mem "hubs" (Jsont.list Hub.jsont) ~enc:hubs

     

       
151
       
 
       
  |> Jsont.Object.mem "items" (Jsont.list Item.jsont) ~enc:items

     

       
152
       
-
       
  |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

       
153
       
 
       
  |> Jsont.Object.finish

     

       
154
       
 
       


     

       
155
       
 
       
(* Encoding and Decoding *)

     

···

       
12
       
 
       
module Item = Item

     

       
13
       
 
       


     

       
14
       
 
       
module Unknown = struct

     

       
15
       
+
       
  type t = Jsont.json

     

       
16
       
 
       


     

       
17
       
+
       
  let empty = Jsont.Object ([], Jsont.Meta.none)

     

       
18
       
+
       
  let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       
19
       
 
       
end

     

       
20
       
 
       


     

       
21
       
 
       
type t = {

     
···

       
85
       
 
       
let jsont =

     

       
86
       
 
       
  let kind = "JSON Feed" in

     

       
87
       
 
       
  let doc = "A JSON Feed document" in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
88
       
 
       


     

       
89
       
 
       
  (* Helper constructor that sets version automatically *)

     

       
90
       
 
       
  let make_from_json _version title home_page_url feed_url description

     
···

       
124
       
 
       
  |> Jsont.Object.opt_mem "expired" Jsont.bool ~enc:expired

     

       
125
       
 
       
  |> Jsont.Object.opt_mem "hubs" (Jsont.list Hub.jsont) ~enc:hubs

     

       
126
       
 
       
  |> Jsont.Object.mem "items" (Jsont.list Item.jsont) ~enc:items

     

       
127
       
+
       
  |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:unknown

     

       
128
       
 
       
  |> Jsont.Object.finish

     

       
129
       
 
       


     

       
130
       
 
       
(* Encoding and Decoding *)

     

···

       
17
       
 
       
    optional fields. *)

     

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
-
       
  type t = (string * Jsont.json) list

     

       
21
       
-
       
  (** Unknown or unrecognized JSON object members. Useful for preserving fields

     

       
22
       
-
       
      from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
17
       
 
       
    optional fields. *)

     

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
+
       
  type t = Jsont.json

     

       
21
       
+
       
  (** Unknown or unrecognized JSON object members as a generic JSON object.

     

       
22
       
+
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
-
       
  type t = (string * Jsont.json) list

     

       
8
       
 
       


     

       
9
       
-
       
  let empty = []

     

       
10
       
-
       
  let is_empty = function [] -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type t = {

     
···

       
34
       
 
       
let jsont =

     

       
35
       
 
       
  let kind = "Reference" in

     

       
36
       
 
       
  let doc = "A reference to a cited source" in

     

       
37
       
-
       
  let unknown_mems :

     

       
38
       
-
       
      (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       
39
       
-
       
    let open Jsont.Object.Mems in

     

       
40
       
-
       
    let dec_empty () = [] in

     

       
41
       
-
       
    let dec_add _meta (name : string) value acc =

     

       
42
       
-
       
      ((name, Jsont.Meta.none), value) :: acc

     

       
43
       
-
       
    in

     

       
44
       
-
       
    let dec_finish _meta mems =

     

       
45
       
-
       
      List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       
46
       
-
       
    in

     

       
47
       
-
       
    let enc =

     

       
48
       
-
       
      {

     

       
49
       
-
       
        enc =

     

       
50
       
-
       
          (fun (type acc)

     

       
51
       
-
       
            (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       
52
       
-
       
            unknown

     

       
53
       
-
       
            (acc : acc)

     

       
54
       
-
       
          ->

     

       
55
       
-
       
            List.fold_left

     

       
56
       
-
       
              (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       
57
       
-
       
              acc unknown);

     

       
58
       
-
       
      }

     

       
59
       
-
       
    in

     

       
60
       
-
       
    map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       
61
       
-
       
  in

     

       
62
       
 
       
  let create_obj url doi cito unknown = create ~url ?doi ?cito ~unknown () in

     

       
63
       
 
       
  Jsont.Object.map ~kind ~doc create_obj

     

       
64
       
 
       
  |> Jsont.Object.mem "url" Jsont.string ~enc:url

     

       
65
       
 
       
  |> Jsont.Object.opt_mem "doi" Jsont.string ~enc:doi

     

       
66
       
 
       
  |> Jsont.Object.opt_mem "cito" (Jsont.list Cito.jsont) ~enc:cito

     

       
67
       
-
       
  |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

       
68
       
 
       
  |> Jsont.Object.finish

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
module Unknown = struct

     

       
7
       
+
       
  type t = Jsont.json

     

       
8
       
 
       


     

       
9
       
+
       
  let empty = Jsont.Object ([], Jsont.Meta.none)

     

       
10
       
+
       
  let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       
11
       
 
       
end

     

       
12
       
 
       


     

       
13
       
 
       
type t = {

     
···

       
34
       
 
       
let jsont =

     

       
35
       
 
       
  let kind = "Reference" in

     

       
36
       
 
       
  let doc = "A reference to a cited source" in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
37
       
 
       
  let create_obj url doi cito unknown = create ~url ?doi ?cito ~unknown () in

     

       
38
       
 
       
  Jsont.Object.map ~kind ~doc create_obj

     

       
39
       
 
       
  |> Jsont.Object.mem "url" Jsont.string ~enc:url

     

       
40
       
 
       
  |> Jsont.Object.opt_mem "doi" Jsont.string ~enc:doi

     

       
41
       
 
       
  |> Jsont.Object.opt_mem "cito" (Jsont.list Cito.jsont) ~enc:cito

     

       
42
       
+
       
  |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:unknown

     

       
43
       
 
       
  |> Jsont.Object.finish

     

···

       
19
       
 
       
(** {1 Unknown Fields} *)

     

       
20
       
 
       


     

       
21
       
 
       
module Unknown : sig

     

       
22
       
-
       
  type t = (string * Jsont.json) list

     

       
23
       
-
       
  (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       
24
       
-
       
      from custom extensions or future spec versions. *)

     

       
25
       
 
       


     

       
26
       
 
       
  val empty : t

     

       
27
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
19
       
 
       
(** {1 Unknown Fields} *)

     

       
20
       
 
       


     

       
21
       
 
       
module Unknown : sig

     

       
22
       
+
       
  type t = Jsont.json

     

       
23
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
24
       
+
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
25
       
 
       


     

       
26
       
 
       
  val empty : t

     

       
27
       
 
       
  (** [empty] is the empty list of unknown fields. *)