1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright © 2011 Red Hat, Inc
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
20 * Authors: Alexander Larsson <alexl@redhat.com>
27 #include "gresource.h"
28 #include <gvdb/gvdb-reader.h>
30 #include <gio/gmemoryinputstream.h>
31 #include <gio/gzlibdecompressor.h>
32 #include <gio/gconverterinputstream.h>
41 static void register_lazy_static_resources (void);
43 G_DEFINE_BOXED_TYPE (GResource
, g_resource
, g_resource_ref
, g_resource_unref
)
47 * @short_description: Resource framework
50 * Applications and libraries often contain binary or textual data that is really part of the
51 * application, rather than user data. For instance #GtkBuilder .ui files, splashscreen images,
52 * GMenu markup xml, CSS files, icons, etc. These are often shipped as files in <filename>$datadir/appname</filename>, or
53 * manually included as literal strings in the code.
55 * The #GResource API and the <link linkend="glib-compile-resources">glib-compile-resources</link> program
56 * provide a convenient and efficient alternative to this which has some nice properties. You
57 * maintain the files as normal files, so its easy to edit them, but during the build the files
58 * are combined into a binary bundle that is linked into the executable. This means that loading
59 * the resource files are efficient (as they are already in memory, shared with other instances) and
60 * simple (no need to check for things like I/O errors or locate the files in the filesystem). It
61 * also makes it easier to create relocatable applications.
63 * Resource files can also be marked as compressed. Such files will be included in the resource bundle
64 * in a compressed form, but will be automatically uncompressed when the resource is used. This
65 * is very useful e.g. for larger text files that are parsed once (or rarely) and then thrown away.
67 * Resource files can also be marked to be preprocessed, by setting the value of the
68 * <literal>preprocess</literal> attribute to a comma-separated list of preprocessing options.
69 * The only options currently supported are:
71 * <literal>xml-stripblanks</literal> which will use <command>xmllint</command> to strip
72 * ignorable whitespace from the xml file. For this to work, the <envar>XMLLINT</envar>
73 * environment variable must be set to the full path to the xmllint executable, or xmllint
74 * must be in the PATH; otherwise the preprocessing step is skipped.
76 * <literal>to-pixdata</literal> which will use <command>gdk-pixbuf-pixdata</command> to convert
77 * images to the GdkPixdata format, which allows you to create pixbufs directly using the data inside
78 * the resource file, rather than an (uncompressed) copy if it. For this, the gdk-pixbuf-pixdata
79 * program must be in the PATH, or the <envar>GDK_PIXBUF_PIXDATA</envar> environment variable must be
80 * set to the full path to the gdk-pixbuf-pixdata executable; otherwise the resource compiler will
83 * Resource bundles are created by the <link linkend="glib-compile-resources">glib-compile-resources</link> program
84 * which takes an xml file that describes the bundle, and a set of files that the xml references. These
85 * are combined into a binary resource bundle.
87 * <example id="resource-example"><title>Example resource description</title>
88 * <programlisting><![CDATA[
89 * <?xml version="1.0" encoding="UTF-8"?>
91 * <gresource prefix="/org/gtk/Example">
92 * <file>data/splashscreen.png</file>
93 * <file compressed="true">dialog.ui</file>
94 * <file preprocess="xml-stripblanks">menumarkup.xml</file>
97 * ]]></programlisting></example>
99 * This will create a resource bundle with the following files:
100 * <programlisting><![CDATA[
101 * /org/gtk/Example/data/splashscreen.png
102 * /org/gtk/Example/dialog.ui
103 * /org/gtk/Example/menumarkup.xml
104 * ]]></programlisting>
106 * Note that all resources in the process share the same namespace, so use java-style
107 * path prefixes (like in the above example) to avoid conflicts.
109 * You can then use <link linkend="glib-compile-resources">glib-compile-resources</link> to compile the xml to a
110 * binary bundle that you can load with g_resource_load(). However, its more common to use the --generate-source and
111 * --generate-header arguments to create a source file and header to link directly into your application.
113 * Once a #GResource has been created and registered all the data in it can be accessed globally in the process by
114 * using API calls like g_resources_open_stream() to stream the data or g_resources_lookup_data() to get a direct pointer
115 * to the data. You can also use uris like "resource:///org/gtk/Example/data/splashscreen.png" with #GFile to access
118 * There are two forms of the generated source, the default version uses the compiler support for constructor
119 * and destructor functions (where available) to automatically create and register the #GResource on startup
120 * or library load time. If you pass --manual-register two functions to register/unregister the resource is instead
121 * created. This requires an explicit initialization call in your application/library, but it works on all platforms,
122 * even on the minor ones where this is not available. (Constructor support is available for at least Win32, MacOS and Linux.)
124 * Note that resource data can point directly into the data segment of e.g. a library, so if you are unloading libraries
125 * during runtime you need to be very careful with keeping around pointers to data from a resource, as this goes away
126 * when the library is unloaded. However, in practice this is not generally a problem, since most resource accesses
127 * is for your own resources, and resource data is often used once, during parsing, and then released.
133 * g_resource_error_quark:
135 * Gets the #GResource Error Quark.
137 * Return value: a #GQuark
141 G_DEFINE_QUARK (g
-resource
-error
-quark
, g_resource_error
)
145 * @resource: A #GResource
147 * Atomically increments the reference count of @array by one. This
148 * function is MT-safe and may be called from any thread.
150 * Returns: The passed in #GResource
155 g_resource_ref (GResource
*resource
)
157 g_atomic_int_inc (&resource
->ref_count
);
163 * @resource: A #GResource
165 * Atomically decrements the reference count of @resource by one. If the
166 * reference count drops to 0, all memory allocated by the array is
167 * released. This function is MT-safe and may be called from any
173 g_resource_unref (GResource
*resource
)
175 if (g_atomic_int_dec_and_test (&resource
->ref_count
))
177 gvdb_table_unref (resource
->table
);
183 * g_resource_new_from_table:
184 * @table: (transfer full): a GvdbTable
186 * Returns: (transfer full): a new #GResource for @table
189 g_resource_new_from_table (GvdbTable
*table
)
193 resource
= g_new (GResource
, 1);
194 resource
->ref_count
= 1;
195 resource
->table
= table
;
201 * g_resource_new_from_data:
203 * @error: return location for a #GError, or %NULL
205 * Creates a GResource from a reference to the binary resource bundle.
206 * This will keep a reference to @data while the resource lives, so
207 * the data should not be modified or freed.
209 * If you want to use this resource in the global resource namespace you need
210 * to register it with g_resources_register().
212 * Return value: (transfer full): a new #GResource, or %NULL on error
217 g_resource_new_from_data (GBytes
*data
,
222 table
= gvdb_table_new_from_data (g_bytes_get_data (data
, NULL
),
223 g_bytes_get_size (data
),
226 (GvdbRefFunc
)g_bytes_ref
,
227 (GDestroyNotify
)g_bytes_unref
,
233 return g_resource_new_from_table (table
);
238 * @filename: (type filename): the path of a filename to load, in the GLib filename encoding
239 * @error: return location for a #GError, or %NULL
241 * Loads a binary resource bundle and creates a #GResource representation of it, allowing
242 * you to query it for data.
244 * If you want to use this resource in the global resource namespace you need
245 * to register it with g_resources_register().
247 * Return value: (transfer full): a new #GResource, or %NULL on error
252 g_resource_load (const gchar
*filename
,
257 table
= gvdb_table_new (filename
, FALSE
, error
);
261 return g_resource_new_from_table (table
);
265 gboolean
do_lookup (GResource
*resource
,
267 GResourceLookupFlags lookup_flags
,
274 char *free_path
= NULL
;
276 gboolean res
= FALSE
;
279 path_len
= strlen (path
);
280 if (path
[path_len
-1] == '/')
282 path
= free_path
= g_strdup (path
);
283 free_path
[path_len
-1] = 0;
286 value
= gvdb_table_get_raw_value (resource
->table
, path
);
290 g_set_error (error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
,
291 _("The resource at '%s' does not exist"),
296 guint32 _size
, _flags
;
299 g_variant_get (value
, "(uu@ay)",
304 _size
= GUINT32_FROM_LE (_size
);
305 _flags
= GUINT32_FROM_LE (_flags
);
312 *data
= g_variant_get_data (array
);
315 /* Don't report trailing newline that non-compressed files has */
316 if (_flags
& G_RESOURCE_FLAGS_COMPRESSED
)
317 *data_size
= g_variant_get_size (array
);
319 *data_size
= g_variant_get_size (array
) - 1;
321 g_variant_unref (array
);
322 g_variant_unref (value
);
332 * g_resource_open_stream:
333 * @resource: A #GResource
334 * @path: A pathname inside the resource
335 * @lookup_flags: A #GResourceLookupFlags
336 * @error: return location for a #GError, or %NULL
338 * Looks for a file at the specified @path in the resource and
339 * returns a #GInputStream that lets you read the data.
341 * @lookup_flags controls the behaviour of the lookup.
343 * Returns: (transfer full): #GInputStream or %NULL on error.
344 * Free the returned object with g_object_unref()
349 g_resource_open_stream (GResource
*resource
,
351 GResourceLookupFlags lookup_flags
,
357 GInputStream
*stream
, *stream2
;
359 if (!do_lookup (resource
, path
, lookup_flags
, NULL
, &flags
, &data
, &data_size
, error
))
362 stream
= g_memory_input_stream_new_from_data (data
, data_size
, NULL
);
363 g_object_set_data_full (G_OBJECT (stream
), "g-resource",
364 g_resource_ref (resource
),
365 (GDestroyNotify
)g_resource_unref
);
367 if (flags
& G_RESOURCE_FLAGS_COMPRESSED
)
369 GZlibDecompressor
*decompressor
=
370 g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB
);
372 stream2
= g_converter_input_stream_new (stream
, G_CONVERTER (decompressor
));
373 g_object_unref (decompressor
);
374 g_object_unref (stream
);
382 * g_resource_lookup_data:
383 * @resource: A #GResource
384 * @path: A pathname inside the resource
385 * @lookup_flags: A #GResourceLookupFlags
386 * @error: return location for a #GError, or %NULL
388 * Looks for a file at the specified @path in the resource and
389 * returns a #GBytes that lets you directly access the data in
392 * The data is always followed by a zero byte, so you
393 * can safely use the data as a C string. However, that byte
394 * is not included in the size of the GBytes.
396 * For uncompressed resource files this is a pointer directly into
397 * the resource bundle, which is typically in some readonly data section
398 * in the program binary. For compressed files we allocate memory on
399 * the heap and automatically uncompress the data.
401 * @lookup_flags controls the behaviour of the lookup.
403 * Returns: (transfer full): #GBytes or %NULL on error.
404 * Free the returned object with g_bytes_unref()
409 g_resource_lookup_data (GResource
*resource
,
411 GResourceLookupFlags lookup_flags
,
419 if (!do_lookup (resource
, path
, lookup_flags
, &size
, &flags
, &data
, &data_size
, error
))
422 if (flags
& G_RESOURCE_FLAGS_COMPRESSED
)
424 char *uncompressed
, *d
;
426 GConverterResult res
;
427 gsize d_size
, s_size
;
428 gsize bytes_read
, bytes_written
;
431 GZlibDecompressor
*decompressor
=
432 g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB
);
434 uncompressed
= g_malloc (size
+ 1);
443 res
= g_converter_convert (G_CONVERTER (decompressor
),
446 G_CONVERTER_INPUT_AT_END
,
450 if (res
== G_CONVERTER_ERROR
)
452 g_free (uncompressed
);
453 g_object_unref (decompressor
);
455 g_set_error (error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_INTERNAL
,
456 _("The resource at '%s' failed to decompress"),
462 s_size
-= bytes_read
;
464 d_size
-= bytes_written
;
466 while (res
!= G_CONVERTER_FINISHED
);
468 uncompressed
[size
] = 0; /* Zero terminate */
470 g_object_unref (decompressor
);
472 return g_bytes_new_take (uncompressed
, size
);
475 return g_bytes_new_with_free_func (data
, data_size
, (GDestroyNotify
)g_resource_unref
, g_resource_ref (resource
));
479 * g_resource_get_info:
480 * @resource: A #GResource
481 * @path: A pathname inside the resource
482 * @lookup_flags: A #GResourceLookupFlags
483 * @size: (out) (allow-none): a location to place the length of the contents of the file,
484 * or %NULL if the length is not needed
485 * @flags: (out) (allow-none): a location to place the flags about the file,
486 * or %NULL if the length is not needed
487 * @error: return location for a #GError, or %NULL
489 * Looks for a file at the specified @path in the resource and
490 * if found returns information about it.
492 * @lookup_flags controls the behaviour of the lookup.
494 * Returns: %TRUE if the file was found. %FALSE if there were errors
499 g_resource_get_info (GResource
*resource
,
501 GResourceLookupFlags lookup_flags
,
506 return do_lookup (resource
, path
, lookup_flags
, size
, flags
, NULL
, NULL
, error
);
510 * g_resource_enumerate_children:
511 * @resource: A #GResource
512 * @path: A pathname inside the resource
513 * @lookup_flags: A #GResourceLookupFlags
514 * @error: return location for a #GError, or %NULL
516 * Returns all the names of children at the specified @path in the resource.
517 * The return result is a %NULL terminated list of strings which should
518 * be released with g_strfreev().
520 * @lookup_flags controls the behaviour of the lookup.
522 * Returns: (array zero-terminated=1) (transfer full): an array of constant strings
527 g_resource_enumerate_children (GResource
*resource
,
529 GResourceLookupFlags lookup_flags
,
534 char *path_with_slash
;
538 g_set_error (error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
,
539 _("The resource at '%s' does not exist"),
544 path_len
= strlen (path
);
545 if (path
[path_len
-1] != '/')
546 path_with_slash
= g_strconcat (path
, "/", NULL
);
548 path_with_slash
= g_strdup (path
);
550 children
= gvdb_table_list (resource
->table
, path_with_slash
);
551 g_free (path_with_slash
);
553 if (children
== NULL
)
555 g_set_error (error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
,
556 _("The resource at '%s' does not exist"),
564 static GRWLock resources_lock
;
565 static GList
*registered_resources
;
567 /* This is updated atomically, so we can append to it and check for NULL outside the
568 lock, but all other accesses are done under the write lock */
569 static GStaticResource
*lazy_register_resources
;
572 g_resources_register_unlocked (GResource
*resource
)
574 registered_resources
= g_list_prepend (registered_resources
, g_resource_ref (resource
));
578 g_resources_unregister_unlocked (GResource
*resource
)
580 if (g_list_find (registered_resources
, resource
) == NULL
)
582 g_warning ("Tried to remove not registered resource");
586 registered_resources
= g_list_remove (registered_resources
, resource
);
587 g_resource_unref (resource
);
592 * g_resources_register:
593 * @resource: A #GResource
595 * Registers the resource with the process-global set of resources.
596 * Once a resource is registered the files in it can be accessed
597 * with the global resource lookup functions like g_resources_lookup_data().
602 g_resources_register (GResource
*resource
)
604 g_rw_lock_writer_lock (&resources_lock
);
605 g_resources_register_unlocked (resource
);
606 g_rw_lock_writer_unlock (&resources_lock
);
610 * g_resources_unregister:
611 * @resource: A #GResource
613 * Unregisters the resource from the process-global set of resources.
618 g_resources_unregister (GResource
*resource
)
620 g_rw_lock_writer_lock (&resources_lock
);
621 g_resources_unregister_unlocked (resource
);
622 g_rw_lock_writer_unlock (&resources_lock
);
626 * g_resources_open_stream:
627 * @path: A pathname inside the resource
628 * @lookup_flags: A #GResourceLookupFlags
629 * @error: return location for a #GError, or %NULL
631 * Looks for a file at the specified @path in the set of
632 * globally registered resources and returns a #GInputStream
633 * that lets you read the data.
635 * @lookup_flags controls the behaviour of the lookup.
637 * Returns: (transfer full): #GInputStream or %NULL on error.
638 * Free the returned object with g_object_unref()
643 g_resources_open_stream (const gchar
*path
,
644 GResourceLookupFlags lookup_flags
,
647 GInputStream
*res
= NULL
;
649 GInputStream
*stream
;
651 register_lazy_static_resources ();
653 g_rw_lock_reader_lock (&resources_lock
);
655 for (l
= registered_resources
; l
!= NULL
; l
= l
->next
)
657 GResource
*r
= l
->data
;
658 GError
*my_error
= NULL
;
660 stream
= g_resource_open_stream (r
, path
, lookup_flags
, &my_error
);
661 if (stream
== NULL
&&
662 g_error_matches (my_error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
))
664 g_clear_error (&my_error
);
669 g_propagate_error (error
, my_error
);
676 g_set_error (error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
,
677 _("The resource at '%s' does not exist"),
680 g_rw_lock_reader_unlock (&resources_lock
);
686 * g_resources_lookup_data:
687 * @path: A pathname inside the resource
688 * @lookup_flags: A #GResourceLookupFlags
689 * @error: return location for a #GError, or %NULL
691 * Looks for a file at the specified @path in the set of
692 * globally registered resources and returns a #GBytes that
693 * lets you directly access the data in memory.
695 * The data is always followed by a zero byte, so you
696 * can safely use the data as a C string. However, that byte
697 * is not included in the size of the GBytes.
699 * For uncompressed resource files this is a pointer directly into
700 * the resource bundle, which is typically in some readonly data section
701 * in the program binary. For compressed files we allocate memory on
702 * the heap and automatically uncompress the data.
704 * @lookup_flags controls the behaviour of the lookup.
706 * Returns: (transfer full): #GBytes or %NULL on error.
707 * Free the returned object with g_bytes_unref()
712 g_resources_lookup_data (const gchar
*path
,
713 GResourceLookupFlags lookup_flags
,
720 register_lazy_static_resources ();
722 g_rw_lock_reader_lock (&resources_lock
);
724 for (l
= registered_resources
; l
!= NULL
; l
= l
->next
)
726 GResource
*r
= l
->data
;
727 GError
*my_error
= NULL
;
729 data
= g_resource_lookup_data (r
, path
, lookup_flags
, &my_error
);
731 g_error_matches (my_error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
))
733 g_clear_error (&my_error
);
738 g_propagate_error (error
, my_error
);
745 g_set_error (error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
,
746 _("The resource at '%s' does not exist"),
749 g_rw_lock_reader_unlock (&resources_lock
);
755 * g_resources_enumerate_children:
756 * @path: A pathname inside the resource
757 * @lookup_flags: A #GResourceLookupFlags
758 * @error: return location for a #GError, or %NULL
760 * Returns all the names of children at the specified @path in the set of
761 * globally registered resources.
762 * The return result is a %NULL terminated list of strings which should
763 * be released with g_strfreev().
765 * @lookup_flags controls the behaviour of the lookup.
767 * Returns: (array zero-terminated=1) (transfer full): an array of constant strings
772 g_resources_enumerate_children (const gchar
*path
,
773 GResourceLookupFlags lookup_flags
,
776 GHashTable
*hash
= NULL
;
781 register_lazy_static_resources ();
783 g_rw_lock_reader_lock (&resources_lock
);
785 for (l
= registered_resources
; l
!= NULL
; l
= l
->next
)
787 GResource
*r
= l
->data
;
789 children
= g_resource_enumerate_children (r
, path
, 0, NULL
);
791 if (children
!= NULL
)
794 hash
= g_hash_table_new_full (g_str_hash
, g_str_equal
, g_free
, NULL
);
796 for (i
= 0; children
[i
] != NULL
; i
++)
797 g_hash_table_insert (hash
, children
[i
], children
[i
]);
802 g_rw_lock_reader_unlock (&resources_lock
);
806 g_set_error (error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
,
807 _("The resource at '%s' does not exist"),
816 n_children
= g_hash_table_size (hash
);
817 children
= g_new (char *, n_children
+ 1);
820 g_hash_table_iter_init (&iter
, hash
);
821 while (g_hash_table_iter_next (&iter
, (gpointer
*)&key
, NULL
))
822 children
[i
++] = g_strdup (key
);
823 children
[i
++] = NULL
;
825 g_hash_table_destroy (hash
);
832 * g_resources_get_info:
833 * @path: A pathname inside the resource
834 * @lookup_flags: A #GResourceLookupFlags
835 * @size: (out) (allow-none): a location to place the length of the contents of the file,
836 * or %NULL if the length is not needed
837 * @flags: (out) (allow-none): a location to place the flags about the file,
838 * or %NULL if the length is not needed
839 * @error: return location for a #GError, or %NULL
841 * Looks for a file at the specified @path in the set of
842 * globally registered resources and if found returns information about it.
844 * @lookup_flags controls the behaviour of the lookup.
846 * Returns: %TRUE if the file was found. %FALSE if there were errors
851 g_resources_get_info (const gchar
*path
,
852 GResourceLookupFlags lookup_flags
,
857 gboolean res
= FALSE
;
861 register_lazy_static_resources ();
863 g_rw_lock_reader_lock (&resources_lock
);
865 for (l
= registered_resources
; l
!= NULL
; l
= l
->next
)
867 GResource
*r
= l
->data
;
868 GError
*my_error
= NULL
;
870 r_res
= g_resource_get_info (r
, path
, lookup_flags
, size
, flags
, &my_error
);
872 g_error_matches (my_error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
))
874 g_clear_error (&my_error
);
879 g_propagate_error (error
, my_error
);
886 g_set_error (error
, G_RESOURCE_ERROR
, G_RESOURCE_ERROR_NOT_FOUND
,
887 _("The resource at '%s' does not exist"),
890 g_rw_lock_reader_unlock (&resources_lock
);
895 /* This code is to handle registration of resources very early, from a constructor.
896 * At that point we'd like to do minimal work, to avoid ordering issues. For instance,
897 * we're not allowed to use g_malloc, as the user need to be able to call g_mem_set_vtable
898 * before the first call to g_malloc.
900 * So, what we do at construction time is that we just register a static structure on
901 * a list of resources that need to be initialized, and then later, when doing any lookups
902 * in the global list of registered resources, or when getting a reference to the
903 * lazily initialized resource we lazily create and register all the GResources on
906 * To avoid having to use locks in the constructor, and having to grab the writer lock
907 * when checking the lazy registering list we update lazy_register_resources in
908 * a lock-less fashion (atomic prepend-only, atomic replace with NULL). However, all
910 * * check if there are any resources to lazily initialize
911 * * Add a static resource to the lazy init list
912 * Do use the full writer lock for protection.
916 register_lazy_static_resources_unlocked (void)
918 GStaticResource
*list
;
921 list
= lazy_register_resources
;
922 while (!g_atomic_pointer_compare_and_exchange (&lazy_register_resources
, list
, NULL
));
926 GBytes
*bytes
= g_bytes_new_static (list
->data
, list
->data_len
);
927 GResource
*resource
= g_resource_new_from_data (bytes
, NULL
);
930 g_resources_register_unlocked (resource
);
931 g_atomic_pointer_set (&list
->resource
, resource
);
933 g_bytes_unref (bytes
);
940 register_lazy_static_resources (void)
942 if (g_atomic_pointer_get (&lazy_register_resources
) == NULL
)
945 g_rw_lock_writer_lock (&resources_lock
);
946 register_lazy_static_resources_unlocked ();
947 g_rw_lock_writer_unlock (&resources_lock
);
951 * g_static_resource_init:
952 * @static_resource: pointer to a static #GStaticResource
954 * Initializes a GResource from static data using a
957 * This is normally used by code generated by
958 * <link linkend="glib-compile-resources">glib-compile-resources</link>
959 * and is not typically used by other code.
964 g_static_resource_init (GStaticResource
*static_resource
)
970 next
= lazy_register_resources
;
971 static_resource
->next
= next
;
973 while (!g_atomic_pointer_compare_and_exchange (&lazy_register_resources
, next
, static_resource
));
977 * g_static_resource_fini:
978 * @static_resource: pointer to a static #GStaticResource
980 * Finalized a GResource initialized by g_static_resource_init().
982 * This is normally used by code generated by
983 * <link linkend="glib-compile-resources">glib-compile-resources</link>
984 * and is not typically used by other code.
989 g_static_resource_fini (GStaticResource
*static_resource
)
993 g_rw_lock_writer_lock (&resources_lock
);
995 register_lazy_static_resources_unlocked ();
997 resource
= g_atomic_pointer_get (&static_resource
->resource
);
1000 g_atomic_pointer_set (&static_resource
->resource
, NULL
);
1001 g_resources_unregister_unlocked (resource
);
1002 g_resource_unref (resource
);
1005 g_rw_lock_writer_unlock (&resources_lock
);
1009 * g_static_resource_get_resource:
1010 * @static_resource: pointer to a static #GStaticResource
1012 * Gets the GResource that was registered by a call to g_static_resource_init().
1014 * This is normally used by code generated by
1015 * <link linkend="glib-compile-resources">glib-compile-resources</link>
1016 * and is not typically used by other code.
1018 * Return value: (transfer none): a #GResource
1023 g_static_resource_get_resource (GStaticResource
*static_resource
)
1025 register_lazy_static_resources ();
1027 return g_atomic_pointer_get (&static_resource
->resource
);