Logo Search packages:      
Sourcecode: udisks version File versions  Download package

udisks-daemon-glue.h

/* Generated by dbus-binding-tool; do not edit! */

#include <glib.h>
#include <dbus/dbus-glib.h>

G_BEGIN_DECLS

#ifndef _DBUS_GLIB_ASYNC_DATA_FREE
#define _DBUS_GLIB_ASYNC_DATA_FREE
static
#ifdef G_HAVE_INLINE
inline
#endif
void
_dbus_glib_async_data_free (gpointer stuff)
{
      g_slice_free (DBusGAsyncData, stuff);
}
#endif

#ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_UDisks
#define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_UDisks

static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_enumerate_adapters (DBusGProxy *proxy, GPtrArray** OUT_devices, GError **error)

{
  return dbus_g_proxy_call (proxy, "EnumerateAdapters", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), OUT_devices, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_enumerate_adapters_reply) (DBusGProxy *proxy, GPtrArray *OUT_devices, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_enumerate_adapters_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  GPtrArray* OUT_devices;
  dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), &OUT_devices, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_enumerate_adapters_reply)data->cb) (proxy, OUT_devices, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_enumerate_adapters_async (DBusGProxy *proxy, org_freedesktop_UDisks_enumerate_adapters_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "EnumerateAdapters", org_freedesktop_UDisks_enumerate_adapters_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_enumerate_expanders (DBusGProxy *proxy, GPtrArray** OUT_devices, GError **error)

{
  return dbus_g_proxy_call (proxy, "EnumerateExpanders", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), OUT_devices, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_enumerate_expanders_reply) (DBusGProxy *proxy, GPtrArray *OUT_devices, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_enumerate_expanders_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  GPtrArray* OUT_devices;
  dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), &OUT_devices, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_enumerate_expanders_reply)data->cb) (proxy, OUT_devices, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_enumerate_expanders_async (DBusGProxy *proxy, org_freedesktop_UDisks_enumerate_expanders_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "EnumerateExpanders", org_freedesktop_UDisks_enumerate_expanders_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_enumerate_ports (DBusGProxy *proxy, GPtrArray** OUT_devices, GError **error)

{
  return dbus_g_proxy_call (proxy, "EnumeratePorts", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), OUT_devices, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_enumerate_ports_reply) (DBusGProxy *proxy, GPtrArray *OUT_devices, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_enumerate_ports_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  GPtrArray* OUT_devices;
  dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), &OUT_devices, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_enumerate_ports_reply)data->cb) (proxy, OUT_devices, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_enumerate_ports_async (DBusGProxy *proxy, org_freedesktop_UDisks_enumerate_ports_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "EnumeratePorts", org_freedesktop_UDisks_enumerate_ports_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_enumerate_devices (DBusGProxy *proxy, GPtrArray** OUT_devices, GError **error)

{
  return dbus_g_proxy_call (proxy, "EnumerateDevices", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), OUT_devices, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_enumerate_devices_reply) (DBusGProxy *proxy, GPtrArray *OUT_devices, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_enumerate_devices_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  GPtrArray* OUT_devices;
  dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), &OUT_devices, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_enumerate_devices_reply)data->cb) (proxy, OUT_devices, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_enumerate_devices_async (DBusGProxy *proxy, org_freedesktop_UDisks_enumerate_devices_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "EnumerateDevices", org_freedesktop_UDisks_enumerate_devices_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_enumerate_device_files (DBusGProxy *proxy, char *** OUT_device_files, GError **error)

{
  return dbus_g_proxy_call (proxy, "EnumerateDeviceFiles", error, G_TYPE_INVALID, G_TYPE_STRV, OUT_device_files, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_enumerate_device_files_reply) (DBusGProxy *proxy, char * *OUT_device_files, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_enumerate_device_files_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  char ** OUT_device_files;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRV, &OUT_device_files, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_enumerate_device_files_reply)data->cb) (proxy, OUT_device_files, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_enumerate_device_files_async (DBusGProxy *proxy, org_freedesktop_UDisks_enumerate_device_files_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "EnumerateDeviceFiles", org_freedesktop_UDisks_enumerate_device_files_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_find_device_by_device_file (DBusGProxy *proxy, const char * IN_device_file, char** OUT_device, GError **error)

{
  return dbus_g_proxy_call (proxy, "FindDeviceByDeviceFile", error, G_TYPE_STRING, IN_device_file, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, OUT_device, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_find_device_by_device_file_reply) (DBusGProxy *proxy, char *OUT_device, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_find_device_by_device_file_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  char* OUT_device;
  dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &OUT_device, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_find_device_by_device_file_reply)data->cb) (proxy, OUT_device, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_find_device_by_device_file_async (DBusGProxy *proxy, const char * IN_device_file, org_freedesktop_UDisks_find_device_by_device_file_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "FindDeviceByDeviceFile", org_freedesktop_UDisks_find_device_by_device_file_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_device_file, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_find_device_by_major_minor (DBusGProxy *proxy, const gint64 IN_device_major, const gint64 IN_device_minor, char** OUT_device, GError **error)

{
  return dbus_g_proxy_call (proxy, "FindDeviceByMajorMinor", error, G_TYPE_INT64, IN_device_major, G_TYPE_INT64, IN_device_minor, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, OUT_device, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_find_device_by_major_minor_reply) (DBusGProxy *proxy, char *OUT_device, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_find_device_by_major_minor_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  char* OUT_device;
  dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &OUT_device, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_find_device_by_major_minor_reply)data->cb) (proxy, OUT_device, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_find_device_by_major_minor_async (DBusGProxy *proxy, const gint64 IN_device_major, const gint64 IN_device_minor, org_freedesktop_UDisks_find_device_by_major_minor_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "FindDeviceByMajorMinor", org_freedesktop_UDisks_find_device_by_major_minor_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT64, IN_device_major, G_TYPE_INT64, IN_device_minor, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_drive_inhibit_all_polling (DBusGProxy *proxy, const char ** IN_options, char ** OUT_cookie, GError **error)

{
  return dbus_g_proxy_call (proxy, "DriveInhibitAllPolling", error, G_TYPE_STRV, IN_options, G_TYPE_INVALID, G_TYPE_STRING, OUT_cookie, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_drive_inhibit_all_polling_reply) (DBusGProxy *proxy, char * OUT_cookie, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_drive_inhibit_all_polling_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  char * OUT_cookie;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_cookie, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_drive_inhibit_all_polling_reply)data->cb) (proxy, OUT_cookie, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_drive_inhibit_all_polling_async (DBusGProxy *proxy, const char ** IN_options, org_freedesktop_UDisks_drive_inhibit_all_polling_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "DriveInhibitAllPolling", org_freedesktop_UDisks_drive_inhibit_all_polling_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_drive_uninhibit_all_polling (DBusGProxy *proxy, const char * IN_cookie, GError **error)

{
  return dbus_g_proxy_call (proxy, "DriveUninhibitAllPolling", error, G_TYPE_STRING, IN_cookie, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_drive_uninhibit_all_polling_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_drive_uninhibit_all_polling_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_drive_uninhibit_all_polling_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_drive_uninhibit_all_polling_async (DBusGProxy *proxy, const char * IN_cookie, org_freedesktop_UDisks_drive_uninhibit_all_polling_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "DriveUninhibitAllPolling", org_freedesktop_UDisks_drive_uninhibit_all_polling_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_cookie, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_drive_set_all_spindown_timeouts (DBusGProxy *proxy, const gint IN_timeout_seconds, const char ** IN_options, char ** OUT_cookie, GError **error)

{
  return dbus_g_proxy_call (proxy, "DriveSetAllSpindownTimeouts", error, G_TYPE_INT, IN_timeout_seconds, G_TYPE_STRV, IN_options, G_TYPE_INVALID, G_TYPE_STRING, OUT_cookie, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_drive_set_all_spindown_timeouts_reply) (DBusGProxy *proxy, char * OUT_cookie, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_drive_set_all_spindown_timeouts_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  char * OUT_cookie;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_cookie, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_drive_set_all_spindown_timeouts_reply)data->cb) (proxy, OUT_cookie, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_drive_set_all_spindown_timeouts_async (DBusGProxy *proxy, const gint IN_timeout_seconds, const char ** IN_options, org_freedesktop_UDisks_drive_set_all_spindown_timeouts_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "DriveSetAllSpindownTimeouts", org_freedesktop_UDisks_drive_set_all_spindown_timeouts_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_timeout_seconds, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_drive_unset_all_spindown_timeouts (DBusGProxy *proxy, const char * IN_cookie, GError **error)

{
  return dbus_g_proxy_call (proxy, "DriveUnsetAllSpindownTimeouts", error, G_TYPE_STRING, IN_cookie, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_drive_unset_all_spindown_timeouts_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_drive_unset_all_spindown_timeouts_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_drive_unset_all_spindown_timeouts_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_drive_unset_all_spindown_timeouts_async (DBusGProxy *proxy, const char * IN_cookie, org_freedesktop_UDisks_drive_unset_all_spindown_timeouts_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "DriveUnsetAllSpindownTimeouts", org_freedesktop_UDisks_drive_unset_all_spindown_timeouts_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_cookie, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_lvm2_vg_start (DBusGProxy *proxy, const char * IN_uuid, const char ** IN_options, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxLvm2VGStart", error, G_TYPE_STRING, IN_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_lvm2_vg_start_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_lvm2_vg_start_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_lvm2_vg_start_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_lvm2_vg_start_async (DBusGProxy *proxy, const char * IN_uuid, const char ** IN_options, org_freedesktop_UDisks_linux_lvm2_vg_start_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxLvm2VGStart", org_freedesktop_UDisks_linux_lvm2_vg_start_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_lvm2_vg_stop (DBusGProxy *proxy, const char * IN_uuid, const char ** IN_options, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxLvm2VGStop", error, G_TYPE_STRING, IN_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_lvm2_vg_stop_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_lvm2_vg_stop_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_lvm2_vg_stop_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_lvm2_vg_stop_async (DBusGProxy *proxy, const char * IN_uuid, const char ** IN_options, org_freedesktop_UDisks_linux_lvm2_vg_stop_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxLvm2VGStop", org_freedesktop_UDisks_linux_lvm2_vg_stop_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_lvm2_vg_set_name (DBusGProxy *proxy, const char * IN_uuid, const char * IN_name, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxLvm2VGSetName", error, G_TYPE_STRING, IN_uuid, G_TYPE_STRING, IN_name, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_lvm2_vg_set_name_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_lvm2_vg_set_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_lvm2_vg_set_name_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_lvm2_vg_set_name_async (DBusGProxy *proxy, const char * IN_uuid, const char * IN_name, org_freedesktop_UDisks_linux_lvm2_vg_set_name_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxLvm2VGSetName", org_freedesktop_UDisks_linux_lvm2_vg_set_name_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_uuid, G_TYPE_STRING, IN_name, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_lvm2_vg_add_pv (DBusGProxy *proxy, const char * IN_uuid, const char* IN_physical_volume, const char ** IN_options, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxLvm2VGAddPV", error, G_TYPE_STRING, IN_uuid, DBUS_TYPE_G_OBJECT_PATH, IN_physical_volume, G_TYPE_STRV, IN_options, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_lvm2_vg_add_pv_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_lvm2_vg_add_pv_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_lvm2_vg_add_pv_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_lvm2_vg_add_pv_async (DBusGProxy *proxy, const char * IN_uuid, const char* IN_physical_volume, const char ** IN_options, org_freedesktop_UDisks_linux_lvm2_vg_add_pv_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxLvm2VGAddPV", org_freedesktop_UDisks_linux_lvm2_vg_add_pv_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_uuid, DBUS_TYPE_G_OBJECT_PATH, IN_physical_volume, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_lvm2_vg_remove_pv (DBusGProxy *proxy, const char * IN_vg_uuid, const char * IN_pv_uuid, const char ** IN_options, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxLvm2VGRemovePV", error, G_TYPE_STRING, IN_vg_uuid, G_TYPE_STRING, IN_pv_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_lvm2_vg_remove_pv_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_lvm2_vg_remove_pv_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_lvm2_vg_remove_pv_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_lvm2_vg_remove_pv_async (DBusGProxy *proxy, const char * IN_vg_uuid, const char * IN_pv_uuid, const char ** IN_options, org_freedesktop_UDisks_linux_lvm2_vg_remove_pv_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxLvm2VGRemovePV", org_freedesktop_UDisks_linux_lvm2_vg_remove_pv_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_vg_uuid, G_TYPE_STRING, IN_pv_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_lvm2_lv_set_name (DBusGProxy *proxy, const char * IN_group_uuid, const char * IN_uuid, const char * IN_name, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxLvm2LVSetName", error, G_TYPE_STRING, IN_group_uuid, G_TYPE_STRING, IN_uuid, G_TYPE_STRING, IN_name, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_lvm2_lv_set_name_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_lvm2_lv_set_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_lvm2_lv_set_name_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_lvm2_lv_set_name_async (DBusGProxy *proxy, const char * IN_group_uuid, const char * IN_uuid, const char * IN_name, org_freedesktop_UDisks_linux_lvm2_lv_set_name_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxLvm2LVSetName", org_freedesktop_UDisks_linux_lvm2_lv_set_name_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_group_uuid, G_TYPE_STRING, IN_uuid, G_TYPE_STRING, IN_name, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_lvm2_lv_start (DBusGProxy *proxy, const char * IN_group_uuid, const char * IN_uuid, const char ** IN_options, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxLvm2LVStart", error, G_TYPE_STRING, IN_group_uuid, G_TYPE_STRING, IN_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_lvm2_lv_start_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_lvm2_lv_start_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_lvm2_lv_start_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_lvm2_lv_start_async (DBusGProxy *proxy, const char * IN_group_uuid, const char * IN_uuid, const char ** IN_options, org_freedesktop_UDisks_linux_lvm2_lv_start_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxLvm2LVStart", org_freedesktop_UDisks_linux_lvm2_lv_start_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_group_uuid, G_TYPE_STRING, IN_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_lvm2_lv_remove (DBusGProxy *proxy, const char * IN_group_uuid, const char * IN_uuid, const char ** IN_options, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxLvm2LVRemove", error, G_TYPE_STRING, IN_group_uuid, G_TYPE_STRING, IN_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_lvm2_lv_remove_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_lvm2_lv_remove_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_lvm2_lv_remove_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_lvm2_lv_remove_async (DBusGProxy *proxy, const char * IN_group_uuid, const char * IN_uuid, const char ** IN_options, org_freedesktop_UDisks_linux_lvm2_lv_remove_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxLvm2LVRemove", org_freedesktop_UDisks_linux_lvm2_lv_remove_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_group_uuid, G_TYPE_STRING, IN_uuid, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_lvm2_lv_create (DBusGProxy *proxy, const char * IN_group_uuid, const char * IN_name, const guint64 IN_size, const guint IN_num_stripes, const guint64 IN_stripe_size, const guint IN_num_mirrors, const char ** IN_options, const char * IN_fstype, const char ** IN_fsoptions, char** OUT_created_device, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxLvm2LVCreate", error, G_TYPE_STRING, IN_group_uuid, G_TYPE_STRING, IN_name, G_TYPE_UINT64, IN_size, G_TYPE_UINT, IN_num_stripes, G_TYPE_UINT64, IN_stripe_size, G_TYPE_UINT, IN_num_mirrors, G_TYPE_STRV, IN_options, G_TYPE_STRING, IN_fstype, G_TYPE_STRV, IN_fsoptions, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, OUT_created_device, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_lvm2_lv_create_reply) (DBusGProxy *proxy, char *OUT_created_device, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_lvm2_lv_create_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  char* OUT_created_device;
  dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &OUT_created_device, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_lvm2_lv_create_reply)data->cb) (proxy, OUT_created_device, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_lvm2_lv_create_async (DBusGProxy *proxy, const char * IN_group_uuid, const char * IN_name, const guint64 IN_size, const guint IN_num_stripes, const guint64 IN_stripe_size, const guint IN_num_mirrors, const char ** IN_options, const char * IN_fstype, const char ** IN_fsoptions, org_freedesktop_UDisks_linux_lvm2_lv_create_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxLvm2LVCreate", org_freedesktop_UDisks_linux_lvm2_lv_create_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_group_uuid, G_TYPE_STRING, IN_name, G_TYPE_UINT64, IN_size, G_TYPE_UINT, IN_num_stripes, G_TYPE_UINT64, IN_stripe_size, G_TYPE_UINT, IN_num_mirrors, G_TYPE_STRV, IN_options, G_TYPE_STRING, IN_fstype, G_TYPE_STRV, IN_fsoptions, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_md_start (DBusGProxy *proxy, const GPtrArray* IN_components, const char ** IN_options, char** OUT_device, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxMdStart", error, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), IN_components, G_TYPE_STRV, IN_options, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, OUT_device, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_md_start_reply) (DBusGProxy *proxy, char *OUT_device, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_md_start_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  char* OUT_device;
  dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &OUT_device, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_md_start_reply)data->cb) (proxy, OUT_device, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_md_start_async (DBusGProxy *proxy, const GPtrArray* IN_components, const char ** IN_options, org_freedesktop_UDisks_linux_md_start_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxMdStart", org_freedesktop_UDisks_linux_md_start_async_callback, stuff, _dbus_glib_async_data_free, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), IN_components, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_linux_md_create (DBusGProxy *proxy, const GPtrArray* IN_components, const char * IN_level, const guint64 IN_stripe_size, const char * IN_name, const char ** IN_options, char** OUT_device, GError **error)

{
  return dbus_g_proxy_call (proxy, "LinuxMdCreate", error, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), IN_components, G_TYPE_STRING, IN_level, G_TYPE_UINT64, IN_stripe_size, G_TYPE_STRING, IN_name, G_TYPE_STRV, IN_options, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, OUT_device, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_linux_md_create_reply) (DBusGProxy *proxy, char *OUT_device, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_linux_md_create_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  char* OUT_device;
  dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &OUT_device, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_linux_md_create_reply)data->cb) (proxy, OUT_device, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_linux_md_create_async (DBusGProxy *proxy, const GPtrArray* IN_components, const char * IN_level, const guint64 IN_stripe_size, const char * IN_name, const char ** IN_options, org_freedesktop_UDisks_linux_md_create_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "LinuxMdCreate", org_freedesktop_UDisks_linux_md_create_async_callback, stuff, _dbus_glib_async_data_free, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), IN_components, G_TYPE_STRING, IN_level, G_TYPE_UINT64, IN_stripe_size, G_TYPE_STRING, IN_name, G_TYPE_STRV, IN_options, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_inhibit (DBusGProxy *proxy, char ** OUT_cookie, GError **error)

{
  return dbus_g_proxy_call (proxy, "Inhibit", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_cookie, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_inhibit_reply) (DBusGProxy *proxy, char * OUT_cookie, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_inhibit_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  char * OUT_cookie;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_cookie, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_inhibit_reply)data->cb) (proxy, OUT_cookie, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_inhibit_async (DBusGProxy *proxy, org_freedesktop_UDisks_inhibit_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "Inhibit", org_freedesktop_UDisks_inhibit_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
}
static
#ifdef G_HAVE_INLINE
inline
#endif
gboolean
org_freedesktop_UDisks_uninhibit (DBusGProxy *proxy, const char * IN_cookie, GError **error)

{
  return dbus_g_proxy_call (proxy, "Uninhibit", error, G_TYPE_STRING, IN_cookie, G_TYPE_INVALID, G_TYPE_INVALID);
}

typedef void (*org_freedesktop_UDisks_uninhibit_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

static void
org_freedesktop_UDisks_uninhibit_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
{
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
  GError *error = NULL;
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
  (*(org_freedesktop_UDisks_uninhibit_reply)data->cb) (proxy, error, data->userdata);
  return;
}

static
#ifdef G_HAVE_INLINE
inline
#endif
DBusGProxyCall*
org_freedesktop_UDisks_uninhibit_async (DBusGProxy *proxy, const char * IN_cookie, org_freedesktop_UDisks_uninhibit_reply callback, gpointer userdata)

{
  DBusGAsyncData *stuff;
  stuff = g_slice_new (DBusGAsyncData);
  stuff->cb = G_CALLBACK (callback);
  stuff->userdata = userdata;
  return dbus_g_proxy_begin_call (proxy, "Uninhibit", org_freedesktop_UDisks_uninhibit_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_cookie, G_TYPE_INVALID);
}
#endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_UDisks */

G_END_DECLS

Generated by  Doxygen 1.6.0   Back to index