Commit 145cec3c authored by Alexander Larsson's avatar Alexander Larsson

Import GInitable, GSocket and dependencies from gnio

This adds:
GInitable - failable object constructor interface
GAsyncInitable - async failable object constructor interface
GSocket - Platform independent lowlevel berkely socket style object
GSocketControlMessage - For passing control messages over GSocket
GUnixFDMessage - unix fd passing socket control message

Some changes were done during the import from gnio to make things
work in glib. For instance, types were moved to other headers, header
file boiler plate were updated to glib style and gio.symbols stuff
was added.
parent 33c00e5c
......@@ -975,6 +975,14 @@ if $glib_failed ; then
AC_MSG_ERROR([Could not determine values for AF_INET* constants])
fi
glib_failed=false
GLIB_CHECK_VALUE(MSG_PEEK, $glib_inet_includes, glib_failed=true)
GLIB_CHECK_VALUE(MSG_OOB, $glib_inet_includes, glib_failed=true)
GLIB_CHECK_VALUE(MSG_DONTROUTE, $glib_inet_includes, glib_failed=true)
if $glib_failed ; then
AC_MSG_ERROR([Could not determine values for MSG_* constants])
fi
AC_CHECK_FUNCS(getprotobyname_r endservent)
AC_CHECK_HEADERS([netdb.h winsock2.h mswsock.h])
......@@ -3038,6 +3046,10 @@ typedef $g_pid_type GPid;
#define GLIB_SYSDEF_AF_INET $g_af_inet
#define GLIB_SYSDEF_AF_INET6 $g_af_inet6
#define GLIB_SYSDEF_MSG_OOB $g_msg_oob
#define GLIB_SYSDEF_MSG_PEEK $g_msg_peek
#define GLIB_SYSDEF_MSG_DONTROUTE $g_msg_dontroute
G_END_DECLS
#endif /* GLIBCONFIG_H */
......@@ -3328,6 +3340,10 @@ g_af_unix=$glib_cv_value_AF_UNIX
g_af_inet=$glib_cv_value_AF_INET
g_af_inet6=$glib_cv_value_AF_INET6
g_msg_peek=$glib_cv_value_MSG_PEEK
g_msg_oob=$glib_cv_value_MSG_OOB
g_msg_dontroute=$glib_cv_value_MSG_DONTROUTE
g_stack_grows=$glib_cv_stack_grows
g_have_eilseq=$have_eilseq
......
......@@ -130,6 +130,7 @@ appinfo_sources += gdesktopappinfo.c gdesktopappinfo.h
platform_libadd += libasyncns/libasyncns.la xdgmime/libxdgmime.la
platform_deps += libasyncns/libasyncns.la xdgmime/libxdgmime.la
unix_sources = \
gunixfdmessage.c \
gunixmount.c \
gunixmount.h \
gunixmounts.c \
......@@ -150,6 +151,7 @@ giounixincludedir=$(includedir)/gio-unix-2.0/gio
giounixinclude_HEADERS = \
gdesktopappinfo.h \
gunixmounts.h \
gunixfdmessage.h \
gunixinputstream.h \
gunixoutputstream.h \
gunixsocketaddress.h \
......@@ -176,6 +178,7 @@ libgio_2_0_la_SOURCES = \
gappinfo.c \
gasynchelper.c \
gasynchelper.h \
gasyncinitable.c \
gasyncresult.c \
gbufferedinputstream.c \
gbufferedoutputstream.c \
......@@ -207,6 +210,7 @@ libgio_2_0_la_SOURCES = \
gicon.c \
ginetaddress.c \
ginetsocketaddress.c \
ginitable.c \
ginputstream.c \
gioenums.h \
gioerror.c \
......@@ -230,6 +234,8 @@ libgio_2_0_la_SOURCES = \
gresolver.c \
gseekable.c \
gsimpleasyncresult.c \
gsocket.c \
gsocketcontrolmessage.c \
gsocketaddress.c \
gsocketaddressenumerator.c \
gsocketconnectable.c \
......@@ -299,6 +305,7 @@ libgio_2_0_la_DEPENDENCIES = $(gio_def) $(platform_deps)
gio_headers = \
gappinfo.h \
gasyncinitable.h \
gasyncresult.h \
gbufferedinputstream.h \
gbufferedoutputstream.h \
......@@ -325,6 +332,7 @@ gio_headers = \
ginetaddress.h \
ginetsocketaddress.h \
ginputstream.h \
ginitable.h \
gio.h \
giotypes.h \
gioenums.h \
......@@ -344,6 +352,8 @@ gio_headers = \
gresolver.h \
gseekable.h \
gsimpleasyncresult.h \
gsocket.h \
gsocketcontrolmessage.h \
gsocketaddress.h \
gsocketaddressenumerator.h \
gsocketconnectable.h \
......
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2009 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Author: Alexander Larsson <alexl@redhat.com>
*/
#include "config.h"
#include "gasyncinitable.h"
#include "gasyncresult.h"
#include "gsimpleasyncresult.h"
#include "glibintl.h"
#include "gioalias.h"
/**
* SECTION:gasyncinitable
* @short_description: Asynchronously failable object initialization interface
* @include: gio/gio.h
* @see_also: #GInitable
*
* 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
* or both.
*
* Users of objects implementing this are not intended to use
* the interface method directly, instead it will be used automatically
* in various ways. For C applications you generally just call
* g_async_initable_new() directly, or indirectly via a foo_thing_new_async() wrapper.
* This will call g_async_initable_init() under the cover, calling back with %NULL and
* a set %GError on failure.
**/
static void g_async_initable_base_init (gpointer g_iface);
static void g_async_initable_real_init_async (GAsyncInitable *initable,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
static gboolean g_async_initable_real_init_finish (GAsyncInitable *initable,
GAsyncResult *res,
GError **error);
GType
g_async_initable_get_type (void)
{
static volatile gsize g_define_type_id__volatile = 0;
if (g_once_init_enter (&g_define_type_id__volatile))
{
const GTypeInfo initable_info =
{
sizeof (GAsyncInitableIface), /* class_size */
g_async_initable_base_init, /* base_init */
NULL, /* base_finalize */
NULL,
NULL, /* class_finalize */
NULL, /* class_data */
0,
0, /* n_preallocs */
NULL
};
GType g_define_type_id =
g_type_register_static (G_TYPE_INTERFACE, I_("GAsyncInitable"),
&initable_info, 0);
g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_OBJECT);
g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
}
return g_define_type_id__volatile;
}
static void
g_async_initable_base_init (gpointer g_iface)
{
GAsyncInitableIface *iface = g_iface;
iface->init_async = g_async_initable_real_init_async;
iface->init_finish = g_async_initable_real_init_finish;
}
/**
* g_async_initable_init_async:
* @initable: a #GAsyncInitable.
* @io_priority: the <link linkend="io-priority">I/O priority</link>
* of the operation.
* @cancellable: optional #GCancellable object, %NULL to ignore.
* @callback: a #GAsyncReadyCallback to call when the request is satisfied
* @user_data: the data to pass to callback function
*
* Starts asynchronous initialization of the object implementing the interface.
* This must be done before any real use of the object after initial construction.
* If the object also implements #GInitable you can optionally call g_initable_init()
* instead.
*
* When the initialization is finished, @callback will be called. You can then call
* g_async_initable_init_finish() to get the result of the initialization.
*
* 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_NOT_SUPPORTED will be returned.
*
* 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
* 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
* pattern in the GObject constructor function.
*
* 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
* any interface methods.
*
* Since: 2.22
**/
void
g_async_initable_init_async (GAsyncInitable *initable,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GAsyncInitableIface *iface;
g_return_if_fail (G_IS_ASYNC_INITABLE (initable));
iface = G_ASYNC_INITABLE_GET_IFACE (initable);
return (* iface->init_async) (initable, io_priority, cancellable, callback, user_data);
}
/**
* g_async_initable_init_finish:
* @initable: a #GAsyncInitable.
* @res: a #GAsyncResult.
* @error: a #GError location to store the error occuring, or %NULL to
* ignore.
*
* Finishes asynchronous initialization and returns the result.
* See g_async_initable_init_async().
*
* Returns: %TRUE if successful. If an error
* has occurred, this function will return %FALSE and set @error
* appropriately if present.
*
* Since: 2.22
**/
gboolean
g_async_initable_init_finish (GAsyncInitable *initable,
GAsyncResult *res,
GError **error)
{
GAsyncInitableIface *iface;
g_return_val_if_fail (G_IS_ASYNC_INITABLE (initable), FALSE);
g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE);
if (G_IS_SIMPLE_ASYNC_RESULT (res))
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
if (g_simple_async_result_propagate_error (simple, error))
return FALSE;
}
iface = G_ASYNC_INITABLE_GET_IFACE (initable);
return (* iface->init_finish) (initable, res, error);
}
static void
async_init_thread (GSimpleAsyncResult *res,
GObject *object,
GCancellable *cancellable)
{
GError *error = NULL;
if (!g_initable_init (G_INITABLE (res), cancellable, &error))
{
g_simple_async_result_set_from_error (res, error);
g_error_free (error);
}
}
static void
g_async_initable_real_init_async (GAsyncInitable *initable,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *res;
g_return_if_fail (G_IS_INITABLE (initable));
res = g_simple_async_result_new (G_OBJECT (initable), callback, user_data,
g_async_initable_real_init_async);
g_simple_async_result_run_in_thread (res, async_init_thread,
io_priority, cancellable);
g_object_unref (res);
}
static gboolean
g_async_initable_real_init_finish (GAsyncInitable *initable,
GAsyncResult *res,
GError **error)
{
return TRUE; /* Errors handled by base impl */
}
/**
* g_async_initable_new_async:
* @object_type: a #GType supporting #GAsyncInitable.
* @io_priority: the <link linkend="io-priority">I/O priority</link>
* of the operation.
* @cancellable: optional #GCancellable object, %NULL to ignore.
* @callback: a #GAsyncReadyCallback to call when the initialization is finished
* @user_data: the data to pass to callback function
* @first_property_name: the name of the first property, followed by
* the value, and 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.
*
* 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.
*
* Since: 2.22
**/
void
g_async_initable_new_async (GType object_type,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data,
const gchar *first_property_name,
...)
{
va_list var_args;
va_start (var_args, first_property_name);
g_async_initable_new_valist_async (object_type,
first_property_name, var_args,
io_priority, cancellable,
callback, user_data);
va_end (var_args);
}
/**
* g_async_initable_newv_async:
* @object_type: a #GType supporting #GAsyncInitable.
* @n_parameters: the number of parameters in @parameters
* @parameters: the parameters to use to construct the object
* @io_priority: the <link linkend="io-priority">I/O priority</link>
* of the operation.
* @cancellable: optional #GCancellable object, %NULL to ignore.
* @callback: a #GAsyncReadyCallback to call when the initialization is finished
* @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.
*
* 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.
*
* Since: 2.22
**/
void
g_async_initable_newv_async (GType object_type,
guint n_parameters,
GParameter *parameters,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GObject *obj;
g_return_if_fail (G_TYPE_IS_ASYNC_INITABLE (object_type));
obj = g_object_newv (object_type, n_parameters, parameters);
g_async_initable_init_async (G_ASYNC_INITABLE (obj),
io_priority, cancellable,
callback, user_data);
}
/**
* g_async_initable_new_async:
* @object_type: a #GType supporting #GAsyncInitable.
* @first_property_name: the name of the first property, followed by
* the value, and other property value pairs, and ended by %NULL.
* @var_args: The var args list generated from @first_property_name.
* @io_priority: the <link linkend="io-priority">I/O priority</link>
* of the operation.
* @cancellable: optional #GCancellable object, %NULL to ignore.
* @callback: a #GAsyncReadyCallback to call when the initialization is finished
* @user_data: the data to pass to callback function
*
* Helper function for constructing #GAsyncInitiable object. This is
* similar to g_object_new_valist() but also initializes the object asyncronously.
*
* 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.
*
* Since: 2.22
**/
void
g_async_initable_new_valist_async (GType object_type,
const gchar *first_property_name,
va_list var_args,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GObject *obj;
g_return_if_fail (G_TYPE_IS_ASYNC_INITABLE (object_type));
obj = g_object_new_valist (object_type,
first_property_name,
var_args);
g_async_initable_init_async (G_ASYNC_INITABLE (obj),
io_priority, cancellable,
callback, user_data);
g_object_unref (obj); /* Passed ownership to async call */
}
/**
* g_async_initable_new_finish:
* @initable: the #GAsyncInitable from the callback
* @res: the #GAsyncResult.from the callback
* @error: a #GError location to store the error occuring, or %NULL to
* ignore.
*
* Finishes the async construction for the various g_async_initable_new calls,
* returning the created object or %NULL on error.
*
* Returns: a newly created #GObject, or %NULL on error. Free with g_object_unref().
*
* Since: 2.22
**/
GObject *
g_async_initable_new_finish (GAsyncInitable *initable,
GAsyncResult *res,
GError **error)
{
if (g_async_initable_init_finish (initable, res, error))
return g_object_ref (initable);
else
return NULL;
}
#define __G_ASYNC_INITABLE_C__
#include "gioaliasdef.c"
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2009 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Author: Alexander Larsson <alexl@redhat.com>
*/
#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
#error "Only <gio/gio.h> can be included directly."
#endif
#ifndef __G_ASYNC_INITABLE_H__
#define __G_ASYNC_INITABLE_H__
#include <gio/giotypes.h>
#include <gio/ginitable.h>
G_BEGIN_DECLS
#define G_TYPE_ASYNC_INITABLE (g_async_initable_get_type ())
#define G_ASYNC_INITABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_ASYNC_INITABLE, GAsyncInitable))
#define G_IS_ASYNC_INITABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_ASYNC_INITABLE))
#define G_ASYNC_INITABLE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_TYPE_ASYNC_INITABLE, GAsyncInitableIface))
#define G_TYPE_IS_ASYNC_INITABLE(type) (g_type_is_a ((type), G_TYPE_ASYNC_INITABLE))
/**
* GAsyncInitable:
*
* Interface for asynchronously initializable objects.
*
* Since: 2.22
**/
typedef struct _GAsyncInitableIface GAsyncInitableIface;
/**
* GAsyncInitableIface:
* @g_iface: The parent interface.
* @init_async: Starts initialization of the object.
* @init_finish: Finishes initialization of the object.
*
* Provides an interface for asynchronous initializing object such that
* initialization may fail.
*
* Since: 2.22
**/
struct _GAsyncInitableIface
{
GTypeInterface g_iface;
/* Virtual Table */
void (* init_async) (GAsyncInitable *initable,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean (* init_finish) (GAsyncInitable *initable,
GAsyncResult *res,
GError **error);
};
GType g_async_initable_get_type (void) G_GNUC_CONST;
void g_async_initable_init_async (GAsyncInitable *initable,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean g_async_initable_init_finish (GAsyncInitable *initable,
GAsyncResult *res,
GError **error);
void g_async_initable_new_async (GType object_type,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data,
const gchar *first_property_name,
...);
void g_async_initable_newv_async (GType object_type,
guint n_parameters,
GParameter *parameters,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
void g_async_initable_new_valist_async (GType object_type,
const gchar *first_property_name,
va_list var_args,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
GObject *g_async_initable_new_finish (GAsyncInitable *initable,
GAsyncResult *res,
GError **error);
G_END_DECLS
#endif /* __G_ASYNC_INITABLE_H__ */
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2009 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Author: Alexander Larsson <alexl@redhat.com>
*/
#include "config.h"
#include "ginitable.h"
#include "glibintl.h"
#include "gioalias.h"
/**
* SECTION:ginitable
* @short_description: Failable object initialization interface
* @include: gio/gio.h
* @see_also: #GAsyncInitable
*
* #GInitable is implemented by objects that can fail during
* initialization. If an object implements this interface the
* g_initable_init() function must be called as the first thing
* after construction. If g_initable_init() is not called, or if
* it returns an error, all further operations on the object
* should fail, generally with a %G_IO_ERROR_NOT_INITIALIZED error.
*
* Users of objects implementing this are not intended to use
* the interface method directly, instead it will be used automatically
* in various ways. For C applications you generally just call
* g_initable_new() directly, or indirectly via a foo_thing_new() wrapper.
* This will call g_initable_init() under the cover, returning %NULL and
* setting a %GError on failure.
*
* For bindings in languages where the native constructor supports
* exceptions the binding could check for objects implemention %GInitable
* during normal construction and automatically initialize them, throwing
* an exception on failure.
**/
GType
g_initable_get_type (void)
{
static volatile gsize g_define_type_id__volatile = 0;
if (g_once_init_enter (&g_define_type_id__volatile))
{
const GTypeInfo initable_info =
{
sizeof (GInitableIface), /* class_size */
NULL, /* base_init */
NULL, /* base_finalize */
NULL,
NULL, /* class_finalize */
NULL, /* class_data */
0,
0, /* n_preallocs */
NULL
};
GType g_define_type_id =
g_type_register_static (G_TYPE_INTERFACE, I_("GInitable"),
&initable_info, 0);
g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_OBJECT);
g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
}
return g_define_type_id__volatile;
}
/**
* g_initable_init:
* @initable: a #GInitable.
* @cancellable: optional #GCancellable object, %NULL to ignore.
* @error: a #GError location to store the error occuring, or %NULL to
* ignore.
*
* Initializes the object implementing the interface. This must be
* done before any real use of the object after initial construction.
*
* 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_NOT_SUPPORTED will be returned.
*
* 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
* 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
* pattern in the GObject constructor function.
*
* Returns: %TRUE if successful. If an error
* has occurred, this function will return %FALSE and set @error
* appropriately if present.
*
* Since: 2.22
**/
gboolean
g_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
GInitableIface *iface;
g_return_val_if_fail (G_IS_INITABLE (initable), FALSE);
iface = G_INITABLE_GET_IFACE (initable);
return (* iface->init) (initable, cancellable, error);
}
/**
* g_initable_new:
* @object_type: a #GType supporting #GInitable.
* @cancellable: optional #GCancellable object, %NULL to ignore.
* @error: a #GError location to store the error occuring, or %NULL to
* ignore.
* @first_property_name: the name of the first property, followed by
* the value, and other property value pairs, and ended by %NULL.
*
* Helper function for constructing #GInitiable object. This is
* similar to g_object_new() but also initializes the object
* and returns %NULL, setting an error on failure.
*
* Return value: a newly allocated #GObject, or %NULL on error
*
* Since: 2.22
**/
gpointer
g_initable_new (GType object_type,
GCancellable *cancellable,
GError **error,
const gchar *first_property_name,
...)
{
GObject *object;
va_list var_args;
va_start (var_args, first_property_name);
object = g_initable_new_valist (object_type,
first_property_name, var_args,
cancellable, error);
va_end (var_args);