* @include: gio/gio.h
* @see_also: #GInitable
*
- * This is the asynchronous version of #GInitable, it behaves the same
+ * This is the asynchronous version of #GInitable; it behaves the same
* in all ways except that initialization is asynchronous. For more details
* see the descriptions on #GInitable.
*
* A class may implement both the #GInitable and #GAsyncInitable interfaces.
*
* Users of objects implementing this are not intended to use the interface
- * method directly, instead it will be used automatically in various ways.
+ * method directly; instead it will be used automatically in various ways.
* For C applications you generally just call g_async_initable_new_async()
* directly, or indirectly via a foo_thing_new_async() wrapper. This will call
* g_async_initable_init_async() under the cover, calling back with %NULL and
* Implementations may also support cancellation. If @cancellable is not
* %NULL, then initialization can be cancelled by triggering the cancellable
* object from another thread. If the operation was cancelled, the error
- * %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL and
- * the object doesn't support cancellable initialization the error
+ * %G_IO_ERROR_CANCELLED will be returned. If @cancellable is not %NULL, and
+ * the object doesn't support cancellable initialization, the error
* %G_IO_ERROR_NOT_SUPPORTED will be returned.
*
- * If this function is not called, or returns with an error then all
+ * If this function is not called, or returns with an error, then all
* operations on the object should fail, generally returning the
* error %G_IO_ERROR_NOT_INITIALIZED.
*
- * Implementations of this method must be idempotent, i.e. multiple calls
+ * Implementations of this method must be idempotent: i.e. multiple calls
* to this function with the same argument should return the same results.
- * Only the first call initializes the object, further calls return the result
- * of the first call. This is so that its safe to implement the singleton
+ * Only the first call initializes the object; further calls return the result
+ * of the first call. This is so that it's safe to implement the singleton
* pattern in the GObject constructor function.
*
- * For classes that also support the #GInitable interface the default
+ * For classes that also support the #GInitable interface, the default
* implementation of this method will run the g_initable_init() function
* in a thread, so if you want to support asynchronous initialization via
* threads, just implement the #GAsyncInitable interface without overriding
* @user_data: the data to pass to callback function
* @first_property_name: the name of the first property, or %NULL if no
* properties
- * @...: the value if the first property, followed by and other property
+ * @...: the value of the first property, followed by other property
* value pairs, and ended by %NULL.
*
* Helper function for constructing #GAsyncInitiable object. This is
- * similar to g_object_new() but also initializes the object asyncronously.
+ * similar to g_object_new() but also initializes the object asynchronously.
*
* When the initialization is finished, @callback will be called. You can
- * then call g_async_initable_new_finish() to get new object and check for
- * any errors.
+ * then call g_async_initable_new_finish() to get the new object and check
+ * for any errors.
*
* Since: 2.22
*/
* @user_data: the data to pass to callback function
*
* Helper function for constructing #GAsyncInitiable object. This is
- * similar to g_object_newv() but also initializes the object asyncronously.
+ * similar to g_object_newv() but also initializes the object asynchronously.
*
* When the initialization is finished, @callback will be called. You can
- * then call g_async_initable_new_finish() to get new object and check for
- * any errors.
+ * then call g_async_initable_new_finish() to get the new object and check
+ * for any errors.
*
* Since: 2.22
*/
*
* Helper function for constructing #GAsyncInitiable object. This is
* similar to g_object_new_valist() but also initializes the object
- * asyncronously.
+ * asynchronously.
*
* When the initialization is finished, @callback will be called. You can
- * then call g_async_initable_new_finish() to get new object and check for
- * any errors.
+ * then call g_async_initable_new_finish() to get the new object and check
+ * for any errors.
*
* Since: 2.22
*/