1use 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_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}