1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8 clippy::approx_constant,
9 clippy::type_complexity,
10 clippy::unreadable_literal,
11 clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use gio_sys as gio;
16use glib_sys as glib;
17use gobject_sys as gobject;
18
19#[cfg(unix)]
20#[allow(unused_imports)]
21use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
22#[allow(unused_imports)]
23use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
24#[allow(unused_imports)]
25use std::ffi::{
26 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
27};
28
29#[allow(unused_imports)]
30use glib::{gboolean, gconstpointer, gpointer, GType};
31
32pub type JsonNodeType = c_int;
34pub const JSON_NODE_OBJECT: JsonNodeType = 0;
35pub const JSON_NODE_ARRAY: JsonNodeType = 1;
36pub const JSON_NODE_VALUE: JsonNodeType = 2;
37pub const JSON_NODE_NULL: JsonNodeType = 3;
38
39pub type JsonParserError = c_int;
40pub const JSON_PARSER_ERROR_PARSE: JsonParserError = 0;
41pub const JSON_PARSER_ERROR_TRAILING_COMMA: JsonParserError = 1;
42pub const JSON_PARSER_ERROR_MISSING_COMMA: JsonParserError = 2;
43pub const JSON_PARSER_ERROR_MISSING_COLON: JsonParserError = 3;
44pub const JSON_PARSER_ERROR_INVALID_BAREWORD: JsonParserError = 4;
45pub const JSON_PARSER_ERROR_EMPTY_MEMBER_NAME: JsonParserError = 5;
46pub const JSON_PARSER_ERROR_INVALID_DATA: JsonParserError = 6;
47pub const JSON_PARSER_ERROR_UNKNOWN: JsonParserError = 7;
48#[cfg(feature = "v1_10")]
49#[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
50pub const JSON_PARSER_ERROR_NESTING: JsonParserError = 8;
51#[cfg(feature = "v1_10")]
52#[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
53pub const JSON_PARSER_ERROR_INVALID_STRUCTURE: JsonParserError = 9;
54#[cfg(feature = "v1_10")]
55#[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
56pub const JSON_PARSER_ERROR_INVALID_ASSIGNMENT: JsonParserError = 10;
57
58pub type JsonPathError = c_int;
59pub const JSON_PATH_ERROR_INVALID_QUERY: JsonPathError = 0;
60
61pub type JsonReaderError = c_int;
62pub const JSON_READER_ERROR_NO_ARRAY: JsonReaderError = 0;
63pub const JSON_READER_ERROR_INVALID_INDEX: JsonReaderError = 1;
64pub const JSON_READER_ERROR_NO_OBJECT: JsonReaderError = 2;
65pub const JSON_READER_ERROR_INVALID_MEMBER: JsonReaderError = 3;
66pub const JSON_READER_ERROR_INVALID_NODE: JsonReaderError = 4;
67pub const JSON_READER_ERROR_NO_VALUE: JsonReaderError = 5;
68pub const JSON_READER_ERROR_INVALID_TYPE: JsonReaderError = 6;
69
70pub const JSON_MAJOR_VERSION: c_int = 1;
72pub const JSON_MICRO_VERSION: c_int = 8;
73pub const JSON_MINOR_VERSION: c_int = 10;
74pub const JSON_PARSER_MAX_RECURSION_DEPTH: c_int = 1024;
75pub const JSON_VERSION_S: &[u8] = b"1.10.8\0";
76
77pub type JsonArrayForeach =
79 Option<unsafe extern "C" fn(*mut JsonArray, c_uint, *mut JsonNode, gpointer)>;
80pub type JsonBoxedDeserializeFunc = Option<unsafe extern "C" fn(*mut JsonNode) -> gpointer>;
81pub type JsonBoxedSerializeFunc = Option<unsafe extern "C" fn(gconstpointer) -> *mut JsonNode>;
82pub type JsonObjectForeach =
83 Option<unsafe extern "C" fn(*mut JsonObject, *const c_char, *mut JsonNode, gpointer)>;
84
85#[repr(C)]
87#[allow(dead_code)]
88pub struct JsonArray {
89 _data: [u8; 0],
90 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
91}
92
93impl ::std::fmt::Debug for JsonArray {
94 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
95 f.debug_struct(&format!("JsonArray @ {self:p}")).finish()
96 }
97}
98
99#[derive(Copy, Clone)]
100#[repr(C)]
101pub struct JsonBuilderClass {
102 pub parent_class: gobject::GObjectClass,
103 pub _json_reserved1: Option<unsafe extern "C" fn()>,
104 pub _json_reserved2: Option<unsafe extern "C" fn()>,
105}
106
107impl ::std::fmt::Debug for JsonBuilderClass {
108 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
109 f.debug_struct(&format!("JsonBuilderClass @ {self:p}"))
110 .field("_json_reserved1", &self._json_reserved1)
111 .field("_json_reserved2", &self._json_reserved2)
112 .finish()
113 }
114}
115
116#[repr(C)]
117#[allow(dead_code)]
118pub struct _JsonBuilderPrivate {
119 _data: [u8; 0],
120 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
121}
122
123pub type JsonBuilderPrivate = _JsonBuilderPrivate;
124
125#[derive(Copy, Clone)]
126#[repr(C)]
127pub struct JsonGeneratorClass {
128 pub parent_class: gobject::GObjectClass,
129 pub _json_reserved1: Option<unsafe extern "C" fn()>,
130 pub _json_reserved2: Option<unsafe extern "C" fn()>,
131 pub _json_reserved3: Option<unsafe extern "C" fn()>,
132 pub _json_reserved4: Option<unsafe extern "C" fn()>,
133}
134
135impl ::std::fmt::Debug for JsonGeneratorClass {
136 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
137 f.debug_struct(&format!("JsonGeneratorClass @ {self:p}"))
138 .field("_json_reserved1", &self._json_reserved1)
139 .field("_json_reserved2", &self._json_reserved2)
140 .field("_json_reserved3", &self._json_reserved3)
141 .field("_json_reserved4", &self._json_reserved4)
142 .finish()
143 }
144}
145
146#[repr(C)]
147#[allow(dead_code)]
148pub struct _JsonGeneratorPrivate {
149 _data: [u8; 0],
150 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
151}
152
153pub type JsonGeneratorPrivate = _JsonGeneratorPrivate;
154
155#[repr(C)]
156#[allow(dead_code)]
157pub struct JsonNode {
158 _data: [u8; 0],
159 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
160}
161
162impl ::std::fmt::Debug for JsonNode {
163 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
164 f.debug_struct(&format!("JsonNode @ {self:p}")).finish()
165 }
166}
167
168#[repr(C)]
169#[allow(dead_code)]
170pub struct JsonObject {
171 _data: [u8; 0],
172 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
173}
174
175impl ::std::fmt::Debug for JsonObject {
176 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
177 f.debug_struct(&format!("JsonObject @ {self:p}")).finish()
178 }
179}
180
181#[derive(Copy, Clone)]
182#[repr(C)]
183pub struct JsonObjectIter {
184 pub priv_pointer: [gpointer; 6],
185 pub priv_int: [c_int; 2],
186 pub priv_boolean: [gboolean; 1],
187}
188
189impl ::std::fmt::Debug for JsonObjectIter {
190 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
191 f.debug_struct(&format!("JsonObjectIter @ {self:p}"))
192 .finish()
193 }
194}
195
196#[derive(Copy, Clone)]
197#[repr(C)]
198pub struct JsonParserClass {
199 pub parent_class: gobject::GObjectClass,
200 pub parse_start: Option<unsafe extern "C" fn(*mut JsonParser)>,
201 pub object_start: Option<unsafe extern "C" fn(*mut JsonParser)>,
202 pub object_member:
203 Option<unsafe extern "C" fn(*mut JsonParser, *mut JsonObject, *const c_char)>,
204 pub object_end: Option<unsafe extern "C" fn(*mut JsonParser, *mut JsonObject)>,
205 pub array_start: Option<unsafe extern "C" fn(*mut JsonParser)>,
206 pub array_element: Option<unsafe extern "C" fn(*mut JsonParser, *mut JsonArray, c_int)>,
207 pub array_end: Option<unsafe extern "C" fn(*mut JsonParser, *mut JsonArray)>,
208 pub parse_end: Option<unsafe extern "C" fn(*mut JsonParser)>,
209 pub error: Option<unsafe extern "C" fn(*mut JsonParser, *const glib::GError)>,
210 pub _json_reserved1: Option<unsafe extern "C" fn()>,
211 pub _json_reserved2: Option<unsafe extern "C" fn()>,
212 pub _json_reserved3: Option<unsafe extern "C" fn()>,
213 pub _json_reserved4: Option<unsafe extern "C" fn()>,
214 pub _json_reserved5: Option<unsafe extern "C" fn()>,
215 pub _json_reserved6: Option<unsafe extern "C" fn()>,
216 pub _json_reserved7: Option<unsafe extern "C" fn()>,
217 pub _json_reserved8: Option<unsafe extern "C" fn()>,
218}
219
220impl ::std::fmt::Debug for JsonParserClass {
221 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
222 f.debug_struct(&format!("JsonParserClass @ {self:p}"))
223 .field("parse_start", &self.parse_start)
224 .field("object_start", &self.object_start)
225 .field("object_member", &self.object_member)
226 .field("object_end", &self.object_end)
227 .field("array_start", &self.array_start)
228 .field("array_element", &self.array_element)
229 .field("array_end", &self.array_end)
230 .field("parse_end", &self.parse_end)
231 .field("error", &self.error)
232 .field("_json_reserved1", &self._json_reserved1)
233 .field("_json_reserved2", &self._json_reserved2)
234 .field("_json_reserved3", &self._json_reserved3)
235 .field("_json_reserved4", &self._json_reserved4)
236 .field("_json_reserved5", &self._json_reserved5)
237 .field("_json_reserved6", &self._json_reserved6)
238 .field("_json_reserved7", &self._json_reserved7)
239 .field("_json_reserved8", &self._json_reserved8)
240 .finish()
241 }
242}
243
244#[repr(C)]
245#[allow(dead_code)]
246pub struct _JsonParserPrivate {
247 _data: [u8; 0],
248 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
249}
250
251pub type JsonParserPrivate = _JsonParserPrivate;
252
253#[repr(C)]
254#[allow(dead_code)]
255pub struct _JsonPathClass {
256 _data: [u8; 0],
257 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
258}
259
260pub type JsonPathClass = _JsonPathClass;
261
262#[derive(Copy, Clone)]
263#[repr(C)]
264pub struct JsonReaderClass {
265 pub parent_class: gobject::GObjectClass,
266 pub _json_padding0: Option<unsafe extern "C" fn()>,
267 pub _json_padding1: Option<unsafe extern "C" fn()>,
268 pub _json_padding2: Option<unsafe extern "C" fn()>,
269 pub _json_padding3: Option<unsafe extern "C" fn()>,
270 pub _json_padding4: Option<unsafe extern "C" fn()>,
271}
272
273impl ::std::fmt::Debug for JsonReaderClass {
274 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
275 f.debug_struct(&format!("JsonReaderClass @ {self:p}"))
276 .field("_json_padding0", &self._json_padding0)
277 .field("_json_padding1", &self._json_padding1)
278 .field("_json_padding2", &self._json_padding2)
279 .field("_json_padding3", &self._json_padding3)
280 .field("_json_padding4", &self._json_padding4)
281 .finish()
282 }
283}
284
285#[repr(C)]
286#[allow(dead_code)]
287pub struct _JsonReaderPrivate {
288 _data: [u8; 0],
289 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
290}
291
292pub type JsonReaderPrivate = _JsonReaderPrivate;
293
294#[derive(Copy, Clone)]
295#[repr(C)]
296pub struct JsonSerializableIface {
297 pub g_iface: gobject::GTypeInterface,
298 pub serialize_property: Option<
299 unsafe extern "C" fn(
300 *mut JsonSerializable,
301 *const c_char,
302 *const gobject::GValue,
303 *mut gobject::GParamSpec,
304 ) -> *mut JsonNode,
305 >,
306 pub deserialize_property: Option<
307 unsafe extern "C" fn(
308 *mut JsonSerializable,
309 *const c_char,
310 *mut gobject::GValue,
311 *mut gobject::GParamSpec,
312 *mut JsonNode,
313 ) -> gboolean,
314 >,
315 pub find_property: Option<
316 unsafe extern "C" fn(*mut JsonSerializable, *const c_char) -> *mut gobject::GParamSpec,
317 >,
318 pub list_properties: Option<
319 unsafe extern "C" fn(*mut JsonSerializable, *mut c_uint) -> *mut *mut gobject::GParamSpec,
320 >,
321 pub set_property: Option<
322 unsafe extern "C" fn(*mut JsonSerializable, *mut gobject::GParamSpec, *mut gobject::GValue),
323 >,
324 pub get_property: Option<
325 unsafe extern "C" fn(*mut JsonSerializable, *mut gobject::GParamSpec, *mut gobject::GValue),
326 >,
327}
328
329impl ::std::fmt::Debug for JsonSerializableIface {
330 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
331 f.debug_struct(&format!("JsonSerializableIface @ {self:p}"))
332 .field("serialize_property", &self.serialize_property)
333 .field("deserialize_property", &self.deserialize_property)
334 .field("find_property", &self.find_property)
335 .field("list_properties", &self.list_properties)
336 .field("set_property", &self.set_property)
337 .field("get_property", &self.get_property)
338 .finish()
339 }
340}
341
342#[derive(Copy, Clone)]
344#[repr(C)]
345pub struct JsonBuilder {
346 pub parent_instance: gobject::GObject,
347 pub priv_: *mut JsonBuilderPrivate,
348}
349
350impl ::std::fmt::Debug for JsonBuilder {
351 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
352 f.debug_struct(&format!("JsonBuilder @ {self:p}")).finish()
353 }
354}
355
356#[derive(Copy, Clone)]
357#[repr(C)]
358pub struct JsonGenerator {
359 pub parent_instance: gobject::GObject,
360 pub priv_: *mut JsonGeneratorPrivate,
361}
362
363impl ::std::fmt::Debug for JsonGenerator {
364 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
365 f.debug_struct(&format!("JsonGenerator @ {self:p}"))
366 .finish()
367 }
368}
369
370#[derive(Copy, Clone)]
371#[repr(C)]
372pub struct JsonParser {
373 pub parent_instance: gobject::GObject,
374 pub priv_: *mut JsonParserPrivate,
375}
376
377impl ::std::fmt::Debug for JsonParser {
378 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
379 f.debug_struct(&format!("JsonParser @ {self:p}")).finish()
380 }
381}
382
383#[repr(C)]
384#[allow(dead_code)]
385pub struct JsonPath {
386 _data: [u8; 0],
387 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
388}
389
390impl ::std::fmt::Debug for JsonPath {
391 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
392 f.debug_struct(&format!("JsonPath @ {self:p}")).finish()
393 }
394}
395
396#[derive(Copy, Clone)]
397#[repr(C)]
398pub struct JsonReader {
399 pub parent_instance: gobject::GObject,
400 pub priv_: *mut JsonReaderPrivate,
401}
402
403impl ::std::fmt::Debug for JsonReader {
404 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
405 f.debug_struct(&format!("JsonReader @ {self:p}")).finish()
406 }
407}
408
409#[repr(C)]
411#[allow(dead_code)]
412pub struct JsonSerializable {
413 _data: [u8; 0],
414 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
415}
416
417impl ::std::fmt::Debug for JsonSerializable {
418 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
419 write!(f, "JsonSerializable @ {self:p}")
420 }
421}
422
423extern "C" {
424
425 pub fn json_node_type_get_type() -> GType;
429
430 pub fn json_parser_error_get_type() -> GType;
434 pub fn json_parser_error_quark() -> glib::GQuark;
435
436 pub fn json_path_error_get_type() -> GType;
440 pub fn json_path_error_quark() -> glib::GQuark;
441
442 pub fn json_reader_error_get_type() -> GType;
446 pub fn json_reader_error_quark() -> glib::GQuark;
447
448 pub fn json_array_get_type() -> GType;
452 pub fn json_array_new() -> *mut JsonArray;
453 pub fn json_array_sized_new(n_elements: c_uint) -> *mut JsonArray;
454 pub fn json_array_add_array_element(array: *mut JsonArray, value: *mut JsonArray);
455 pub fn json_array_add_boolean_element(array: *mut JsonArray, value: gboolean);
456 pub fn json_array_add_double_element(array: *mut JsonArray, value: c_double);
457 pub fn json_array_add_element(array: *mut JsonArray, node: *mut JsonNode);
458 pub fn json_array_add_int_element(array: *mut JsonArray, value: i64);
459 pub fn json_array_add_null_element(array: *mut JsonArray);
460 pub fn json_array_add_object_element(array: *mut JsonArray, value: *mut JsonObject);
461 pub fn json_array_add_string_element(array: *mut JsonArray, value: *const c_char);
462 pub fn json_array_dup_element(array: *mut JsonArray, index_: c_uint) -> *mut JsonNode;
463 #[cfg(feature = "v1_2")]
464 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
465 pub fn json_array_equal(a: gconstpointer, b: gconstpointer) -> gboolean;
466 pub fn json_array_foreach_element(
467 array: *mut JsonArray,
468 func: JsonArrayForeach,
469 data: gpointer,
470 );
471 pub fn json_array_get_array_element(array: *mut JsonArray, index_: c_uint) -> *mut JsonArray;
472 pub fn json_array_get_boolean_element(array: *mut JsonArray, index_: c_uint) -> gboolean;
473 pub fn json_array_get_double_element(array: *mut JsonArray, index_: c_uint) -> c_double;
474 pub fn json_array_get_element(array: *mut JsonArray, index_: c_uint) -> *mut JsonNode;
475 pub fn json_array_get_elements(array: *mut JsonArray) -> *mut glib::GList;
476 pub fn json_array_get_int_element(array: *mut JsonArray, index_: c_uint) -> i64;
477 pub fn json_array_get_length(array: *mut JsonArray) -> c_uint;
478 pub fn json_array_get_null_element(array: *mut JsonArray, index_: c_uint) -> gboolean;
479 pub fn json_array_get_object_element(array: *mut JsonArray, index_: c_uint) -> *mut JsonObject;
480 pub fn json_array_get_string_element(array: *mut JsonArray, index_: c_uint) -> *const c_char;
481 #[cfg(feature = "v1_2")]
482 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
483 pub fn json_array_hash(key: gconstpointer) -> c_uint;
484 #[cfg(feature = "v1_2")]
485 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
486 pub fn json_array_is_immutable(array: *mut JsonArray) -> gboolean;
487 pub fn json_array_ref(array: *mut JsonArray) -> *mut JsonArray;
488 pub fn json_array_remove_element(array: *mut JsonArray, index_: c_uint);
489 #[cfg(feature = "v1_2")]
490 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
491 pub fn json_array_seal(array: *mut JsonArray);
492 pub fn json_array_unref(array: *mut JsonArray);
493
494 pub fn json_node_get_type() -> GType;
498 pub fn json_node_alloc() -> *mut JsonNode;
499 pub fn json_node_new(type_: JsonNodeType) -> *mut JsonNode;
500 pub fn json_node_copy(node: *mut JsonNode) -> *mut JsonNode;
501 pub fn json_node_dup_array(node: *mut JsonNode) -> *mut JsonArray;
502 pub fn json_node_dup_object(node: *mut JsonNode) -> *mut JsonObject;
503 pub fn json_node_dup_string(node: *mut JsonNode) -> *mut c_char;
504 #[cfg(feature = "v1_2")]
505 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
506 pub fn json_node_equal(a: gconstpointer, b: gconstpointer) -> gboolean;
507 pub fn json_node_free(node: *mut JsonNode);
508 pub fn json_node_get_array(node: *mut JsonNode) -> *mut JsonArray;
509 pub fn json_node_get_boolean(node: *mut JsonNode) -> gboolean;
510 pub fn json_node_get_double(node: *mut JsonNode) -> c_double;
511 pub fn json_node_get_int(node: *mut JsonNode) -> i64;
512 pub fn json_node_get_node_type(node: *mut JsonNode) -> JsonNodeType;
513 pub fn json_node_get_object(node: *mut JsonNode) -> *mut JsonObject;
514 pub fn json_node_get_parent(node: *mut JsonNode) -> *mut JsonNode;
515 pub fn json_node_get_string(node: *mut JsonNode) -> *const c_char;
516 pub fn json_node_get_value(node: *mut JsonNode, value: *mut gobject::GValue);
517 pub fn json_node_get_value_type(node: *mut JsonNode) -> GType;
518 #[cfg(feature = "v1_2")]
519 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
520 pub fn json_node_hash(key: gconstpointer) -> c_uint;
521 pub fn json_node_init(node: *mut JsonNode, type_: JsonNodeType) -> *mut JsonNode;
522 pub fn json_node_init_array(node: *mut JsonNode, array: *mut JsonArray) -> *mut JsonNode;
523 pub fn json_node_init_boolean(node: *mut JsonNode, value: gboolean) -> *mut JsonNode;
524 pub fn json_node_init_double(node: *mut JsonNode, value: c_double) -> *mut JsonNode;
525 pub fn json_node_init_int(node: *mut JsonNode, value: i64) -> *mut JsonNode;
526 pub fn json_node_init_null(node: *mut JsonNode) -> *mut JsonNode;
527 pub fn json_node_init_object(node: *mut JsonNode, object: *mut JsonObject) -> *mut JsonNode;
528 pub fn json_node_init_string(node: *mut JsonNode, value: *const c_char) -> *mut JsonNode;
529 #[cfg(feature = "v1_2")]
530 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
531 pub fn json_node_is_immutable(node: *mut JsonNode) -> gboolean;
532 pub fn json_node_is_null(node: *mut JsonNode) -> gboolean;
533 #[cfg(feature = "v1_2")]
534 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
535 pub fn json_node_ref(node: *mut JsonNode) -> *mut JsonNode;
536 #[cfg(feature = "v1_2")]
537 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
538 pub fn json_node_seal(node: *mut JsonNode);
539 pub fn json_node_set_array(node: *mut JsonNode, array: *mut JsonArray);
540 pub fn json_node_set_boolean(node: *mut JsonNode, value: gboolean);
541 pub fn json_node_set_double(node: *mut JsonNode, value: c_double);
542 pub fn json_node_set_int(node: *mut JsonNode, value: i64);
543 pub fn json_node_set_object(node: *mut JsonNode, object: *mut JsonObject);
544 pub fn json_node_set_parent(node: *mut JsonNode, parent: *mut JsonNode);
545 pub fn json_node_set_string(node: *mut JsonNode, value: *const c_char);
546 pub fn json_node_set_value(node: *mut JsonNode, value: *const gobject::GValue);
547 pub fn json_node_take_array(node: *mut JsonNode, array: *mut JsonArray);
548 pub fn json_node_take_object(node: *mut JsonNode, object: *mut JsonObject);
549 pub fn json_node_type_name(node: *mut JsonNode) -> *const c_char;
550 #[cfg(feature = "v1_2")]
551 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
552 pub fn json_node_unref(node: *mut JsonNode);
553
554 pub fn json_object_get_type() -> GType;
558 pub fn json_object_new() -> *mut JsonObject;
559 pub fn json_object_add_member(
560 object: *mut JsonObject,
561 member_name: *const c_char,
562 node: *mut JsonNode,
563 );
564 pub fn json_object_dup_member(
565 object: *mut JsonObject,
566 member_name: *const c_char,
567 ) -> *mut JsonNode;
568 #[cfg(feature = "v1_2")]
569 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
570 pub fn json_object_equal(a: gconstpointer, b: gconstpointer) -> gboolean;
571 pub fn json_object_foreach_member(
572 object: *mut JsonObject,
573 func: JsonObjectForeach,
574 data: gpointer,
575 );
576 pub fn json_object_get_array_member(
577 object: *mut JsonObject,
578 member_name: *const c_char,
579 ) -> *mut JsonArray;
580 pub fn json_object_get_boolean_member(
581 object: *mut JsonObject,
582 member_name: *const c_char,
583 ) -> gboolean;
584 #[cfg(feature = "v1_6")]
585 #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
586 pub fn json_object_get_boolean_member_with_default(
587 object: *mut JsonObject,
588 member_name: *const c_char,
589 default_value: gboolean,
590 ) -> gboolean;
591 pub fn json_object_get_double_member(
592 object: *mut JsonObject,
593 member_name: *const c_char,
594 ) -> c_double;
595 #[cfg(feature = "v1_6")]
596 #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
597 pub fn json_object_get_double_member_with_default(
598 object: *mut JsonObject,
599 member_name: *const c_char,
600 default_value: c_double,
601 ) -> c_double;
602 pub fn json_object_get_int_member(object: *mut JsonObject, member_name: *const c_char) -> i64;
603 #[cfg(feature = "v1_6")]
604 #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
605 pub fn json_object_get_int_member_with_default(
606 object: *mut JsonObject,
607 member_name: *const c_char,
608 default_value: i64,
609 ) -> i64;
610 pub fn json_object_get_member(
611 object: *mut JsonObject,
612 member_name: *const c_char,
613 ) -> *mut JsonNode;
614 pub fn json_object_get_members(object: *mut JsonObject) -> *mut glib::GList;
615 pub fn json_object_get_null_member(
616 object: *mut JsonObject,
617 member_name: *const c_char,
618 ) -> gboolean;
619 pub fn json_object_get_object_member(
620 object: *mut JsonObject,
621 member_name: *const c_char,
622 ) -> *mut JsonObject;
623 pub fn json_object_get_size(object: *mut JsonObject) -> c_uint;
624 pub fn json_object_get_string_member(
625 object: *mut JsonObject,
626 member_name: *const c_char,
627 ) -> *const c_char;
628 #[cfg(feature = "v1_6")]
629 #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
630 pub fn json_object_get_string_member_with_default(
631 object: *mut JsonObject,
632 member_name: *const c_char,
633 default_value: *const c_char,
634 ) -> *const c_char;
635 pub fn json_object_get_values(object: *mut JsonObject) -> *mut glib::GList;
636 pub fn json_object_has_member(object: *mut JsonObject, member_name: *const c_char) -> gboolean;
637 #[cfg(feature = "v1_2")]
638 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
639 pub fn json_object_hash(key: gconstpointer) -> c_uint;
640 #[cfg(feature = "v1_2")]
641 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
642 pub fn json_object_is_immutable(object: *mut JsonObject) -> gboolean;
643 pub fn json_object_ref(object: *mut JsonObject) -> *mut JsonObject;
644 pub fn json_object_remove_member(object: *mut JsonObject, member_name: *const c_char);
645 #[cfg(feature = "v1_2")]
646 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
647 pub fn json_object_seal(object: *mut JsonObject);
648 pub fn json_object_set_array_member(
649 object: *mut JsonObject,
650 member_name: *const c_char,
651 value: *mut JsonArray,
652 );
653 pub fn json_object_set_boolean_member(
654 object: *mut JsonObject,
655 member_name: *const c_char,
656 value: gboolean,
657 );
658 pub fn json_object_set_double_member(
659 object: *mut JsonObject,
660 member_name: *const c_char,
661 value: c_double,
662 );
663 pub fn json_object_set_int_member(
664 object: *mut JsonObject,
665 member_name: *const c_char,
666 value: i64,
667 );
668 pub fn json_object_set_member(
669 object: *mut JsonObject,
670 member_name: *const c_char,
671 node: *mut JsonNode,
672 );
673 pub fn json_object_set_null_member(object: *mut JsonObject, member_name: *const c_char);
674 pub fn json_object_set_object_member(
675 object: *mut JsonObject,
676 member_name: *const c_char,
677 value: *mut JsonObject,
678 );
679 pub fn json_object_set_string_member(
680 object: *mut JsonObject,
681 member_name: *const c_char,
682 value: *const c_char,
683 );
684 pub fn json_object_unref(object: *mut JsonObject);
685
686 #[cfg(feature = "v1_2")]
690 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
691 pub fn json_object_iter_init(iter: *mut JsonObjectIter, object: *mut JsonObject);
692 #[cfg(feature = "v1_6")]
693 #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
694 pub fn json_object_iter_init_ordered(iter: *mut JsonObjectIter, object: *mut JsonObject);
695 #[cfg(feature = "v1_2")]
696 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
697 pub fn json_object_iter_next(
698 iter: *mut JsonObjectIter,
699 member_name: *mut *const c_char,
700 member_node: *mut *mut JsonNode,
701 ) -> gboolean;
702 #[cfg(feature = "v1_6")]
703 #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
704 pub fn json_object_iter_next_ordered(
705 iter: *mut JsonObjectIter,
706 member_name: *mut *const c_char,
707 member_node: *mut *mut JsonNode,
708 ) -> gboolean;
709
710 pub fn json_builder_get_type() -> GType;
714 pub fn json_builder_new() -> *mut JsonBuilder;
715 #[cfg(feature = "v1_2")]
716 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
717 pub fn json_builder_new_immutable() -> *mut JsonBuilder;
718 pub fn json_builder_add_boolean_value(
719 builder: *mut JsonBuilder,
720 value: gboolean,
721 ) -> *mut JsonBuilder;
722 pub fn json_builder_add_double_value(
723 builder: *mut JsonBuilder,
724 value: c_double,
725 ) -> *mut JsonBuilder;
726 pub fn json_builder_add_int_value(builder: *mut JsonBuilder, value: i64) -> *mut JsonBuilder;
727 pub fn json_builder_add_null_value(builder: *mut JsonBuilder) -> *mut JsonBuilder;
728 pub fn json_builder_add_string_value(
729 builder: *mut JsonBuilder,
730 value: *const c_char,
731 ) -> *mut JsonBuilder;
732 pub fn json_builder_add_value(
733 builder: *mut JsonBuilder,
734 node: *mut JsonNode,
735 ) -> *mut JsonBuilder;
736 pub fn json_builder_begin_array(builder: *mut JsonBuilder) -> *mut JsonBuilder;
737 pub fn json_builder_begin_object(builder: *mut JsonBuilder) -> *mut JsonBuilder;
738 pub fn json_builder_end_array(builder: *mut JsonBuilder) -> *mut JsonBuilder;
739 pub fn json_builder_end_object(builder: *mut JsonBuilder) -> *mut JsonBuilder;
740 pub fn json_builder_get_root(builder: *mut JsonBuilder) -> *mut JsonNode;
741 pub fn json_builder_reset(builder: *mut JsonBuilder);
742 pub fn json_builder_set_member_name(
743 builder: *mut JsonBuilder,
744 member_name: *const c_char,
745 ) -> *mut JsonBuilder;
746
747 pub fn json_generator_get_type() -> GType;
751 pub fn json_generator_new() -> *mut JsonGenerator;
752 pub fn json_generator_get_indent(generator: *mut JsonGenerator) -> c_uint;
753 pub fn json_generator_get_indent_char(generator: *mut JsonGenerator) -> u32;
754 pub fn json_generator_get_pretty(generator: *mut JsonGenerator) -> gboolean;
755 pub fn json_generator_get_root(generator: *mut JsonGenerator) -> *mut JsonNode;
756 pub fn json_generator_set_indent(generator: *mut JsonGenerator, indent_level: c_uint);
757 pub fn json_generator_set_indent_char(generator: *mut JsonGenerator, indent_char: u32);
758 pub fn json_generator_set_pretty(generator: *mut JsonGenerator, is_pretty: gboolean);
759 pub fn json_generator_set_root(generator: *mut JsonGenerator, node: *mut JsonNode);
760 #[cfg(feature = "v1_10")]
761 #[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
762 pub fn json_generator_take_root(generator: *mut JsonGenerator, node: *mut JsonNode);
763 pub fn json_generator_to_data(
764 generator: *mut JsonGenerator,
765 length: *mut size_t,
766 ) -> *mut c_char;
767 pub fn json_generator_to_file(
768 generator: *mut JsonGenerator,
769 filename: *const c_char,
770 error: *mut *mut glib::GError,
771 ) -> gboolean;
772 #[cfg(feature = "v1_4")]
773 #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
774 pub fn json_generator_to_gstring(
775 generator: *mut JsonGenerator,
776 string: *mut glib::GString,
777 ) -> *mut glib::GString;
778 pub fn json_generator_to_stream(
779 generator: *mut JsonGenerator,
780 stream: *mut gio::GOutputStream,
781 cancellable: *mut gio::GCancellable,
782 error: *mut *mut glib::GError,
783 ) -> gboolean;
784
785 pub fn json_parser_get_type() -> GType;
789 pub fn json_parser_new() -> *mut JsonParser;
790 #[cfg(feature = "v1_2")]
791 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
792 pub fn json_parser_new_immutable() -> *mut JsonParser;
793 pub fn json_parser_get_current_line(parser: *mut JsonParser) -> c_uint;
794 pub fn json_parser_get_current_pos(parser: *mut JsonParser) -> c_uint;
795 pub fn json_parser_get_root(parser: *mut JsonParser) -> *mut JsonNode;
796 #[cfg(feature = "v1_10")]
797 #[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
798 pub fn json_parser_get_strict(parser: *mut JsonParser) -> gboolean;
799 pub fn json_parser_has_assignment(
800 parser: *mut JsonParser,
801 variable_name: *mut *mut c_char,
802 ) -> gboolean;
803 pub fn json_parser_load_from_data(
804 parser: *mut JsonParser,
805 data: *const c_char,
806 length: ssize_t,
807 error: *mut *mut glib::GError,
808 ) -> gboolean;
809 pub fn json_parser_load_from_file(
810 parser: *mut JsonParser,
811 filename: *const c_char,
812 error: *mut *mut glib::GError,
813 ) -> gboolean;
814 #[cfg(feature = "v1_6")]
815 #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
816 pub fn json_parser_load_from_mapped_file(
817 parser: *mut JsonParser,
818 filename: *const c_char,
819 error: *mut *mut glib::GError,
820 ) -> gboolean;
821 pub fn json_parser_load_from_stream(
822 parser: *mut JsonParser,
823 stream: *mut gio::GInputStream,
824 cancellable: *mut gio::GCancellable,
825 error: *mut *mut glib::GError,
826 ) -> gboolean;
827 pub fn json_parser_load_from_stream_async(
828 parser: *mut JsonParser,
829 stream: *mut gio::GInputStream,
830 cancellable: *mut gio::GCancellable,
831 callback: gio::GAsyncReadyCallback,
832 user_data: gpointer,
833 );
834 pub fn json_parser_load_from_stream_finish(
835 parser: *mut JsonParser,
836 result: *mut gio::GAsyncResult,
837 error: *mut *mut glib::GError,
838 ) -> gboolean;
839 #[cfg(feature = "v1_10")]
840 #[cfg_attr(docsrs, doc(cfg(feature = "v1_10")))]
841 pub fn json_parser_set_strict(parser: *mut JsonParser, strict: gboolean);
842 #[cfg(feature = "v1_4")]
843 #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
844 pub fn json_parser_steal_root(parser: *mut JsonParser) -> *mut JsonNode;
845
846 pub fn json_path_get_type() -> GType;
850 pub fn json_path_new() -> *mut JsonPath;
851 pub fn json_path_query(
852 expression: *const c_char,
853 root: *mut JsonNode,
854 error: *mut *mut glib::GError,
855 ) -> *mut JsonNode;
856 pub fn json_path_compile(
857 path: *mut JsonPath,
858 expression: *const c_char,
859 error: *mut *mut glib::GError,
860 ) -> gboolean;
861 pub fn json_path_match(path: *mut JsonPath, root: *mut JsonNode) -> *mut JsonNode;
862
863 pub fn json_reader_get_type() -> GType;
867 pub fn json_reader_new(node: *mut JsonNode) -> *mut JsonReader;
868 pub fn json_reader_count_elements(reader: *mut JsonReader) -> c_int;
869 pub fn json_reader_count_members(reader: *mut JsonReader) -> c_int;
870 pub fn json_reader_end_element(reader: *mut JsonReader);
871 pub fn json_reader_end_member(reader: *mut JsonReader);
872 pub fn json_reader_get_boolean_value(reader: *mut JsonReader) -> gboolean;
873 #[cfg(feature = "v1_8")]
874 #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
875 pub fn json_reader_get_current_node(reader: *mut JsonReader) -> *mut JsonNode;
876 pub fn json_reader_get_double_value(reader: *mut JsonReader) -> c_double;
877 pub fn json_reader_get_error(reader: *mut JsonReader) -> *const glib::GError;
878 pub fn json_reader_get_int_value(reader: *mut JsonReader) -> i64;
879 pub fn json_reader_get_member_name(reader: *mut JsonReader) -> *const c_char;
880 pub fn json_reader_get_null_value(reader: *mut JsonReader) -> gboolean;
881 pub fn json_reader_get_string_value(reader: *mut JsonReader) -> *const c_char;
882 pub fn json_reader_get_value(reader: *mut JsonReader) -> *mut JsonNode;
883 pub fn json_reader_is_array(reader: *mut JsonReader) -> gboolean;
884 pub fn json_reader_is_object(reader: *mut JsonReader) -> gboolean;
885 pub fn json_reader_is_value(reader: *mut JsonReader) -> gboolean;
886 pub fn json_reader_list_members(reader: *mut JsonReader) -> *mut *mut c_char;
887 pub fn json_reader_read_element(reader: *mut JsonReader, index_: c_uint) -> gboolean;
888 pub fn json_reader_read_member(reader: *mut JsonReader, member_name: *const c_char)
889 -> gboolean;
890 pub fn json_reader_set_root(reader: *mut JsonReader, root: *mut JsonNode);
891
892 pub fn json_serializable_get_type() -> GType;
896 pub fn json_serializable_default_deserialize_property(
897 serializable: *mut JsonSerializable,
898 property_name: *const c_char,
899 value: *mut gobject::GValue,
900 pspec: *mut gobject::GParamSpec,
901 property_node: *mut JsonNode,
902 ) -> gboolean;
903 pub fn json_serializable_default_serialize_property(
904 serializable: *mut JsonSerializable,
905 property_name: *const c_char,
906 value: *const gobject::GValue,
907 pspec: *mut gobject::GParamSpec,
908 ) -> *mut JsonNode;
909 pub fn json_serializable_deserialize_property(
910 serializable: *mut JsonSerializable,
911 property_name: *const c_char,
912 value: *mut gobject::GValue,
913 pspec: *mut gobject::GParamSpec,
914 property_node: *mut JsonNode,
915 ) -> gboolean;
916 pub fn json_serializable_find_property(
917 serializable: *mut JsonSerializable,
918 name: *const c_char,
919 ) -> *mut gobject::GParamSpec;
920 pub fn json_serializable_get_property(
921 serializable: *mut JsonSerializable,
922 pspec: *mut gobject::GParamSpec,
923 value: *mut gobject::GValue,
924 );
925 pub fn json_serializable_list_properties(
926 serializable: *mut JsonSerializable,
927 n_pspecs: *mut c_uint,
928 ) -> *mut *mut gobject::GParamSpec;
929 pub fn json_serializable_serialize_property(
930 serializable: *mut JsonSerializable,
931 property_name: *const c_char,
932 value: *const gobject::GValue,
933 pspec: *mut gobject::GParamSpec,
934 ) -> *mut JsonNode;
935 pub fn json_serializable_set_property(
936 serializable: *mut JsonSerializable,
937 pspec: *mut gobject::GParamSpec,
938 value: *const gobject::GValue,
939 );
940
941 pub fn json_boxed_can_deserialize(gboxed_type: GType, node_type: JsonNodeType) -> gboolean;
945 pub fn json_boxed_can_serialize(gboxed_type: GType, node_type: *mut JsonNodeType) -> gboolean;
946 pub fn json_boxed_deserialize(gboxed_type: GType, node: *mut JsonNode) -> gpointer;
947 pub fn json_boxed_register_deserialize_func(
948 gboxed_type: GType,
949 node_type: JsonNodeType,
950 deserialize_func: JsonBoxedDeserializeFunc,
951 );
952 pub fn json_boxed_register_serialize_func(
953 gboxed_type: GType,
954 node_type: JsonNodeType,
955 serialize_func: JsonBoxedSerializeFunc,
956 );
957 pub fn json_boxed_serialize(gboxed_type: GType, boxed: gconstpointer) -> *mut JsonNode;
958 pub fn json_construct_gobject(
959 gtype: GType,
960 data: *const c_char,
961 length: size_t,
962 error: *mut *mut glib::GError,
963 ) -> *mut gobject::GObject;
964 #[cfg(feature = "v1_2")]
965 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
966 pub fn json_from_string(str: *const c_char, error: *mut *mut glib::GError) -> *mut JsonNode;
967 pub fn json_gobject_deserialize(gtype: GType, node: *mut JsonNode) -> *mut gobject::GObject;
968 pub fn json_gobject_from_data(
969 gtype: GType,
970 data: *const c_char,
971 length: ssize_t,
972 error: *mut *mut glib::GError,
973 ) -> *mut gobject::GObject;
974 pub fn json_gobject_serialize(gobject: *mut gobject::GObject) -> *mut JsonNode;
975 pub fn json_gobject_to_data(gobject: *mut gobject::GObject, length: *mut size_t)
976 -> *mut c_char;
977 pub fn json_gvariant_deserialize(
978 json_node: *mut JsonNode,
979 signature: *const c_char,
980 error: *mut *mut glib::GError,
981 ) -> *mut glib::GVariant;
982 pub fn json_gvariant_deserialize_data(
983 json: *const c_char,
984 length: ssize_t,
985 signature: *const c_char,
986 error: *mut *mut glib::GError,
987 ) -> *mut glib::GVariant;
988 pub fn json_gvariant_serialize(variant: *mut glib::GVariant) -> *mut JsonNode;
989 pub fn json_gvariant_serialize_data(
990 variant: *mut glib::GVariant,
991 length: *mut size_t,
992 ) -> *mut c_char;
993 pub fn json_serialize_gobject(
994 gobject: *mut gobject::GObject,
995 length: *mut size_t,
996 ) -> *mut c_char;
997 #[cfg(feature = "v1_2")]
998 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
999 pub fn json_string_compare(a: gconstpointer, b: gconstpointer) -> c_int;
1000 #[cfg(feature = "v1_2")]
1001 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
1002 pub fn json_string_equal(a: gconstpointer, b: gconstpointer) -> gboolean;
1003 #[cfg(feature = "v1_2")]
1004 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
1005 pub fn json_string_hash(key: gconstpointer) -> c_uint;
1006 #[cfg(feature = "v1_2")]
1007 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
1008 pub fn json_to_string(node: *mut JsonNode, pretty: gboolean) -> *mut c_char;
1009
1010}