glib/auto/
key_file.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use glib_sys;
6use std;
7use std::mem;
8use std::ptr;
9use translate::*;
10#[cfg(any(feature = "v2_50", feature = "dox"))]
11use Bytes;
12use Char;
13use Error;
14use GString;
15use KeyFileFlags;
16
17glib_wrapper! {
18    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
19    pub struct KeyFile(Shared<glib_sys::GKeyFile>);
20
21    match fn {
22        ref => |ptr| glib_sys::g_key_file_ref(ptr),
23        unref => |ptr| glib_sys::g_key_file_unref(ptr),
24        get_type => || glib_sys::g_key_file_get_type(),
25    }
26}
27
28impl KeyFile {
29    pub fn new() -> KeyFile {
30        unsafe { from_glib_full(glib_sys::g_key_file_new()) }
31    }
32
33    pub fn get_comment(&self, group_name: Option<&str>, key: &str) -> Result<GString, Error> {
34        unsafe {
35            let mut error = ptr::null_mut();
36            let ret = glib_sys::g_key_file_get_comment(
37                self.to_glib_none().0,
38                group_name.to_glib_none().0,
39                key.to_glib_none().0,
40                &mut error,
41            );
42            if error.is_null() {
43                Ok(from_glib_full(ret))
44            } else {
45                Err(from_glib_full(error))
46            }
47        }
48    }
49
50    pub fn get_double(&self, group_name: &str, key: &str) -> Result<f64, Error> {
51        unsafe {
52            let mut error = ptr::null_mut();
53            let ret = glib_sys::g_key_file_get_double(
54                self.to_glib_none().0,
55                group_name.to_glib_none().0,
56                key.to_glib_none().0,
57                &mut error,
58            );
59            if error.is_null() {
60                Ok(ret)
61            } else {
62                Err(from_glib_full(error))
63            }
64        }
65    }
66
67    pub fn get_double_list(&self, group_name: &str, key: &str) -> Result<Vec<f64>, Error> {
68        unsafe {
69            let mut length = mem::uninitialized();
70            let mut error = ptr::null_mut();
71            let ret = glib_sys::g_key_file_get_double_list(
72                self.to_glib_none().0,
73                group_name.to_glib_none().0,
74                key.to_glib_none().0,
75                &mut length,
76                &mut error,
77            );
78            if error.is_null() {
79                Ok(FromGlibContainer::from_glib_container_num(
80                    ret,
81                    length as usize,
82                ))
83            } else {
84                Err(from_glib_full(error))
85            }
86        }
87    }
88
89    pub fn get_groups(&self) -> (Vec<GString>, usize) {
90        unsafe {
91            let mut length = mem::uninitialized();
92            let ret = FromGlibPtrContainer::from_glib_full(glib_sys::g_key_file_get_groups(
93                self.to_glib_none().0,
94                &mut length,
95            ));
96            (ret, length)
97        }
98    }
99
100    pub fn get_int64(&self, group_name: &str, key: &str) -> Result<i64, Error> {
101        unsafe {
102            let mut error = ptr::null_mut();
103            let ret = glib_sys::g_key_file_get_int64(
104                self.to_glib_none().0,
105                group_name.to_glib_none().0,
106                key.to_glib_none().0,
107                &mut error,
108            );
109            if error.is_null() {
110                Ok(ret)
111            } else {
112                Err(from_glib_full(error))
113            }
114        }
115    }
116
117    pub fn get_integer(&self, group_name: &str, key: &str) -> Result<i32, Error> {
118        unsafe {
119            let mut error = ptr::null_mut();
120            let ret = glib_sys::g_key_file_get_integer(
121                self.to_glib_none().0,
122                group_name.to_glib_none().0,
123                key.to_glib_none().0,
124                &mut error,
125            );
126            if error.is_null() {
127                Ok(ret)
128            } else {
129                Err(from_glib_full(error))
130            }
131        }
132    }
133
134    pub fn get_integer_list(&self, group_name: &str, key: &str) -> Result<Vec<i32>, Error> {
135        unsafe {
136            let mut length = mem::uninitialized();
137            let mut error = ptr::null_mut();
138            let ret = glib_sys::g_key_file_get_integer_list(
139                self.to_glib_none().0,
140                group_name.to_glib_none().0,
141                key.to_glib_none().0,
142                &mut length,
143                &mut error,
144            );
145            if error.is_null() {
146                Ok(FromGlibContainer::from_glib_container_num(
147                    ret,
148                    length as usize,
149                ))
150            } else {
151                Err(from_glib_full(error))
152            }
153        }
154    }
155
156    pub fn get_keys(&self, group_name: &str) -> Result<(Vec<GString>, usize), Error> {
157        unsafe {
158            let mut length = mem::uninitialized();
159            let mut error = ptr::null_mut();
160            let ret = glib_sys::g_key_file_get_keys(
161                self.to_glib_none().0,
162                group_name.to_glib_none().0,
163                &mut length,
164                &mut error,
165            );
166            if error.is_null() {
167                Ok((FromGlibPtrContainer::from_glib_full(ret), length))
168            } else {
169                Err(from_glib_full(error))
170            }
171        }
172    }
173
174    #[cfg(any(feature = "v2_56", feature = "dox"))]
175    pub fn get_locale_for_key(
176        &self,
177        group_name: &str,
178        key: &str,
179        locale: Option<&str>,
180    ) -> Option<GString> {
181        unsafe {
182            from_glib_full(glib_sys::g_key_file_get_locale_for_key(
183                self.to_glib_none().0,
184                group_name.to_glib_none().0,
185                key.to_glib_none().0,
186                locale.to_glib_none().0,
187            ))
188        }
189    }
190
191    pub fn get_locale_string(
192        &self,
193        group_name: &str,
194        key: &str,
195        locale: Option<&str>,
196    ) -> Result<GString, Error> {
197        unsafe {
198            let mut error = ptr::null_mut();
199            let ret = glib_sys::g_key_file_get_locale_string(
200                self.to_glib_none().0,
201                group_name.to_glib_none().0,
202                key.to_glib_none().0,
203                locale.to_glib_none().0,
204                &mut error,
205            );
206            if error.is_null() {
207                Ok(from_glib_full(ret))
208            } else {
209                Err(from_glib_full(error))
210            }
211        }
212    }
213
214    pub fn get_locale_string_list(
215        &self,
216        group_name: &str,
217        key: &str,
218        locale: Option<&str>,
219    ) -> Result<Vec<GString>, Error> {
220        unsafe {
221            let mut length = mem::uninitialized();
222            let mut error = ptr::null_mut();
223            let ret = glib_sys::g_key_file_get_locale_string_list(
224                self.to_glib_none().0,
225                group_name.to_glib_none().0,
226                key.to_glib_none().0,
227                locale.to_glib_none().0,
228                &mut length,
229                &mut error,
230            );
231            if error.is_null() {
232                Ok(FromGlibContainer::from_glib_full_num(ret, length as usize))
233            } else {
234                Err(from_glib_full(error))
235            }
236        }
237    }
238
239    pub fn get_start_group(&self) -> Option<GString> {
240        unsafe { from_glib_full(glib_sys::g_key_file_get_start_group(self.to_glib_none().0)) }
241    }
242
243    pub fn get_string(&self, group_name: &str, key: &str) -> Result<GString, Error> {
244        unsafe {
245            let mut error = ptr::null_mut();
246            let ret = glib_sys::g_key_file_get_string(
247                self.to_glib_none().0,
248                group_name.to_glib_none().0,
249                key.to_glib_none().0,
250                &mut error,
251            );
252            if error.is_null() {
253                Ok(from_glib_full(ret))
254            } else {
255                Err(from_glib_full(error))
256            }
257        }
258    }
259
260    pub fn get_string_list(&self, group_name: &str, key: &str) -> Result<Vec<GString>, Error> {
261        unsafe {
262            let mut length = mem::uninitialized();
263            let mut error = ptr::null_mut();
264            let ret = glib_sys::g_key_file_get_string_list(
265                self.to_glib_none().0,
266                group_name.to_glib_none().0,
267                key.to_glib_none().0,
268                &mut length,
269                &mut error,
270            );
271            if error.is_null() {
272                Ok(FromGlibContainer::from_glib_full_num(ret, length as usize))
273            } else {
274                Err(from_glib_full(error))
275            }
276        }
277    }
278
279    pub fn get_uint64(&self, group_name: &str, key: &str) -> Result<u64, Error> {
280        unsafe {
281            let mut error = ptr::null_mut();
282            let ret = glib_sys::g_key_file_get_uint64(
283                self.to_glib_none().0,
284                group_name.to_glib_none().0,
285                key.to_glib_none().0,
286                &mut error,
287            );
288            if error.is_null() {
289                Ok(ret)
290            } else {
291                Err(from_glib_full(error))
292            }
293        }
294    }
295
296    pub fn get_value(&self, group_name: &str, key: &str) -> Result<GString, Error> {
297        unsafe {
298            let mut error = ptr::null_mut();
299            let ret = glib_sys::g_key_file_get_value(
300                self.to_glib_none().0,
301                group_name.to_glib_none().0,
302                key.to_glib_none().0,
303                &mut error,
304            );
305            if error.is_null() {
306                Ok(from_glib_full(ret))
307            } else {
308                Err(from_glib_full(error))
309            }
310        }
311    }
312
313    pub fn has_group(&self, group_name: &str) -> bool {
314        unsafe {
315            from_glib(glib_sys::g_key_file_has_group(
316                self.to_glib_none().0,
317                group_name.to_glib_none().0,
318            ))
319        }
320    }
321
322    #[cfg(any(feature = "v2_50", feature = "dox"))]
323    pub fn load_from_bytes(&self, bytes: &Bytes, flags: KeyFileFlags) -> Result<(), Error> {
324        unsafe {
325            let mut error = ptr::null_mut();
326            let _ = glib_sys::g_key_file_load_from_bytes(
327                self.to_glib_none().0,
328                bytes.to_glib_none().0,
329                flags.to_glib(),
330                &mut error,
331            );
332            if error.is_null() {
333                Ok(())
334            } else {
335                Err(from_glib_full(error))
336            }
337        }
338    }
339
340    pub fn load_from_data(&self, data: &str, flags: KeyFileFlags) -> Result<(), Error> {
341        let length = data.len() as usize;
342        unsafe {
343            let mut error = ptr::null_mut();
344            let _ = glib_sys::g_key_file_load_from_data(
345                self.to_glib_none().0,
346                data.to_glib_none().0,
347                length,
348                flags.to_glib(),
349                &mut error,
350            );
351            if error.is_null() {
352                Ok(())
353            } else {
354                Err(from_glib_full(error))
355            }
356        }
357    }
358
359    pub fn load_from_file<P: AsRef<std::path::Path>>(
360        &self,
361        file: P,
362        flags: KeyFileFlags,
363    ) -> Result<(), Error> {
364        unsafe {
365            let mut error = ptr::null_mut();
366            let _ = glib_sys::g_key_file_load_from_file(
367                self.to_glib_none().0,
368                file.as_ref().to_glib_none().0,
369                flags.to_glib(),
370                &mut error,
371            );
372            if error.is_null() {
373                Ok(())
374            } else {
375                Err(from_glib_full(error))
376            }
377        }
378    }
379
380    pub fn remove_comment(&self, group_name: Option<&str>, key: Option<&str>) -> Result<(), Error> {
381        unsafe {
382            let mut error = ptr::null_mut();
383            let _ = glib_sys::g_key_file_remove_comment(
384                self.to_glib_none().0,
385                group_name.to_glib_none().0,
386                key.to_glib_none().0,
387                &mut error,
388            );
389            if error.is_null() {
390                Ok(())
391            } else {
392                Err(from_glib_full(error))
393            }
394        }
395    }
396
397    pub fn remove_group(&self, group_name: &str) -> Result<(), Error> {
398        unsafe {
399            let mut error = ptr::null_mut();
400            let _ = glib_sys::g_key_file_remove_group(
401                self.to_glib_none().0,
402                group_name.to_glib_none().0,
403                &mut error,
404            );
405            if error.is_null() {
406                Ok(())
407            } else {
408                Err(from_glib_full(error))
409            }
410        }
411    }
412
413    pub fn remove_key(&self, group_name: &str, key: &str) -> Result<(), Error> {
414        unsafe {
415            let mut error = ptr::null_mut();
416            let _ = glib_sys::g_key_file_remove_key(
417                self.to_glib_none().0,
418                group_name.to_glib_none().0,
419                key.to_glib_none().0,
420                &mut error,
421            );
422            if error.is_null() {
423                Ok(())
424            } else {
425                Err(from_glib_full(error))
426            }
427        }
428    }
429
430    pub fn set_boolean(&self, group_name: &str, key: &str, value: bool) {
431        unsafe {
432            glib_sys::g_key_file_set_boolean(
433                self.to_glib_none().0,
434                group_name.to_glib_none().0,
435                key.to_glib_none().0,
436                value.to_glib(),
437            );
438        }
439    }
440
441    //pub fn set_boolean_list(&self, group_name: &str, key: &str, list: /*Unimplemented*/&CArray TypeId { ns_id: 0, id: 1 }) {
442    //    unsafe { TODO: call glib_sys:g_key_file_set_boolean_list() }
443    //}
444
445    pub fn set_comment(
446        &self,
447        group_name: Option<&str>,
448        key: Option<&str>,
449        comment: &str,
450    ) -> Result<(), Error> {
451        unsafe {
452            let mut error = ptr::null_mut();
453            let _ = glib_sys::g_key_file_set_comment(
454                self.to_glib_none().0,
455                group_name.to_glib_none().0,
456                key.to_glib_none().0,
457                comment.to_glib_none().0,
458                &mut error,
459            );
460            if error.is_null() {
461                Ok(())
462            } else {
463                Err(from_glib_full(error))
464            }
465        }
466    }
467
468    pub fn set_double(&self, group_name: &str, key: &str, value: f64) {
469        unsafe {
470            glib_sys::g_key_file_set_double(
471                self.to_glib_none().0,
472                group_name.to_glib_none().0,
473                key.to_glib_none().0,
474                value,
475            );
476        }
477    }
478
479    pub fn set_int64(&self, group_name: &str, key: &str, value: i64) {
480        unsafe {
481            glib_sys::g_key_file_set_int64(
482                self.to_glib_none().0,
483                group_name.to_glib_none().0,
484                key.to_glib_none().0,
485                value,
486            );
487        }
488    }
489
490    pub fn set_integer(&self, group_name: &str, key: &str, value: i32) {
491        unsafe {
492            glib_sys::g_key_file_set_integer(
493                self.to_glib_none().0,
494                group_name.to_glib_none().0,
495                key.to_glib_none().0,
496                value,
497            );
498        }
499    }
500
501    pub fn set_list_separator(&self, separator: Char) {
502        unsafe {
503            glib_sys::g_key_file_set_list_separator(self.to_glib_none().0, separator.to_glib());
504        }
505    }
506
507    pub fn set_locale_string(&self, group_name: &str, key: &str, locale: &str, string: &str) {
508        unsafe {
509            glib_sys::g_key_file_set_locale_string(
510                self.to_glib_none().0,
511                group_name.to_glib_none().0,
512                key.to_glib_none().0,
513                locale.to_glib_none().0,
514                string.to_glib_none().0,
515            );
516        }
517    }
518
519    pub fn set_string(&self, group_name: &str, key: &str, string: &str) {
520        unsafe {
521            glib_sys::g_key_file_set_string(
522                self.to_glib_none().0,
523                group_name.to_glib_none().0,
524                key.to_glib_none().0,
525                string.to_glib_none().0,
526            );
527        }
528    }
529
530    pub fn set_uint64(&self, group_name: &str, key: &str, value: u64) {
531        unsafe {
532            glib_sys::g_key_file_set_uint64(
533                self.to_glib_none().0,
534                group_name.to_glib_none().0,
535                key.to_glib_none().0,
536                value,
537            );
538        }
539    }
540
541    pub fn set_value(&self, group_name: &str, key: &str, value: &str) {
542        unsafe {
543            glib_sys::g_key_file_set_value(
544                self.to_glib_none().0,
545                group_name.to_glib_none().0,
546                key.to_glib_none().0,
547                value.to_glib_none().0,
548            );
549        }
550    }
551}
552
553impl Default for KeyFile {
554    fn default() -> Self {
555        Self::new()
556    }
557}