1use crate::{ffi,Node};
7use glib::{prelude::*,signal::{connect_raw, SignalHandlerId},translate::*};
8use std::{boxed::Box as Box_};
9
10glib::wrapper! {
11 #[doc(alias = "JsonReader")]
12 pub struct Reader(Object<ffi::JsonReader, ffi::JsonReaderClass>);
13
14 match fn {
15 type_ => || ffi::json_reader_get_type(),
16 }
17}
18
19impl Reader {
20 pub const NONE: Option<&'static Reader> = None;
21
22
23 #[doc(alias = "json_reader_new")]
24 pub fn new(node: Option<&Node>) -> Reader {
25 assert_initialized_main_thread!();
26 unsafe {
27 from_glib_full(ffi::json_reader_new(node.to_glib_none().0))
28 }
29 }
30
31 pub fn builder() -> ReaderBuilder {
36 ReaderBuilder::new()
37 }
38
39}
40
41impl Default for Reader {
42 fn default() -> Self {
43 glib::object::Object::new::<Self>()
44 }
45 }
46
47#[must_use = "The builder must be built to be used"]
52pub struct ReaderBuilder {
53 builder: glib::object::ObjectBuilder<'static, Reader>,
54 }
55
56 impl ReaderBuilder {
57 fn new() -> Self {
58 Self { builder: glib::object::Object::builder() }
59 }
60
61 pub fn root(self, root: &Node) -> Self {
62 Self { builder: self.builder.property("root", root.clone()), }
63 }
64
65 #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
68 pub fn build(self) -> Reader {
69assert_initialized_main_thread!();
70 self.builder.build() }
71}
72
73pub trait ReaderExt: IsA<Reader> + 'static {
74 #[doc(alias = "json_reader_count_elements")]
75 fn count_elements(&self) -> i32 {
76 unsafe {
77 ffi::json_reader_count_elements(self.as_ref().to_glib_none().0)
78 }
79 }
80
81 #[doc(alias = "json_reader_count_members")]
82 fn count_members(&self) -> i32 {
83 unsafe {
84 ffi::json_reader_count_members(self.as_ref().to_glib_none().0)
85 }
86 }
87
88 #[doc(alias = "json_reader_end_element")]
89 fn end_element(&self) {
90 unsafe {
91 ffi::json_reader_end_element(self.as_ref().to_glib_none().0);
92 }
93 }
94
95 #[doc(alias = "json_reader_end_member")]
96 fn end_member(&self) {
97 unsafe {
98 ffi::json_reader_end_member(self.as_ref().to_glib_none().0);
99 }
100 }
101
102 #[doc(alias = "json_reader_get_boolean_value")]
103 #[doc(alias = "get_boolean_value")]
104 fn is_boolean_value(&self) -> bool {
105 unsafe {
106 from_glib(ffi::json_reader_get_boolean_value(self.as_ref().to_glib_none().0))
107 }
108 }
109
110 #[cfg(feature = "v1_8")]
111 #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
112 #[doc(alias = "json_reader_get_current_node")]
113 #[doc(alias = "get_current_node")]
114 fn current_node(&self) -> Option<Node> {
115 unsafe {
116 from_glib_none(ffi::json_reader_get_current_node(self.as_ref().to_glib_none().0))
117 }
118 }
119
120 #[doc(alias = "json_reader_get_double_value")]
121 #[doc(alias = "get_double_value")]
122 fn double_value(&self) -> f64 {
123 unsafe {
124 ffi::json_reader_get_double_value(self.as_ref().to_glib_none().0)
125 }
126 }
127
128 #[doc(alias = "json_reader_get_error")]
129 #[doc(alias = "get_error")]
130 fn error(&self) -> Option<glib::Error> {
131 unsafe {
132 from_glib_none(ffi::json_reader_get_error(self.as_ref().to_glib_none().0))
133 }
134 }
135
136 #[doc(alias = "json_reader_get_int_value")]
137 #[doc(alias = "get_int_value")]
138 fn int_value(&self) -> i64 {
139 unsafe {
140 ffi::json_reader_get_int_value(self.as_ref().to_glib_none().0)
141 }
142 }
143
144 #[doc(alias = "json_reader_get_member_name")]
145 #[doc(alias = "get_member_name")]
146 fn member_name(&self) -> Option<glib::GString> {
147 unsafe {
148 from_glib_none(ffi::json_reader_get_member_name(self.as_ref().to_glib_none().0))
149 }
150 }
151
152 #[doc(alias = "json_reader_get_null_value")]
153 #[doc(alias = "get_null_value")]
154 fn is_null_value(&self) -> bool {
155 unsafe {
156 from_glib(ffi::json_reader_get_null_value(self.as_ref().to_glib_none().0))
157 }
158 }
159
160 #[doc(alias = "json_reader_get_string_value")]
161 #[doc(alias = "get_string_value")]
162 fn string_value(&self) -> glib::GString {
163 unsafe {
164 from_glib_none(ffi::json_reader_get_string_value(self.as_ref().to_glib_none().0))
165 }
166 }
167
168 #[doc(alias = "json_reader_get_value")]
169 #[doc(alias = "get_value")]
170 fn value(&self) -> Option<Node> {
171 unsafe {
172 from_glib_none(ffi::json_reader_get_value(self.as_ref().to_glib_none().0))
173 }
174 }
175
176 #[doc(alias = "json_reader_is_array")]
177 fn is_array(&self) -> bool {
178 unsafe {
179 from_glib(ffi::json_reader_is_array(self.as_ref().to_glib_none().0))
180 }
181 }
182
183 #[doc(alias = "json_reader_is_object")]
184 fn is_object(&self) -> bool {
185 unsafe {
186 from_glib(ffi::json_reader_is_object(self.as_ref().to_glib_none().0))
187 }
188 }
189
190 #[doc(alias = "json_reader_is_value")]
191 fn is_value(&self) -> bool {
192 unsafe {
193 from_glib(ffi::json_reader_is_value(self.as_ref().to_glib_none().0))
194 }
195 }
196
197 #[doc(alias = "json_reader_list_members")]
198 fn list_members(&self) -> Vec<glib::GString> {
199 unsafe {
200 FromGlibPtrContainer::from_glib_full(ffi::json_reader_list_members(self.as_ref().to_glib_none().0))
201 }
202 }
203
204 #[doc(alias = "json_reader_read_element")]
205 fn read_element(&self, index_: u32) -> bool {
206 unsafe {
207 from_glib(ffi::json_reader_read_element(self.as_ref().to_glib_none().0, index_))
208 }
209 }
210
211 #[doc(alias = "json_reader_read_member")]
212 fn read_member(&self, member_name: &str) -> bool {
213 unsafe {
214 from_glib(ffi::json_reader_read_member(self.as_ref().to_glib_none().0, member_name.to_glib_none().0))
215 }
216 }
217
218 #[doc(alias = "json_reader_set_root")]
219 #[doc(alias = "root")]
220 fn set_root(&self, root: Option<&Node>) {
221 unsafe {
222 ffi::json_reader_set_root(self.as_ref().to_glib_none().0, root.to_glib_none().0);
223 }
224 }
225
226 fn root(&self) -> Option<Node> {
227 ObjectExt::property(self.as_ref(), "root")
228 }
229
230 #[doc(alias = "root")]
231 fn connect_root_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
232 unsafe extern "C" fn notify_root_trampoline<P: IsA<Reader>, F: Fn(&P) + 'static>(this: *mut ffi::JsonReader, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) {
233 let f: &F = &*(f as *const F);
234 f(Reader::from_glib_borrow(this).unsafe_cast_ref())
235 }
236 unsafe {
237 let f: Box_<F> = Box_::new(f);
238 connect_raw(self.as_ptr() as *mut _, c"notify::root".as_ptr() as *const _,
239 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(notify_root_trampoline::<Self, F> as *const ())), Box_::into_raw(f))
240 }
241 }
242}
243
244impl<O: IsA<Reader>> ReaderExt for O {}