source: appstream-generator/build/girepo/glib/KeyFile.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 33.6 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module glib.KeyFile;
22
23private import gi.glib;
24public  import gi.glibtypes;
25private import glib.ConstructionException;
26private import glib.ErrorG;
27private import glib.GException;
28private import glib.Str;
29
30
31/**
32 * The GKeyFile struct contains only private data
33 * and should not be accessed directly.
34 */
35public class KeyFile
36{
37        /** the main Gtk struct */
38        protected GKeyFile* gKeyFile;
39        protected bool ownedRef;
40
41        /** Get the main Gtk struct */
42        public GKeyFile* getKeyFileStruct()
43        {
44                return gKeyFile;
45        }
46
47        /** the main Gtk struct as a void* */
48        protected void* getStruct()
49        {
50                return cast(void*)gKeyFile;
51        }
52
53        /**
54         * Sets our main struct and passes it to the parent class.
55         */
56        public this (GKeyFile* gKeyFile, bool ownedRef = false)
57        {
58                this.gKeyFile = gKeyFile;
59                this.ownedRef = ownedRef;
60        }
61
62
63        /**
64         * Creates a new empty #GKeyFile object. Use
65         * g_key_file_load_from_file(), g_key_file_load_from_data(),
66         * g_key_file_load_from_dirs() or g_key_file_load_from_data_dirs() to
67         * read an existing key file.
68         *
69         * Returns: an empty #GKeyFile.
70         *
71         * Since: 2.6
72         *
73         * Throws: ConstructionException GTK+ fails to create the object.
74         */
75        public this()
76        {
77                auto p = g_key_file_new();
78               
79                if(p is null)
80                {
81                        throw new ConstructionException("null returned by new");
82                }
83               
84                this(cast(GKeyFile*) p);
85        }
86
87        /**
88         * Clears all keys and groups from @key_file, and decreases the
89         * reference count by 1. If the reference count reaches zero,
90         * frees the key file and all its allocated memory.
91         *
92         * Since: 2.6
93         */
94        public void free()
95        {
96                g_key_file_free(gKeyFile);
97        }
98
99        /**
100         * Returns the value associated with @key under @group_name as a
101         * boolean.
102         *
103         * If @key cannot be found then %FALSE is returned and @error is set
104         * to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value
105         * associated with @key cannot be interpreted as a boolean then %FALSE
106         * is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
107         *
108         * Params:
109         *     groupName = a group name
110         *     key = a key
111         *
112         * Returns: the value associated with the key as a boolean,
113         *     or %FALSE if the key was not found or could not be parsed.
114         *
115         * Since: 2.6
116         *
117         * Throws: GException on failure.
118         */
119        public bool getBoolean(string groupName, string key)
120        {
121                GError* err = null;
122               
123                auto p = g_key_file_get_boolean(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err) != 0;
124               
125                if (err !is null)
126                {
127                        throw new GException( new ErrorG(err) );
128                }
129               
130                return p;
131        }
132
133        /**
134         * Returns the values associated with @key under @group_name as
135         * booleans.
136         *
137         * If @key cannot be found then %NULL is returned and @error is set to
138         * #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
139         * with @key cannot be interpreted as booleans then %NULL is returned
140         * and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
141         *
142         * Params:
143         *     groupName = a group name
144         *     key = a key
145         *
146         * Returns: the values associated with the key as a list of booleans, or %NULL if the
147         *     key was not found or could not be parsed. The returned list of booleans
148         *     should be freed with g_free() when no longer needed.
149         *
150         * Since: 2.6
151         *
152         * Throws: GException on failure.
153         */
154        public bool[] getBooleanList(string groupName, string key)
155        {
156                size_t length;
157                GError* err = null;
158               
159                auto p = g_key_file_get_boolean_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &length, &err);
160               
161                if (err !is null)
162                {
163                        throw new GException( new ErrorG(err) );
164                }
165               
166                bool[] r = new bool[length];
167                for(size_t i = 0; i < length; i++)
168                {
169                        r[i] = p[i] != 0;
170                }
171                return r;
172        }
173
174        /**
175         * Retrieves a comment above @key from @group_name.
176         * If @key is %NULL then @comment will be read from above
177         * @group_name. If both @key and @group_name are %NULL, then
178         * @comment will be read from above the first group in the file.
179         *
180         * Note that the returned string includes the '#' comment markers.
181         *
182         * Params:
183         *     groupName = a group name, or %NULL
184         *     key = a key
185         *
186         * Returns: a comment that should be freed with g_free()
187         *
188         * Since: 2.6
189         *
190         * Throws: GException on failure.
191         */
192        public string getComment(string groupName, string key)
193        {
194                GError* err = null;
195               
196                auto retStr = g_key_file_get_comment(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err);
197               
198                if (err !is null)
199                {
200                        throw new GException( new ErrorG(err) );
201                }
202               
203                scope(exit) Str.freeString(retStr);
204                return Str.toString(retStr);
205        }
206
207        /**
208         * Returns the value associated with @key under @group_name as a
209         * double. If @group_name is %NULL, the start_group is used.
210         *
211         * If @key cannot be found then 0.0 is returned and @error is set to
212         * #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
213         * with @key cannot be interpreted as a double then 0.0 is returned
214         * and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
215         *
216         * Params:
217         *     groupName = a group name
218         *     key = a key
219         *
220         * Returns: the value associated with the key as a double, or
221         *     0.0 if the key was not found or could not be parsed.
222         *
223         * Since: 2.12
224         *
225         * Throws: GException on failure.
226         */
227        public double getDouble(string groupName, string key)
228        {
229                GError* err = null;
230               
231                auto p = g_key_file_get_double(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err);
232               
233                if (err !is null)
234                {
235                        throw new GException( new ErrorG(err) );
236                }
237               
238                return p;
239        }
240
241        /**
242         * Returns the values associated with @key under @group_name as
243         * doubles.
244         *
245         * If @key cannot be found then %NULL is returned and @error is set to
246         * #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
247         * with @key cannot be interpreted as doubles then %NULL is returned
248         * and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
249         *
250         * Params:
251         *     groupName = a group name
252         *     key = a key
253         *
254         * Returns: the values associated with the key as a list of doubles, or %NULL if the
255         *     key was not found or could not be parsed. The returned list of doubles
256         *     should be freed with g_free() when no longer needed.
257         *
258         * Since: 2.12
259         *
260         * Throws: GException on failure.
261         */
262        public double[] getDoubleList(string groupName, string key)
263        {
264                size_t length;
265                GError* err = null;
266               
267                auto p = g_key_file_get_double_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &length, &err);
268               
269                if (err !is null)
270                {
271                        throw new GException( new ErrorG(err) );
272                }
273               
274                return p[0 .. length];
275        }
276
277        /**
278         * Returns all groups in the key file loaded with @key_file.
279         * The array of returned groups will be %NULL-terminated, so
280         * @length may optionally be %NULL.
281         *
282         * Params:
283         *     length = return location for the number of returned groups, or %NULL
284         *
285         * Returns: a newly-allocated %NULL-terminated array of strings.
286         *     Use g_strfreev() to free it.
287         *
288         * Since: 2.6
289         */
290        public string[] getGroups(out size_t length)
291        {
292                auto retStr = g_key_file_get_groups(gKeyFile, &length);
293               
294                scope(exit) Str.freeStringArray(retStr);
295                return Str.toStringArray(retStr);
296        }
297
298        /**
299         * Returns the value associated with @key under @group_name as a signed
300         * 64-bit integer. This is similar to g_key_file_get_integer() but can return
301         * 64-bit results without truncation.
302         *
303         * Params:
304         *     groupName = a non-%NULL group name
305         *     key = a non-%NULL key
306         *
307         * Returns: the value associated with the key as a signed 64-bit integer, or
308         *     0 if the key was not found or could not be parsed.
309         *
310         * Since: 2.26
311         *
312         * Throws: GException on failure.
313         */
314        public long getInt64(string groupName, string key)
315        {
316                GError* err = null;
317               
318                auto p = g_key_file_get_int64(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err);
319               
320                if (err !is null)
321                {
322                        throw new GException( new ErrorG(err) );
323                }
324               
325                return p;
326        }
327
328        /**
329         * Returns the value associated with @key under @group_name as an
330         * integer.
331         *
332         * If @key cannot be found then 0 is returned and @error is set to
333         * #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
334         * with @key cannot be interpreted as an integer then 0 is returned
335         * and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
336         *
337         * Params:
338         *     groupName = a group name
339         *     key = a key
340         *
341         * Returns: the value associated with the key as an integer, or
342         *     0 if the key was not found or could not be parsed.
343         *
344         * Since: 2.6
345         *
346         * Throws: GException on failure.
347         */
348        public int getInteger(string groupName, string key)
349        {
350                GError* err = null;
351               
352                auto p = g_key_file_get_integer(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err);
353               
354                if (err !is null)
355                {
356                        throw new GException( new ErrorG(err) );
357                }
358               
359                return p;
360        }
361
362        /**
363         * Returns the values associated with @key under @group_name as
364         * integers.
365         *
366         * If @key cannot be found then %NULL is returned and @error is set to
367         * #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
368         * with @key cannot be interpreted as integers then %NULL is returned
369         * and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.
370         *
371         * Params:
372         *     groupName = a group name
373         *     key = a key
374         *
375         * Returns: the values associated with the key as a list of integers, or %NULL if
376         *     the key was not found or could not be parsed. The returned list of
377         *     integers should be freed with g_free() when no longer needed.
378         *
379         * Since: 2.6
380         *
381         * Throws: GException on failure.
382         */
383        public int[] getIntegerList(string groupName, string key)
384        {
385                size_t length;
386                GError* err = null;
387               
388                auto p = g_key_file_get_integer_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &length, &err);
389               
390                if (err !is null)
391                {
392                        throw new GException( new ErrorG(err) );
393                }
394               
395                return p[0 .. length];
396        }
397
398        /**
399         * Returns all keys for the group name @group_name.  The array of
400         * returned keys will be %NULL-terminated, so @length may
401         * optionally be %NULL. In the event that the @group_name cannot
402         * be found, %NULL is returned and @error is set to
403         * #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
404         *
405         * Params:
406         *     groupName = a group name
407         *     length = return location for the number of keys returned, or %NULL
408         *
409         * Returns: a newly-allocated %NULL-terminated array of strings.
410         *     Use g_strfreev() to free it.
411         *
412         * Since: 2.6
413         *
414         * Throws: GException on failure.
415         */
416        public string[] getKeys(string groupName, out size_t length)
417        {
418                GError* err = null;
419               
420                auto retStr = g_key_file_get_keys(gKeyFile, Str.toStringz(groupName), &length, &err);
421               
422                if (err !is null)
423                {
424                        throw new GException( new ErrorG(err) );
425                }
426               
427                scope(exit) Str.freeStringArray(retStr);
428                return Str.toStringArray(retStr);
429        }
430
431        /**
432         * Returns the value associated with @key under @group_name
433         * translated in the given @locale if available.  If @locale is
434         * %NULL then the current locale is assumed.
435         *
436         * If @key cannot be found then %NULL is returned and @error is set
437         * to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the value associated
438         * with @key cannot be interpreted or no suitable translation can
439         * be found then the untranslated value is returned.
440         *
441         * Params:
442         *     groupName = a group name
443         *     key = a key
444         *     locale = a locale identifier or %NULL
445         *
446         * Returns: a newly allocated string or %NULL if the specified
447         *     key cannot be found.
448         *
449         * Since: 2.6
450         *
451         * Throws: GException on failure.
452         */
453        public string getLocaleString(string groupName, string key, string locale)
454        {
455                GError* err = null;
456               
457                auto retStr = g_key_file_get_locale_string(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), Str.toStringz(locale), &err);
458               
459                if (err !is null)
460                {
461                        throw new GException( new ErrorG(err) );
462                }
463               
464                scope(exit) Str.freeString(retStr);
465                return Str.toString(retStr);
466        }
467
468        /**
469         * Returns the values associated with @key under @group_name
470         * translated in the given @locale if available.  If @locale is
471         * %NULL then the current locale is assumed.
472         *
473         * If @key cannot be found then %NULL is returned and @error is set
474         * to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the values associated
475         * with @key cannot be interpreted or no suitable translations
476         * can be found then the untranslated values are returned. The
477         * returned array is %NULL-terminated, so @length may optionally
478         * be %NULL.
479         *
480         * Params:
481         *     groupName = a group name
482         *     key = a key
483         *     locale = a locale identifier or %NULL
484         *
485         * Returns: a newly allocated %NULL-terminated string array
486         *     or %NULL if the key isn't found. The string array should be freed
487         *     with g_strfreev().
488         *
489         * Since: 2.6
490         *
491         * Throws: GException on failure.
492         */
493        public string[] getLocaleStringList(string groupName, string key, string locale)
494        {
495                size_t length;
496                GError* err = null;
497               
498                auto retStr = g_key_file_get_locale_string_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), Str.toStringz(locale), &length, &err);
499               
500                if (err !is null)
501                {
502                        throw new GException( new ErrorG(err) );
503                }
504               
505                scope(exit) Str.freeStringArray(retStr);
506                return Str.toStringArray(retStr, length);
507        }
508
509        /**
510         * Returns the name of the start group of the file.
511         *
512         * Returns: The start group of the key file.
513         *
514         * Since: 2.6
515         */
516        public string getStartGroup()
517        {
518                auto retStr = g_key_file_get_start_group(gKeyFile);
519               
520                scope(exit) Str.freeString(retStr);
521                return Str.toString(retStr);
522        }
523
524        /**
525         * Returns the string value associated with @key under @group_name.
526         * Unlike g_key_file_get_value(), this function handles escape sequences
527         * like \s.
528         *
529         * In the event the key cannot be found, %NULL is returned and
530         * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
531         * event that the @group_name cannot be found, %NULL is returned
532         * and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
533         *
534         * Params:
535         *     groupName = a group name
536         *     key = a key
537         *
538         * Returns: a newly allocated string or %NULL if the specified
539         *     key cannot be found.
540         *
541         * Since: 2.6
542         *
543         * Throws: GException on failure.
544         */
545        public string getString(string groupName, string key)
546        {
547                GError* err = null;
548               
549                auto retStr = g_key_file_get_string(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err);
550               
551                if (err !is null)
552                {
553                        throw new GException( new ErrorG(err) );
554                }
555               
556                scope(exit) Str.freeString(retStr);
557                return Str.toString(retStr);
558        }
559
560        /**
561         * Returns the values associated with @key under @group_name.
562         *
563         * In the event the key cannot be found, %NULL is returned and
564         * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
565         * event that the @group_name cannot be found, %NULL is returned
566         * and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
567         *
568         * Params:
569         *     groupName = a group name
570         *     key = a key
571         *
572         * Returns: a %NULL-terminated string array or %NULL if the specified
573         *     key cannot be found. The array should be freed with g_strfreev().
574         *
575         * Since: 2.6
576         *
577         * Throws: GException on failure.
578         */
579        public string[] getStringList(string groupName, string key)
580        {
581                size_t length;
582                GError* err = null;
583               
584                auto retStr = g_key_file_get_string_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &length, &err);
585               
586                if (err !is null)
587                {
588                        throw new GException( new ErrorG(err) );
589                }
590               
591                scope(exit) Str.freeStringArray(retStr);
592                return Str.toStringArray(retStr, length);
593        }
594
595        /**
596         * Returns the value associated with @key under @group_name as an unsigned
597         * 64-bit integer. This is similar to g_key_file_get_integer() but can return
598         * large positive results without truncation.
599         *
600         * Params:
601         *     groupName = a non-%NULL group name
602         *     key = a non-%NULL key
603         *
604         * Returns: the value associated with the key as an unsigned 64-bit integer,
605         *     or 0 if the key was not found or could not be parsed.
606         *
607         * Since: 2.26
608         *
609         * Throws: GException on failure.
610         */
611        public ulong getUint64(string groupName, string key)
612        {
613                GError* err = null;
614               
615                auto p = g_key_file_get_uint64(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err);
616               
617                if (err !is null)
618                {
619                        throw new GException( new ErrorG(err) );
620                }
621               
622                return p;
623        }
624
625        /**
626         * Returns the raw value associated with @key under @group_name.
627         * Use g_key_file_get_string() to retrieve an unescaped UTF-8 string.
628         *
629         * In the event the key cannot be found, %NULL is returned and
630         * @error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
631         * event that the @group_name cannot be found, %NULL is returned
632         * and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
633         *
634         * Params:
635         *     groupName = a group name
636         *     key = a key
637         *
638         * Returns: a newly allocated string or %NULL if the specified
639         *     key cannot be found.
640         *
641         * Since: 2.6
642         *
643         * Throws: GException on failure.
644         */
645        public string getValue(string groupName, string key)
646        {
647                GError* err = null;
648               
649                auto retStr = g_key_file_get_value(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err);
650               
651                if (err !is null)
652                {
653                        throw new GException( new ErrorG(err) );
654                }
655               
656                scope(exit) Str.freeString(retStr);
657                return Str.toString(retStr);
658        }
659
660        /**
661         * Looks whether the key file has the group @group_name.
662         *
663         * Params:
664         *     groupName = a group name
665         *
666         * Returns: %TRUE if @group_name is a part of @key_file, %FALSE
667         *     otherwise.
668         *
669         * Since: 2.6
670         */
671        public bool hasGroup(string groupName)
672        {
673                return g_key_file_has_group(gKeyFile, Str.toStringz(groupName)) != 0;
674        }
675
676        /**
677         * Looks whether the key file has the key @key in the group
678         * @group_name.
679         *
680         * Note that this function does not follow the rules for #GError strictly;
681         * the return value both carries meaning and signals an error.  To use
682         * this function, you must pass a #GError pointer in @error, and check
683         * whether it is not %NULL to see if an error occurred.
684         *
685         * Language bindings should use g_key_file_get_value() to test whether
686         * or not a key exists.
687         *
688         * Params:
689         *     groupName = a group name
690         *     key = a key name
691         *
692         * Returns: %TRUE if @key is a part of @group_name, %FALSE otherwise
693         *
694         * Since: 2.6
695         *
696         * Throws: GException on failure.
697         */
698        public bool hasKey(string groupName, string key)
699        {
700                GError* err = null;
701               
702                auto p = g_key_file_has_key(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err) != 0;
703               
704                if (err !is null)
705                {
706                        throw new GException( new ErrorG(err) );
707                }
708               
709                return p;
710        }
711
712        /**
713         * Loads a key file from memory into an empty #GKeyFile structure.
714         * If the object cannot be created then %error is set to a #GKeyFileError.
715         *
716         * Params:
717         *     data = key file loaded in memory
718         *     length = the length of @data in bytes (or (gsize)-1 if data is nul-terminated)
719         *     flags = flags from #GKeyFileFlags
720         *
721         * Returns: %TRUE if a key file could be loaded, %FALSE otherwise
722         *
723         * Since: 2.6
724         *
725         * Throws: GException on failure.
726         */
727        public bool loadFromData(string data, size_t length, GKeyFileFlags flags)
728        {
729                GError* err = null;
730               
731                auto p = g_key_file_load_from_data(gKeyFile, Str.toStringz(data), length, flags, &err) != 0;
732               
733                if (err !is null)
734                {
735                        throw new GException( new ErrorG(err) );
736                }
737               
738                return p;
739        }
740
741        /**
742         * This function looks for a key file named @file in the paths
743         * returned from g_get_user_data_dir() and g_get_system_data_dirs(),
744         * loads the file into @key_file and returns the file's full path in
745         * @full_path.  If the file could not be loaded then an %error is
746         * set to either a #GFileError or #GKeyFileError.
747         *
748         * Params:
749         *     file = a relative path to a filename to open and parse
750         *     fullPath = return location for a string containing the full path
751         *         of the file, or %NULL
752         *     flags = flags from #GKeyFileFlags
753         *
754         * Returns: %TRUE if a key file could be loaded, %FALSE othewise
755         *
756         * Since: 2.6
757         *
758         * Throws: GException on failure.
759         */
760        public bool loadFromDataDirs(string file, out string fullPath, GKeyFileFlags flags)
761        {
762                char* outfullPath = null;
763                GError* err = null;
764               
765                auto p = g_key_file_load_from_data_dirs(gKeyFile, Str.toStringz(file), &outfullPath, flags, &err) != 0;
766               
767                if (err !is null)
768                {
769                        throw new GException( new ErrorG(err) );
770                }
771               
772                fullPath = Str.toString(outfullPath);
773               
774                return p;
775        }
776
777        /**
778         * This function looks for a key file named @file in the paths
779         * specified in @search_dirs, loads the file into @key_file and
780         * returns the file's full path in @full_path.  If the file could not
781         * be loaded then an %error is set to either a #GFileError or
782         * #GKeyFileError.
783         *
784         * Params:
785         *     file = a relative path to a filename to open and parse
786         *     searchDirs = %NULL-terminated array of directories to search
787         *     fullPath = return location for a string containing the full path
788         *         of the file, or %NULL
789         *     flags = flags from #GKeyFileFlags
790         *
791         * Returns: %TRUE if a key file could be loaded, %FALSE otherwise
792         *
793         * Since: 2.14
794         *
795         * Throws: GException on failure.
796         */
797        public bool loadFromDirs(string file, string[] searchDirs, out string fullPath, GKeyFileFlags flags)
798        {
799                char* outfullPath = null;
800                GError* err = null;
801               
802                auto p = g_key_file_load_from_dirs(gKeyFile, Str.toStringz(file), Str.toStringzArray(searchDirs), &outfullPath, flags, &err) != 0;
803               
804                if (err !is null)
805                {
806                        throw new GException( new ErrorG(err) );
807                }
808               
809                fullPath = Str.toString(outfullPath);
810               
811                return p;
812        }
813
814        /**
815         * Loads a key file into an empty #GKeyFile structure.
816         * If the file could not be loaded then @error is set to
817         * either a #GFileError or #GKeyFileError.
818         *
819         * Params:
820         *     file = the path of a filename to load, in the GLib filename encoding
821         *     flags = flags from #GKeyFileFlags
822         *
823         * Returns: %TRUE if a key file could be loaded, %FALSE otherwise
824         *
825         * Since: 2.6
826         *
827         * Throws: GException on failure.
828         */
829        public bool loadFromFile(string file, GKeyFileFlags flags)
830        {
831                GError* err = null;
832               
833                auto p = g_key_file_load_from_file(gKeyFile, Str.toStringz(file), flags, &err) != 0;
834               
835                if (err !is null)
836                {
837                        throw new GException( new ErrorG(err) );
838                }
839               
840                return p;
841        }
842
843        /**
844         * Increases the reference count of @key_file.
845         *
846         * Returns: the same @key_file.
847         *
848         * Since: 2.32
849         */
850        public KeyFile doref()
851        {
852                auto p = g_key_file_ref(gKeyFile);
853               
854                if(p is null)
855                {
856                        return null;
857                }
858               
859                return new KeyFile(cast(GKeyFile*) p, true);
860        }
861
862        /**
863         * Removes a comment above @key from @group_name.
864         * If @key is %NULL then @comment will be removed above @group_name.
865         * If both @key and @group_name are %NULL, then @comment will
866         * be removed above the first group in the file.
867         *
868         * Params:
869         *     groupName = a group name, or %NULL
870         *     key = a key
871         *
872         * Returns: %TRUE if the comment was removed, %FALSE otherwise
873         *
874         * Since: 2.6
875         *
876         * Throws: GException on failure.
877         */
878        public bool removeComment(string groupName, string key)
879        {
880                GError* err = null;
881               
882                auto p = g_key_file_remove_comment(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err) != 0;
883               
884                if (err !is null)
885                {
886                        throw new GException( new ErrorG(err) );
887                }
888               
889                return p;
890        }
891
892        /**
893         * Removes the specified group, @group_name,
894         * from the key file.
895         *
896         * Params:
897         *     groupName = a group name
898         *
899         * Returns: %TRUE if the group was removed, %FALSE otherwise
900         *
901         * Since: 2.6
902         *
903         * Throws: GException on failure.
904         */
905        public bool removeGroup(string groupName)
906        {
907                GError* err = null;
908               
909                auto p = g_key_file_remove_group(gKeyFile, Str.toStringz(groupName), &err) != 0;
910               
911                if (err !is null)
912                {
913                        throw new GException( new ErrorG(err) );
914                }
915               
916                return p;
917        }
918
919        /**
920         * Removes @key in @group_name from the key file.
921         *
922         * Params:
923         *     groupName = a group name
924         *     key = a key name to remove
925         *
926         * Returns: %TRUE if the key was removed, %FALSE otherwise
927         *
928         * Since: 2.6
929         *
930         * Throws: GException on failure.
931         */
932        public bool removeKey(string groupName, string key)
933        {
934                GError* err = null;
935               
936                auto p = g_key_file_remove_key(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), &err) != 0;
937               
938                if (err !is null)
939                {
940                        throw new GException( new ErrorG(err) );
941                }
942               
943                return p;
944        }
945
946        /**
947         * Writes the contents of @key_file to @filename using
948         * g_file_set_contents().
949         *
950         * This function can fail for any of the reasons that
951         * g_file_set_contents() may fail.
952         *
953         * Params:
954         *     filename = the name of the file to write to
955         *
956         * Returns: %TRUE if successful, else %FALSE with @error set
957         *
958         * Since: 2.40
959         *
960         * Throws: GException on failure.
961         */
962        public bool saveToFile(string filename)
963        {
964                GError* err = null;
965               
966                auto p = g_key_file_save_to_file(gKeyFile, Str.toStringz(filename), &err) != 0;
967               
968                if (err !is null)
969                {
970                        throw new GException( new ErrorG(err) );
971                }
972               
973                return p;
974        }
975
976        /**
977         * Associates a new boolean value with @key under @group_name.
978         * If @key cannot be found then it is created.
979         *
980         * Params:
981         *     groupName = a group name
982         *     key = a key
983         *     value = %TRUE or %FALSE
984         *
985         * Since: 2.6
986         */
987        public void setBoolean(string groupName, string key, bool value)
988        {
989                g_key_file_set_boolean(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), value);
990        }
991
992        /**
993         * Associates a list of boolean values with @key under @group_name.
994         * If @key cannot be found then it is created.
995         * If @group_name is %NULL, the start_group is used.
996         *
997         * Params:
998         *     groupName = a group name
999         *     key = a key
1000         *     list = an array of boolean values
1001         *     length = length of @list
1002         *
1003         * Since: 2.6
1004         */
1005        public void setBooleanList(string groupName, string key, bool[] list)
1006        {
1007                int[] listArray = new int[list.length];
1008                for ( int i = 0; i < list.length; i++ )
1009                {
1010                        listArray[i] = list[i] ? 1 : 0;
1011                }
1012               
1013                g_key_file_set_boolean_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), listArray.ptr, cast(size_t)list.length);
1014        }
1015
1016        /**
1017         * Places a comment above @key from @group_name.
1018         *
1019         * If @key is %NULL then @comment will be written above @group_name.
1020         * If both @key and @group_name  are %NULL, then @comment will be
1021         * written above the first group in the file.
1022         *
1023         * Note that this function prepends a '#' comment marker to
1024         * each line of @comment.
1025         *
1026         * Params:
1027         *     groupName = a group name, or %NULL
1028         *     key = a key
1029         *     comment = a comment
1030         *
1031         * Returns: %TRUE if the comment was written, %FALSE otherwise
1032         *
1033         * Since: 2.6
1034         *
1035         * Throws: GException on failure.
1036         */
1037        public bool setComment(string groupName, string key, string comment)
1038        {
1039                GError* err = null;
1040               
1041                auto p = g_key_file_set_comment(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), Str.toStringz(comment), &err) != 0;
1042               
1043                if (err !is null)
1044                {
1045                        throw new GException( new ErrorG(err) );
1046                }
1047               
1048                return p;
1049        }
1050
1051        /**
1052         * Associates a new double value with @key under @group_name.
1053         * If @key cannot be found then it is created.
1054         *
1055         * Params:
1056         *     groupName = a group name
1057         *     key = a key
1058         *     value = an double value
1059         *
1060         * Since: 2.12
1061         */
1062        public void setDouble(string groupName, string key, double value)
1063        {
1064                g_key_file_set_double(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), value);
1065        }
1066
1067        /**
1068         * Associates a list of double values with @key under
1069         * @group_name.  If @key cannot be found then it is created.
1070         *
1071         * Params:
1072         *     groupName = a group name
1073         *     key = a key
1074         *     list = an array of double values
1075         *     length = number of double values in @list
1076         *
1077         * Since: 2.12
1078         */
1079        public void setDoubleList(string groupName, string key, double[] list)
1080        {
1081                g_key_file_set_double_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), list.ptr, cast(size_t)list.length);
1082        }
1083
1084        /**
1085         * Associates a new integer value with @key under @group_name.
1086         * If @key cannot be found then it is created.
1087         *
1088         * Params:
1089         *     groupName = a group name
1090         *     key = a key
1091         *     value = an integer value
1092         *
1093         * Since: 2.26
1094         */
1095        public void setInt64(string groupName, string key, long value)
1096        {
1097                g_key_file_set_int64(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), value);
1098        }
1099
1100        /**
1101         * Associates a new integer value with @key under @group_name.
1102         * If @key cannot be found then it is created.
1103         *
1104         * Params:
1105         *     groupName = a group name
1106         *     key = a key
1107         *     value = an integer value
1108         *
1109         * Since: 2.6
1110         */
1111        public void setInteger(string groupName, string key, int value)
1112        {
1113                g_key_file_set_integer(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), value);
1114        }
1115
1116        /**
1117         * Associates a list of integer values with @key under @group_name.
1118         * If @key cannot be found then it is created.
1119         *
1120         * Params:
1121         *     groupName = a group name
1122         *     key = a key
1123         *     list = an array of integer values
1124         *     length = number of integer values in @list
1125         *
1126         * Since: 2.6
1127         */
1128        public void setIntegerList(string groupName, string key, int[] list)
1129        {
1130                g_key_file_set_integer_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), list.ptr, cast(size_t)list.length);
1131        }
1132
1133        /**
1134         * Sets the character which is used to separate
1135         * values in lists. Typically ';' or ',' are used
1136         * as separators. The default list separator is ';'.
1137         *
1138         * Params:
1139         *     separator = the separator
1140         *
1141         * Since: 2.6
1142         */
1143        public void setListSeparator(char separator)
1144        {
1145                g_key_file_set_list_separator(gKeyFile, separator);
1146        }
1147
1148        /**
1149         * Associates a string value for @key and @locale under @group_name.
1150         * If the translation for @key cannot be found then it is created.
1151         *
1152         * Params:
1153         *     groupName = a group name
1154         *     key = a key
1155         *     locale = a locale identifier
1156         *     str = a string
1157         *
1158         * Since: 2.6
1159         */
1160        public void setLocaleString(string groupName, string key, string locale, string str)
1161        {
1162                g_key_file_set_locale_string(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), Str.toStringz(locale), Str.toStringz(str));
1163        }
1164
1165        /**
1166         * Associates a list of string values for @key and @locale under
1167         * @group_name.  If the translation for @key cannot be found then
1168         * it is created.
1169         *
1170         * Params:
1171         *     groupName = a group name
1172         *     key = a key
1173         *     locale = a locale identifier
1174         *     list = a %NULL-terminated array of locale string values
1175         *     length = the length of @list
1176         *
1177         * Since: 2.6
1178         */
1179        public void setLocaleStringList(string groupName, string key, string locale, string list)
1180        {
1181                g_key_file_set_locale_string_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), Str.toStringz(locale), Str.toStringz(list), cast(size_t)list.length);
1182        }
1183
1184        /**
1185         * Associates a new string value with @key under @group_name.
1186         * If @key cannot be found then it is created.
1187         * If @group_name cannot be found then it is created.
1188         * Unlike g_key_file_set_value(), this function handles characters
1189         * that need escaping, such as newlines.
1190         *
1191         * Params:
1192         *     groupName = a group name
1193         *     key = a key
1194         *     str = a string
1195         *
1196         * Since: 2.6
1197         */
1198        public void setString(string groupName, string key, string str)
1199        {
1200                g_key_file_set_string(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), Str.toStringz(str));
1201        }
1202
1203        /**
1204         * Associates a list of string values for @key under @group_name.
1205         * If @key cannot be found then it is created.
1206         * If @group_name cannot be found then it is created.
1207         *
1208         * Params:
1209         *     groupName = a group name
1210         *     key = a key
1211         *     list = an array of string values
1212         *     length = number of string values in @list
1213         *
1214         * Since: 2.6
1215         */
1216        public void setStringList(string groupName, string key, string[] list)
1217        {
1218                g_key_file_set_string_list(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), Str.toStringzArray(list), cast(size_t)list.length);
1219        }
1220
1221        /**
1222         * Associates a new integer value with @key under @group_name.
1223         * If @key cannot be found then it is created.
1224         *
1225         * Params:
1226         *     groupName = a group name
1227         *     key = a key
1228         *     value = an integer value
1229         *
1230         * Since: 2.26
1231         */
1232        public void setUint64(string groupName, string key, ulong value)
1233        {
1234                g_key_file_set_uint64(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), value);
1235        }
1236
1237        /**
1238         * Associates a new value with @key under @group_name.
1239         *
1240         * If @key cannot be found then it is created. If @group_name cannot
1241         * be found then it is created. To set an UTF-8 string which may contain
1242         * characters that need escaping (such as newlines or spaces), use
1243         * g_key_file_set_string().
1244         *
1245         * Params:
1246         *     groupName = a group name
1247         *     key = a key
1248         *     value = a string
1249         *
1250         * Since: 2.6
1251         */
1252        public void setValue(string groupName, string key, string value)
1253        {
1254                g_key_file_set_value(gKeyFile, Str.toStringz(groupName), Str.toStringz(key), Str.toStringz(value));
1255        }
1256
1257        /**
1258         * This function outputs @key_file as a string.
1259         *
1260         * Note that this function never reports an error,
1261         * so it is safe to pass %NULL as @error.
1262         *
1263         * Params:
1264         *     length = return location for the length of the
1265         *         returned string, or %NULL
1266         *
1267         * Returns: a newly allocated string holding
1268         *     the contents of the #GKeyFile
1269         *
1270         * Since: 2.6
1271         *
1272         * Throws: GException on failure.
1273         */
1274        public string toData(out size_t length)
1275        {
1276                GError* err = null;
1277               
1278                auto retStr = g_key_file_to_data(gKeyFile, &length, &err);
1279               
1280                if (err !is null)
1281                {
1282                        throw new GException( new ErrorG(err) );
1283                }
1284               
1285                scope(exit) Str.freeString(retStr);
1286                return Str.toString(retStr);
1287        }
1288
1289        /**
1290         * Decreases the reference count of @key_file by 1. If the reference count
1291         * reaches zero, frees the key file and all its allocated memory.
1292         *
1293         * Since: 2.32
1294         */
1295        public void unref()
1296        {
1297                g_key_file_unref(gKeyFile);
1298        }
1299
1300        /** */
1301        public static GQuark errorQuark()
1302        {
1303                return g_key_file_error_quark();
1304        }
1305}
Note: See TracBrowser for help on using the repository browser.