/* tracker-bus.c generated by valac 0.11.2, the Vala compiler
 * generated from tracker-bus.vala, do not modify */

/*
 * Copyright (C) 2010, Nokia <ivan.frade@nokia.com>
 *
 * 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.1 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., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include <glib.h>
#include <glib-object.h>
#include <gio/gio.h>
#include <stdlib.h>
#include <string.h>
#include <libtracker-sparql/tracker-sparql.h>
#include <gio/gunixoutputstream.h>
#include <gio/gunixinputstream.h>
#include <gio/gunixfdlist.h>
#include <unistd.h>


#define TRACKER_BUS_TYPE_RESOURCES (tracker_bus_resources_get_type ())
#define TRACKER_BUS_RESOURCES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRACKER_BUS_TYPE_RESOURCES, TrackerBusResources))
#define TRACKER_BUS_IS_RESOURCES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TRACKER_BUS_TYPE_RESOURCES))
#define TRACKER_BUS_RESOURCES_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TRACKER_BUS_TYPE_RESOURCES, TrackerBusResourcesIface))

typedef struct _TrackerBusResources TrackerBusResources;
typedef struct _TrackerBusResourcesIface TrackerBusResourcesIface;

#define TRACKER_BUS_TYPE_RESOURCES_PROXY (tracker_bus_resources_proxy_get_type ())
typedef GDBusProxy TrackerBusResourcesProxy;
typedef GDBusProxyClass TrackerBusResourcesProxyClass;
#define _g_free0(var) (var = (g_free (var), NULL))

#define TRACKER_BUS_TYPE_STEROIDS (tracker_bus_steroids_get_type ())
#define TRACKER_BUS_STEROIDS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRACKER_BUS_TYPE_STEROIDS, TrackerBusSteroids))
#define TRACKER_BUS_IS_STEROIDS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TRACKER_BUS_TYPE_STEROIDS))
#define TRACKER_BUS_STEROIDS_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TRACKER_BUS_TYPE_STEROIDS, TrackerBusSteroidsIface))

typedef struct _TrackerBusSteroids TrackerBusSteroids;
typedef struct _TrackerBusSteroidsIface TrackerBusSteroidsIface;

#define TRACKER_BUS_TYPE_STEROIDS_PROXY (tracker_bus_steroids_proxy_get_type ())
typedef GDBusProxy TrackerBusSteroidsProxy;
typedef GDBusProxyClass TrackerBusSteroidsProxyClass;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))

#define TRACKER_BUS_TYPE_STATISTICS (tracker_bus_statistics_get_type ())
#define TRACKER_BUS_STATISTICS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRACKER_BUS_TYPE_STATISTICS, TrackerBusStatistics))
#define TRACKER_BUS_IS_STATISTICS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TRACKER_BUS_TYPE_STATISTICS))
#define TRACKER_BUS_STATISTICS_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TRACKER_BUS_TYPE_STATISTICS, TrackerBusStatisticsIface))

typedef struct _TrackerBusStatistics TrackerBusStatistics;
typedef struct _TrackerBusStatisticsIface TrackerBusStatisticsIface;

#define TRACKER_BUS_TYPE_STATISTICS_PROXY (tracker_bus_statistics_proxy_get_type ())
typedef GDBusProxy TrackerBusStatisticsProxy;
typedef GDBusProxyClass TrackerBusStatisticsProxyClass;

#define TRACKER_BUS_TYPE_CONNECTION (tracker_bus_connection_get_type ())
#define TRACKER_BUS_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRACKER_BUS_TYPE_CONNECTION, TrackerBusConnection))
#define TRACKER_BUS_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TRACKER_BUS_TYPE_CONNECTION, TrackerBusConnectionClass))
#define TRACKER_BUS_IS_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TRACKER_BUS_TYPE_CONNECTION))
#define TRACKER_BUS_IS_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TRACKER_BUS_TYPE_CONNECTION))
#define TRACKER_BUS_CONNECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TRACKER_BUS_TYPE_CONNECTION, TrackerBusConnectionClass))

typedef struct _TrackerBusConnection TrackerBusConnection;
typedef struct _TrackerBusConnectionClass TrackerBusConnectionClass;
typedef struct _TrackerBusConnectionPrivate TrackerBusConnectionPrivate;
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
typedef struct _Block1Data Block1Data;
#define _g_main_context_unref0(var) ((var == NULL) ? NULL : (var = (g_main_context_unref (var), NULL)))
typedef struct _Block2Data Block2Data;

#define TRACKER_BUS_TYPE_FD_CURSOR (tracker_bus_fd_cursor_get_type ())
#define TRACKER_BUS_FD_CURSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRACKER_BUS_TYPE_FD_CURSOR, TrackerBusFDCursor))
#define TRACKER_BUS_FD_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TRACKER_BUS_TYPE_FD_CURSOR, TrackerBusFDCursorClass))
#define TRACKER_BUS_IS_FD_CURSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TRACKER_BUS_TYPE_FD_CURSOR))
#define TRACKER_BUS_IS_FD_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TRACKER_BUS_TYPE_FD_CURSOR))
#define TRACKER_BUS_FD_CURSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TRACKER_BUS_TYPE_FD_CURSOR, TrackerBusFDCursorClass))

typedef struct _TrackerBusFDCursor TrackerBusFDCursor;
typedef struct _TrackerBusFDCursorClass TrackerBusFDCursorClass;
typedef struct _TrackerBusConnectionQueryAsyncData TrackerBusConnectionQueryAsyncData;
typedef struct _Block3Data Block3Data;
typedef struct _Block4Data Block4Data;
typedef struct _TrackerBusConnectionUpdateAsyncData TrackerBusConnectionUpdateAsyncData;
#define _g_ptr_array_unref0(var) ((var == NULL) ? NULL : (var = (g_ptr_array_unref (var), NULL)))
typedef struct _Block5Data Block5Data;
#define _g_variant_iter_free0(var) ((var == NULL) ? NULL : (var = (g_variant_iter_free (var), NULL)))
typedef struct _TrackerBusConnectionUpdateArrayAsyncData TrackerBusConnectionUpdateArrayAsyncData;
typedef struct _Block6Data Block6Data;
typedef struct _Block7Data Block7Data;
typedef struct _TrackerBusConnectionUpdateBlankAsyncData TrackerBusConnectionUpdateBlankAsyncData;
typedef struct _TrackerBusConnectionLoadAsyncData TrackerBusConnectionLoadAsyncData;

#define TRACKER_BUS_TYPE_ARRAY_CURSOR (tracker_bus_array_cursor_get_type ())
#define TRACKER_BUS_ARRAY_CURSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRACKER_BUS_TYPE_ARRAY_CURSOR, TrackerBusArrayCursor))
#define TRACKER_BUS_ARRAY_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TRACKER_BUS_TYPE_ARRAY_CURSOR, TrackerBusArrayCursorClass))
#define TRACKER_BUS_IS_ARRAY_CURSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TRACKER_BUS_TYPE_ARRAY_CURSOR))
#define TRACKER_BUS_IS_ARRAY_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TRACKER_BUS_TYPE_ARRAY_CURSOR))
#define TRACKER_BUS_ARRAY_CURSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TRACKER_BUS_TYPE_ARRAY_CURSOR, TrackerBusArrayCursorClass))

typedef struct _TrackerBusArrayCursor TrackerBusArrayCursor;
typedef struct _TrackerBusArrayCursorClass TrackerBusArrayCursorClass;
typedef struct _TrackerBusConnectionStatisticsAsyncData TrackerBusConnectionStatisticsAsyncData;

struct _TrackerBusResourcesIface {
	GTypeInterface parent_iface;
	void (*load) (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GError** error);
	void (*load_async) (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*load_finish) (TrackerBusResources* self, GAsyncResult* _res_, GError** error);
};

struct _TrackerBusSteroidsIface {
	GTypeInterface parent_iface;
	void (*query) (TrackerBusSteroids* self, const gchar* query, GUnixOutputStream* result_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gchar** (*query_finish) (TrackerBusSteroids* self, GAsyncResult* _res_, int* result_length1, GError** error);
	void (*update) (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*update_finish) (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
	void (*update_blank) (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	GVariant* (*update_blank_finish) (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
	void (*batch_update) (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*batch_update_finish) (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
	void (*update_array) (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	GVariant* (*update_array_finish) (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
	void (*batch_update_array) (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	GVariant* (*batch_update_array_finish) (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
};

struct _TrackerBusStatisticsIface {
	GTypeInterface parent_iface;
	gchar** (*Get) (TrackerBusStatistics* self, GCancellable* cancellable, int* result_length1, int* result_length2, GError** error);
	void (*Get_async) (TrackerBusStatistics* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gchar** (*Get_finish) (TrackerBusStatistics* self, GAsyncResult* _res_, int* result_length1, int* result_length2, GError** error);
};

struct _TrackerBusConnection {
	TrackerSparqlConnection parent_instance;
	TrackerBusConnectionPrivate * priv;
};

struct _TrackerBusConnectionClass {
	TrackerSparqlConnectionClass parent_class;
};

struct _Block1Data {
	int _ref_count_;
	TrackerBusConnection * self;
	GMainLoop* loop;
	GAsyncResult* async_res;
};

struct _Block2Data {
	int _ref_count_;
	TrackerBusConnection * self;
	GAsyncResult* dbus_res;
	gboolean received_result;
	gpointer _async_data_;
};

struct _TrackerBusConnectionQueryAsyncData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	TrackerBusConnection* self;
	gchar* sparql;
	GCancellable* cancellable;
	TrackerSparqlCursor* result;
	Block2Data* _data2_;
	GUnixInputStream* input;
	GUnixOutputStream* output;
	GUnixInputStream* _tmp0_;
	GUnixOutputStream* _tmp1_;
	GUnixOutputStream* _tmp2_;
	GMemoryOutputStream* _tmp3_;
	GMemoryOutputStream* mem_stream;
	gint _tmp4_;
	gchar** _tmp5_;
	gint variable_names_length1;
	gint _variable_names_size_;
	gchar** _tmp6_;
	gchar** variable_names;
	guint8* _tmp7_;
	gulong _tmp8_;
	TrackerBusFDCursor* _tmp9_;
	GError * _inner_error_;
};

struct _Block3Data {
	int _ref_count_;
	TrackerBusConnection * self;
	GMainLoop* loop;
	GAsyncResult* async_res;
};

struct _Block4Data {
	int _ref_count_;
	TrackerBusConnection * self;
	GAsyncResult* dbus_res;
	gboolean sent_update;
	gpointer _async_data_;
};

struct _TrackerBusConnectionUpdateAsyncData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	TrackerBusConnection* self;
	gchar* sparql;
	gint priority;
	GCancellable* cancellable;
	Block4Data* _data4_;
	GUnixInputStream* input;
	GUnixOutputStream* output;
	GUnixInputStream* _tmp0_;
	GUnixOutputStream* _tmp1_;
	GDataOutputStream* _tmp2_;
	GDataOutputStream* data_stream;
	glong _tmp3_;
	GDataOutputStream* _tmp4_;
	GError * _inner_error_;
};

struct _Block5Data {
	int _ref_count_;
	TrackerBusConnection * self;
	GAsyncResult* dbus_res;
	gboolean sent_update;
	gpointer _async_data_;
};

struct _TrackerBusConnectionUpdateArrayAsyncData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	TrackerBusConnection* self;
	gchar** sparql;
	gint sparql_length1;
	gint priority;
	GCancellable* cancellable;
	GPtrArray* result;
	Block5Data* _data5_;
	GUnixInputStream* input;
	GUnixOutputStream* output;
	GUnixInputStream* _tmp0_;
	GUnixOutputStream* _tmp1_;
	GDataOutputStream* _tmp2_;
	GDataOutputStream* data_stream;
	gint i;
	gboolean _tmp3_;
	glong _tmp4_;
	GDataOutputStream* _tmp5_;
	GPtrArray* _tmp6_;
	GPtrArray* _result_;
	GVariant* resultv;
	GVariant* _tmp7_;
	GVariant* _tmp8_;
	GVariant* _tmp9_;
	GVariant* _tmp10_;
	GVariant* _tmp11_;
	GVariant* _tmp12_;
	GVariantIter* _tmp13_;
	GVariantIter* iter;
	gchar* code;
	gchar* message;
	gboolean _tmp14_;
	gboolean _tmp15_;
	gboolean _tmp16_;
	GError* _tmp17_;
	GError * _inner_error_;
};

struct _Block6Data {
	int _ref_count_;
	TrackerBusConnection * self;
	GMainLoop* loop;
	GAsyncResult* async_res;
};

struct _Block7Data {
	int _ref_count_;
	TrackerBusConnection * self;
	GAsyncResult* dbus_res;
	gboolean sent_update;
	gpointer _async_data_;
};

struct _TrackerBusConnectionUpdateBlankAsyncData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	TrackerBusConnection* self;
	gchar* sparql;
	gint priority;
	GCancellable* cancellable;
	GVariant* result;
	Block7Data* _data7_;
	GUnixInputStream* input;
	GUnixOutputStream* output;
	GUnixInputStream* _tmp0_;
	GUnixOutputStream* _tmp1_;
	GDataOutputStream* _tmp2_;
	GDataOutputStream* data_stream;
	glong _tmp3_;
	GDataOutputStream* _tmp4_;
	GVariant* _tmp5_;
	GVariant* _tmp6_;
	GError * _inner_error_;
};

struct _TrackerBusConnectionLoadAsyncData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	TrackerBusConnection* self;
	GFile* file;
	GCancellable* cancellable;
	gchar* _tmp0_;
	gchar* _tmp1_;
	gboolean _tmp2_;
	gboolean _tmp3_;
	GError* _tmp4_;
	GError * _inner_error_;
};

struct _TrackerBusConnectionStatisticsAsyncData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	TrackerBusConnection* self;
	GCancellable* cancellable;
	TrackerSparqlCursor* result;
	gint _tmp0_;
	gint _tmp1_;
	gchar** _tmp2_;
	gint results_length1;
	gint results_length2;
	gchar** _tmp3_;
	gchar** results;
	TrackerSparqlValueType* _tmp4_;
	gint types_length1;
	gint _types_size_;
	TrackerSparqlValueType* _tmp5_;
	TrackerSparqlValueType* types;
	gchar** _tmp6_;
	gint var_names_length1;
	gint _var_names_size_;
	gchar** _tmp7_;
	gchar** var_names;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	gchar** _tmp12_;
	TrackerBusArrayCursor* _tmp13_;
	GError * _inner_error_;
};


static gpointer tracker_bus_connection_parent_class = NULL;
static gboolean tracker_bus_connection_initialized;
static TrackerBusResources* tracker_bus_connection_resources_object;
static TrackerBusResources* tracker_bus_connection_resources_object = NULL;
static TrackerBusSteroids* tracker_bus_connection_steroids_object;
static TrackerBusSteroids* tracker_bus_connection_steroids_object = NULL;
static TrackerBusStatistics* tracker_bus_connection_statistics_object;
static TrackerBusStatistics* tracker_bus_connection_statistics_object = NULL;
static gboolean tracker_bus_connection_initialized = FALSE;

GType tracker_bus_resources_proxy_get_type (void) G_GNUC_CONST;
guint tracker_bus_resources_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType tracker_bus_resources_get_type (void) G_GNUC_CONST;
void tracker_bus_resources_load (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GError** error);
void tracker_bus_resources_load_async (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
void tracker_bus_resources_load_finish (TrackerBusResources* self, GAsyncResult* _res_, GError** error);
static void tracker_bus_resources_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static void tracker_bus_resources_proxy_load (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GError** error);
static void _vala_g_async_ready_callback (GObject *source_object, GAsyncResult *res, void *user_data);
static void tracker_bus_resources_proxy_load_async_async (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void tracker_bus_resources_proxy_load_async_finish (TrackerBusResources* self, GAsyncResult* _res_, GError** error);
static void tracker_bus_resources_proxy_tracker_bus_resources_interface_init (TrackerBusResourcesIface* iface);
static void _dbus_tracker_bus_resources_load (TrackerBusResources* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_resources_load_async (TrackerBusResources* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_resources_load_async_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
static void tracker_bus_resources_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* tracker_bus_resources_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean tracker_bus_resources_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _tracker_bus_resources_unregister_object (gpointer user_data);
GType tracker_bus_steroids_proxy_get_type (void) G_GNUC_CONST;
guint tracker_bus_steroids_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType tracker_bus_steroids_get_type (void) G_GNUC_CONST;
void tracker_bus_steroids_query (TrackerBusSteroids* self, const gchar* query, GUnixOutputStream* result_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
gchar** tracker_bus_steroids_query_finish (TrackerBusSteroids* self, GAsyncResult* _res_, int* result_length1, GError** error);
void tracker_bus_steroids_update (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
void tracker_bus_steroids_update_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
void tracker_bus_steroids_update_blank (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
GVariant* tracker_bus_steroids_update_blank_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
void tracker_bus_steroids_batch_update (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
void tracker_bus_steroids_batch_update_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
void tracker_bus_steroids_update_array (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
GVariant* tracker_bus_steroids_update_array_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
void tracker_bus_steroids_batch_update_array (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
GVariant* tracker_bus_steroids_batch_update_array_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
void tracker_bus_steroids_update_begin (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, gint priority, GCancellable* cancellable, GAsyncReadyCallback callback, void* callback_target);
void tracker_bus_steroids_update_array_begin (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, gint priority, GCancellable* cancellable, GAsyncReadyCallback callback, void* callback_target);
static void tracker_bus_steroids_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static void tracker_bus_steroids_proxy_query_async (TrackerBusSteroids* self, const gchar* query, GUnixOutputStream* result_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar** tracker_bus_steroids_proxy_query_finish (TrackerBusSteroids* self, GAsyncResult* _res_, int* result_length1, GError** error);
static void tracker_bus_steroids_proxy_update_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void tracker_bus_steroids_proxy_update_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
static void tracker_bus_steroids_proxy_update_blank_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static GVariant* tracker_bus_steroids_proxy_update_blank_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
static void tracker_bus_steroids_proxy_batch_update_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void tracker_bus_steroids_proxy_batch_update_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
static void tracker_bus_steroids_proxy_update_array_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static GVariant* tracker_bus_steroids_proxy_update_array_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
static void tracker_bus_steroids_proxy_batch_update_array_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static GVariant* tracker_bus_steroids_proxy_batch_update_array_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error);
static void tracker_bus_steroids_proxy_tracker_bus_steroids_interface_init (TrackerBusSteroidsIface* iface);
static void _dbus_tracker_bus_steroids_query (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_steroids_query_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
static void _dbus_tracker_bus_steroids_update (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_steroids_update_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
static void _dbus_tracker_bus_steroids_update_blank (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_steroids_update_blank_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
static void _dbus_tracker_bus_steroids_batch_update (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_steroids_batch_update_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
static void _dbus_tracker_bus_steroids_update_array (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_steroids_update_array_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
static void _dbus_tracker_bus_steroids_batch_update_array (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_steroids_batch_update_array_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
static void tracker_bus_steroids_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* tracker_bus_steroids_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean tracker_bus_steroids_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _tracker_bus_steroids_unregister_object (gpointer user_data);
GType tracker_bus_statistics_proxy_get_type (void) G_GNUC_CONST;
guint tracker_bus_statistics_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType tracker_bus_statistics_get_type (void) G_GNUC_CONST;
gchar** tracker_bus_statistics_Get (TrackerBusStatistics* self, GCancellable* cancellable, int* result_length1, int* result_length2, GError** error);
void tracker_bus_statistics_Get_async (TrackerBusStatistics* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
gchar** tracker_bus_statistics_Get_finish (TrackerBusStatistics* self, GAsyncResult* _res_, int* result_length1, int* result_length2, GError** error);
static void tracker_bus_statistics_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static gchar** tracker_bus_statistics_proxy_Get (TrackerBusStatistics* self, GCancellable* cancellable, int* result_length1, int* result_length2, GError** error);
static void tracker_bus_statistics_proxy_Get_async_async (TrackerBusStatistics* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar** tracker_bus_statistics_proxy_Get_async_finish (TrackerBusStatistics* self, GAsyncResult* _res_, int* result_length1, int* result_length2, GError** error);
static void tracker_bus_statistics_proxy_tracker_bus_statistics_interface_init (TrackerBusStatisticsIface* iface);
static void _dbus_tracker_bus_statistics_Get (TrackerBusStatistics* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_statistics_Get_async (TrackerBusStatistics* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_tracker_bus_statistics_Get_async_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
static void tracker_bus_statistics_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* tracker_bus_statistics_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean tracker_bus_statistics_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _tracker_bus_statistics_unregister_object (gpointer user_data);
GType tracker_bus_connection_get_type (void) G_GNUC_CONST;
enum  {
	TRACKER_BUS_CONNECTION_DUMMY_PROPERTY
};
TrackerBusConnection* tracker_bus_connection_new (GError** error);
TrackerBusConnection* tracker_bus_connection_construct (GType object_type, GError** error);
static void tracker_bus_connection_pipe (TrackerBusConnection* self, GUnixInputStream** input, GUnixOutputStream** output, GError** error);
static TrackerSparqlCursor* tracker_bus_connection_real_query (TrackerSparqlConnection* base, const gchar* sparql, GCancellable* cancellable, GError** error);
static Block1Data* block1_data_ref (Block1Data* _data1_);
static void block1_data_unref (Block1Data* _data1_);
static void _lambda1_ (GObject* o, GAsyncResult* res, Block1Data* _data1_);
static void __lambda1__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void tracker_bus_connection_real_query_async_data_free (gpointer _data);
static void tracker_bus_connection_real_query_async (TrackerSparqlConnection* base, const gchar* sparql, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void tracker_bus_connection_query_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static gboolean tracker_bus_connection_real_query_async_co (TrackerBusConnectionQueryAsyncData* data);
static Block2Data* block2_data_ref (Block2Data* _data2_);
static void block2_data_unref (Block2Data* _data2_);
static void _lambda0_ (GObject* o, GAsyncResult* res, Block2Data* _data2_);
static void __lambda0__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void* _g_realloc_grealloc_func (void* data, gsize size);
static void _g_free_gdestroy_notify (void* data);
TrackerBusFDCursor* tracker_bus_fd_cursor_new (gchar* buffer, gulong buffer_size, gchar** variable_names, int variable_names_length1);
TrackerBusFDCursor* tracker_bus_fd_cursor_construct (GType object_type, gchar* buffer, gulong buffer_size, gchar** variable_names, int variable_names_length1);
GType tracker_bus_fd_cursor_get_type (void) G_GNUC_CONST;
static void tracker_bus_connection_real_update (TrackerSparqlConnection* base, const gchar* sparql, gint priority, GCancellable* cancellable, GError** error);
static Block3Data* block3_data_ref (Block3Data* _data3_);
static void block3_data_unref (Block3Data* _data3_);
static void _lambda3_ (GObject* o, GAsyncResult* res, Block3Data* _data3_);
static void __lambda3__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void tracker_bus_connection_real_update_async_data_free (gpointer _data);
static void tracker_bus_connection_real_update_async (TrackerSparqlConnection* base, const gchar* sparql, gint priority, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void tracker_bus_connection_update_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static gboolean tracker_bus_connection_real_update_async_co (TrackerBusConnectionUpdateAsyncData* data);
static Block4Data* block4_data_ref (Block4Data* _data4_);
static void block4_data_unref (Block4Data* _data4_);
static void _lambda2_ (GObject* o, GAsyncResult* res, Block4Data* _data4_);
static void __lambda2__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void tracker_bus_connection_real_update_array_async_data_free (gpointer _data);
static void tracker_bus_connection_real_update_array_async (TrackerSparqlConnection* base, gchar** sparql, int sparql_length1, gint priority, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar** _vala_array_dup1 (gchar** self, int length);
static void tracker_bus_connection_update_array_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static gboolean tracker_bus_connection_real_update_array_async_co (TrackerBusConnectionUpdateArrayAsyncData* data);
static Block5Data* block5_data_ref (Block5Data* _data5_);
static void block5_data_unref (Block5Data* _data5_);
static void _lambda4_ (GObject* o, GAsyncResult* res, Block5Data* _data5_);
static void __lambda4__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void _g_error_free0_ (gpointer var);
static GVariant* tracker_bus_connection_real_update_blank (TrackerSparqlConnection* base, const gchar* sparql, gint priority, GCancellable* cancellable, GError** error);
static Block6Data* block6_data_ref (Block6Data* _data6_);
static void block6_data_unref (Block6Data* _data6_);
static void _lambda6_ (GObject* o, GAsyncResult* res, Block6Data* _data6_);
static void __lambda6__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void tracker_bus_connection_real_update_blank_async_data_free (gpointer _data);
static void tracker_bus_connection_real_update_blank_async (TrackerSparqlConnection* base, const gchar* sparql, gint priority, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void tracker_bus_connection_update_blank_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static gboolean tracker_bus_connection_real_update_blank_async_co (TrackerBusConnectionUpdateBlankAsyncData* data);
static Block7Data* block7_data_ref (Block7Data* _data7_);
static void block7_data_unref (Block7Data* _data7_);
static void _lambda5_ (GObject* o, GAsyncResult* res, Block7Data* _data7_);
static void __lambda5__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void tracker_bus_connection_real_load (TrackerSparqlConnection* base, GFile* file, GCancellable* cancellable, GError** error);
static void tracker_bus_connection_real_load_async_data_free (gpointer _data);
static void tracker_bus_connection_real_load_async (TrackerSparqlConnection* base, GFile* file, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void tracker_bus_connection_load_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static gboolean tracker_bus_connection_real_load_async_co (TrackerBusConnectionLoadAsyncData* data);
static TrackerSparqlCursor* tracker_bus_connection_real_statistics (TrackerSparqlConnection* base, GCancellable* cancellable, GError** error);
TrackerBusArrayCursor* tracker_bus_array_cursor_new (gchar** results, int results_length1, int results_length2, gint rows, gint cols, gchar** var_names, int var_names_length1, TrackerSparqlValueType* types, int types_length1);
TrackerBusArrayCursor* tracker_bus_array_cursor_construct (GType object_type, gchar** results, int results_length1, int results_length2, gint rows, gint cols, gchar** var_names, int var_names_length1, TrackerSparqlValueType* types, int types_length1);
GType tracker_bus_array_cursor_get_type (void) G_GNUC_CONST;
static void tracker_bus_connection_real_statistics_async_data_free (gpointer _data);
static void tracker_bus_connection_real_statistics_async (TrackerSparqlConnection* base, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void tracker_bus_connection_statistics_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static gboolean tracker_bus_connection_real_statistics_async_co (TrackerBusConnectionStatisticsAsyncData* data);
static void tracker_bus_connection_finalize (GObject* obj);
TrackerSparqlConnection* module_init (void);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);

static const GDBusArgInfo _tracker_bus_resources_dbus_arg_info_load_uri = {-1, "uri", "s"};
static const GDBusArgInfo * const _tracker_bus_resources_dbus_arg_info_load_in[] = {&_tracker_bus_resources_dbus_arg_info_load_uri, NULL};
static const GDBusArgInfo * const _tracker_bus_resources_dbus_arg_info_load_out[] = {NULL};
static const GDBusMethodInfo _tracker_bus_resources_dbus_method_info_load = {-1, "Load", (GDBusArgInfo **) (&_tracker_bus_resources_dbus_arg_info_load_in), (GDBusArgInfo **) (&_tracker_bus_resources_dbus_arg_info_load_out)};
static const GDBusArgInfo _tracker_bus_resources_dbus_arg_info_load_async_uri = {-1, "uri", "s"};
static const GDBusArgInfo * const _tracker_bus_resources_dbus_arg_info_load_async_in[] = {&_tracker_bus_resources_dbus_arg_info_load_async_uri, NULL};
static const GDBusArgInfo * const _tracker_bus_resources_dbus_arg_info_load_async_out[] = {NULL};
static const GDBusMethodInfo _tracker_bus_resources_dbus_method_info_load_async = {-1, "Load", (GDBusArgInfo **) (&_tracker_bus_resources_dbus_arg_info_load_async_in), (GDBusArgInfo **) (&_tracker_bus_resources_dbus_arg_info_load_async_out)};
static const GDBusMethodInfo * const _tracker_bus_resources_dbus_method_info[] = {&_tracker_bus_resources_dbus_method_info_load, &_tracker_bus_resources_dbus_method_info_load_async, NULL};
static const GDBusSignalInfo * const _tracker_bus_resources_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _tracker_bus_resources_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _tracker_bus_resources_dbus_interface_info = {-1, "org.freedesktop.Tracker1.Resources", (GDBusMethodInfo **) (&_tracker_bus_resources_dbus_method_info), (GDBusSignalInfo **) (&_tracker_bus_resources_dbus_signal_info), (GDBusPropertyInfo **) (&_tracker_bus_resources_dbus_property_info)};
static const GDBusInterfaceVTable _tracker_bus_resources_dbus_interface_vtable = {tracker_bus_resources_dbus_interface_method_call, tracker_bus_resources_dbus_interface_get_property, tracker_bus_resources_dbus_interface_set_property};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_query_query = {-1, "query", "s"};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_query_result_stream = {-1, "result_stream", "h"};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_query_result = {-1, "result", "as"};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_query_in[] = {&_tracker_bus_steroids_dbus_arg_info_query_query, &_tracker_bus_steroids_dbus_arg_info_query_result_stream, NULL};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_query_out[] = {&_tracker_bus_steroids_dbus_arg_info_query_result, NULL};
static const GDBusMethodInfo _tracker_bus_steroids_dbus_method_info_query = {-1, "Query", (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_query_in), (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_query_out)};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_update_sparql_stream = {-1, "sparql_stream", "h"};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_update_in[] = {&_tracker_bus_steroids_dbus_arg_info_update_sparql_stream, NULL};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_update_out[] = {NULL};
static const GDBusMethodInfo _tracker_bus_steroids_dbus_method_info_update = {-1, "Update", (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_update_in), (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_update_out)};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_update_blank_sparql_stream = {-1, "sparql_stream", "h"};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_update_blank_result = {-1, "result", "aaa{ss}"};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_update_blank_in[] = {&_tracker_bus_steroids_dbus_arg_info_update_blank_sparql_stream, NULL};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_update_blank_out[] = {&_tracker_bus_steroids_dbus_arg_info_update_blank_result, NULL};
static const GDBusMethodInfo _tracker_bus_steroids_dbus_method_info_update_blank = {-1, "UpdateBlank", (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_update_blank_in), (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_update_blank_out)};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_batch_update_sparql_stream = {-1, "sparql_stream", "h"};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_batch_update_in[] = {&_tracker_bus_steroids_dbus_arg_info_batch_update_sparql_stream, NULL};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_batch_update_out[] = {NULL};
static const GDBusMethodInfo _tracker_bus_steroids_dbus_method_info_batch_update = {-1, "BatchUpdate", (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_batch_update_in), (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_batch_update_out)};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_update_array_sparql_stream = {-1, "sparql_stream", "h"};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_update_array_result = {-1, "result", "as"};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_update_array_in[] = {&_tracker_bus_steroids_dbus_arg_info_update_array_sparql_stream, NULL};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_update_array_out[] = {&_tracker_bus_steroids_dbus_arg_info_update_array_result, NULL};
static const GDBusMethodInfo _tracker_bus_steroids_dbus_method_info_update_array = {-1, "UpdateArray", (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_update_array_in), (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_update_array_out)};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_batch_update_array_sparql_stream = {-1, "sparql_stream", "h"};
static const GDBusArgInfo _tracker_bus_steroids_dbus_arg_info_batch_update_array_result = {-1, "result", "as"};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_batch_update_array_in[] = {&_tracker_bus_steroids_dbus_arg_info_batch_update_array_sparql_stream, NULL};
static const GDBusArgInfo * const _tracker_bus_steroids_dbus_arg_info_batch_update_array_out[] = {&_tracker_bus_steroids_dbus_arg_info_batch_update_array_result, NULL};
static const GDBusMethodInfo _tracker_bus_steroids_dbus_method_info_batch_update_array = {-1, "BatchUpdateArray", (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_batch_update_array_in), (GDBusArgInfo **) (&_tracker_bus_steroids_dbus_arg_info_batch_update_array_out)};
static const GDBusMethodInfo * const _tracker_bus_steroids_dbus_method_info[] = {&_tracker_bus_steroids_dbus_method_info_query, &_tracker_bus_steroids_dbus_method_info_update, &_tracker_bus_steroids_dbus_method_info_update_blank, &_tracker_bus_steroids_dbus_method_info_batch_update, &_tracker_bus_steroids_dbus_method_info_update_array, &_tracker_bus_steroids_dbus_method_info_batch_update_array, NULL};
static const GDBusSignalInfo * const _tracker_bus_steroids_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _tracker_bus_steroids_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _tracker_bus_steroids_dbus_interface_info = {-1, "org.freedesktop.Tracker1.Steroids", (GDBusMethodInfo **) (&_tracker_bus_steroids_dbus_method_info), (GDBusSignalInfo **) (&_tracker_bus_steroids_dbus_signal_info), (GDBusPropertyInfo **) (&_tracker_bus_steroids_dbus_property_info)};
static const GDBusInterfaceVTable _tracker_bus_steroids_dbus_interface_vtable = {tracker_bus_steroids_dbus_interface_method_call, tracker_bus_steroids_dbus_interface_get_property, tracker_bus_steroids_dbus_interface_set_property};
static const GDBusArgInfo _tracker_bus_statistics_dbus_arg_info_Get_result = {-1, "result", "aas"};
static const GDBusArgInfo * const _tracker_bus_statistics_dbus_arg_info_Get_in[] = {NULL};
static const GDBusArgInfo * const _tracker_bus_statistics_dbus_arg_info_Get_out[] = {&_tracker_bus_statistics_dbus_arg_info_Get_result, NULL};
static const GDBusMethodInfo _tracker_bus_statistics_dbus_method_info_Get = {-1, "Get", (GDBusArgInfo **) (&_tracker_bus_statistics_dbus_arg_info_Get_in), (GDBusArgInfo **) (&_tracker_bus_statistics_dbus_arg_info_Get_out)};
static const GDBusArgInfo _tracker_bus_statistics_dbus_arg_info_Get_async_result = {-1, "result", "aas"};
static const GDBusArgInfo * const _tracker_bus_statistics_dbus_arg_info_Get_async_in[] = {NULL};
static const GDBusArgInfo * const _tracker_bus_statistics_dbus_arg_info_Get_async_out[] = {&_tracker_bus_statistics_dbus_arg_info_Get_async_result, NULL};
static const GDBusMethodInfo _tracker_bus_statistics_dbus_method_info_Get_async = {-1, "Get_async", (GDBusArgInfo **) (&_tracker_bus_statistics_dbus_arg_info_Get_async_in), (GDBusArgInfo **) (&_tracker_bus_statistics_dbus_arg_info_Get_async_out)};
static const GDBusMethodInfo * const _tracker_bus_statistics_dbus_method_info[] = {&_tracker_bus_statistics_dbus_method_info_Get, &_tracker_bus_statistics_dbus_method_info_Get_async, NULL};
static const GDBusSignalInfo * const _tracker_bus_statistics_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _tracker_bus_statistics_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _tracker_bus_statistics_dbus_interface_info = {-1, "org.freedesktop.Tracker1.Statistics", (GDBusMethodInfo **) (&_tracker_bus_statistics_dbus_method_info), (GDBusSignalInfo **) (&_tracker_bus_statistics_dbus_signal_info), (GDBusPropertyInfo **) (&_tracker_bus_statistics_dbus_property_info)};
static const GDBusInterfaceVTable _tracker_bus_statistics_dbus_interface_vtable = {tracker_bus_statistics_dbus_interface_method_call, tracker_bus_statistics_dbus_interface_get_property, tracker_bus_statistics_dbus_interface_set_property};

void tracker_bus_resources_real_load (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GError** error) {
	g_return_if_fail (self != NULL);
	g_critical ("Type `%s' does not implement abstract method `tracker_bus_resources_load'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
	return;
}


void tracker_bus_resources_load (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GError** error) {
	TRACKER_BUS_RESOURCES_GET_INTERFACE (self)->load (self, uri, cancellable, error);
}


void tracker_bus_resources_load_async (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TRACKER_BUS_RESOURCES_GET_INTERFACE (self)->load_async (self, uri, cancellable, _callback_, _user_data_);
}


void tracker_bus_resources_load_finish (TrackerBusResources* self, GAsyncResult* _res_, GError** error) {
	TRACKER_BUS_RESOURCES_GET_INTERFACE (self)->load_finish (self, _res_, error);
}


static void tracker_bus_resources_base_init (TrackerBusResourcesIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
		g_type_set_qdata (TRACKER_BUS_TYPE_RESOURCES, g_quark_from_static_string ("vala-dbus-register-object"), (void*) tracker_bus_resources_register_object);
	}
}


GType tracker_bus_resources_get_type (void) {
	static volatile gsize tracker_bus_resources_type_id__volatile = 0;
	if (g_once_init_enter (&tracker_bus_resources_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (TrackerBusResourcesIface), (GBaseInitFunc) tracker_bus_resources_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType tracker_bus_resources_type_id;
		tracker_bus_resources_type_id = g_type_register_static (G_TYPE_INTERFACE, "TrackerBusResources", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (tracker_bus_resources_type_id, G_TYPE_DBUS_PROXY);
		g_once_init_leave (&tracker_bus_resources_type_id__volatile, tracker_bus_resources_type_id);
	}
	return tracker_bus_resources_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (TrackerBusResourcesProxy, tracker_bus_resources_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (TRACKER_BUS_TYPE_RESOURCES, tracker_bus_resources_proxy_tracker_bus_resources_interface_init) );
static void tracker_bus_resources_proxy_class_init (TrackerBusResourcesProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = tracker_bus_resources_proxy_g_signal;
}


static void tracker_bus_resources_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
}


static void tracker_bus_resources_proxy_init (TrackerBusResourcesProxy* self) {
}


static void tracker_bus_resources_proxy_load (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	TRACKER_SPARQL_ERROR;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Resources", "Load");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (uri));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void _vala_g_async_ready_callback (GObject *source_object, GAsyncResult *res, void *user_data) {
	g_simple_async_result_set_op_res_gpointer (user_data, g_object_ref (res), g_object_unref);
	g_simple_async_result_complete (user_data);
	g_object_unref (user_data);
}


static void tracker_bus_resources_proxy_load_async_async (TrackerBusResources* self, const gchar* uri, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	TRACKER_SPARQL_ERROR;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Resources", "Load");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (uri));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, _vala_g_async_ready_callback, g_simple_async_result_new (self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static void tracker_bus_resources_proxy_load_async_finish (TrackerBusResources* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer (_res_), error);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void tracker_bus_resources_proxy_tracker_bus_resources_interface_init (TrackerBusResourcesIface* iface) {
	iface->load = tracker_bus_resources_proxy_load;
	iface->load_async = tracker_bus_resources_proxy_load_async_async;
	iface->load_finish = tracker_bus_resources_proxy_load_async_finish;
}


static void _dbus_tracker_bus_resources_load (TrackerBusResources* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error;
	GVariantIter _arguments_iter;
	gchar* uri = NULL;
	GVariant* _tmp0_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	error = NULL;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp0_ = g_variant_iter_next_value (&_arguments_iter);
	uri = g_variant_dup_string (_tmp0_, NULL);
	g_variant_unref (_tmp0_);
	tracker_bus_resources_load (self, uri, NULL, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (uri);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (_reply_message);
}


static void _dbus_tracker_bus_resources_load_async (TrackerBusResources* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* uri = NULL;
	GVariant* _tmp1_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp1_ = g_variant_iter_next_value (&_arguments_iter);
	uri = g_variant_dup_string (_tmp1_, NULL);
	g_variant_unref (_tmp1_);
	tracker_bus_resources_load_async (self, uri, NULL, (GAsyncReadyCallback) _dbus_tracker_bus_resources_load_async_ready, g_object_ref (invocation));
	_g_free0 (uri);
}


static void _dbus_tracker_bus_resources_load_async_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	invocation = _user_data_;
	error = NULL;
	tracker_bus_resources_load_finish ((TrackerBusResources*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void tracker_bus_resources_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "Load") == 0) {
		_dbus_tracker_bus_resources_load (object, parameters, invocation);
	} else if (strcmp (method_name, "Load") == 0) {
		_dbus_tracker_bus_resources_load_async (object, parameters, invocation);
	}
	g_object_unref (invocation);
}


static GVariant* tracker_bus_resources_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean tracker_bus_resources_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


guint tracker_bus_resources_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, &_tracker_bus_resources_dbus_interface_info, &_tracker_bus_resources_dbus_interface_vtable, data, _tracker_bus_resources_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _tracker_bus_resources_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


void tracker_bus_steroids_query (TrackerBusSteroids* self, const gchar* query, GUnixOutputStream* result_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->query (self, query, result_stream, cancellable, _callback_, _user_data_);
}


gchar** tracker_bus_steroids_query_finish (TrackerBusSteroids* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	return TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->query_finish (self, _res_, result_length1, error);
}


void tracker_bus_steroids_update (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->update (self, sparql_stream, cancellable, _callback_, _user_data_);
}


void tracker_bus_steroids_update_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->update_finish (self, _res_, error);
}


void tracker_bus_steroids_update_blank (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->update_blank (self, sparql_stream, cancellable, _callback_, _user_data_);
}


GVariant* tracker_bus_steroids_update_blank_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	return TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->update_blank_finish (self, _res_, error);
}


void tracker_bus_steroids_batch_update (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->batch_update (self, sparql_stream, cancellable, _callback_, _user_data_);
}


void tracker_bus_steroids_batch_update_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->batch_update_finish (self, _res_, error);
}


void tracker_bus_steroids_update_array (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->update_array (self, sparql_stream, cancellable, _callback_, _user_data_);
}


GVariant* tracker_bus_steroids_update_array_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	return TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->update_array_finish (self, _res_, error);
}


void tracker_bus_steroids_batch_update_array (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->batch_update_array (self, sparql_stream, cancellable, _callback_, _user_data_);
}


GVariant* tracker_bus_steroids_batch_update_array_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	return TRACKER_BUS_STEROIDS_GET_INTERFACE (self)->batch_update_array_finish (self, _res_, error);
}


void tracker_bus_steroids_update_begin (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, gint priority, GCancellable* cancellable, GAsyncReadyCallback callback, void* callback_target) {
	g_return_if_fail (sparql_stream != NULL);
	if (priority <= G_PRIORITY_DEFAULT) {
		tracker_bus_steroids_update (self, sparql_stream, cancellable, callback, callback_target);
	} else {
		tracker_bus_steroids_batch_update (self, sparql_stream, cancellable, callback, callback_target);
	}
}


void tracker_bus_steroids_update_array_begin (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, gint priority, GCancellable* cancellable, GAsyncReadyCallback callback, void* callback_target) {
	g_return_if_fail (sparql_stream != NULL);
	if (priority <= G_PRIORITY_DEFAULT) {
		tracker_bus_steroids_update_array (self, sparql_stream, cancellable, callback, callback_target);
	} else {
		tracker_bus_steroids_batch_update_array (self, sparql_stream, cancellable, callback, callback_target);
	}
}


static void tracker_bus_steroids_base_init (TrackerBusSteroidsIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
		g_type_set_qdata (TRACKER_BUS_TYPE_STEROIDS, g_quark_from_static_string ("vala-dbus-register-object"), (void*) tracker_bus_steroids_register_object);
	}
}


GType tracker_bus_steroids_get_type (void) {
	static volatile gsize tracker_bus_steroids_type_id__volatile = 0;
	if (g_once_init_enter (&tracker_bus_steroids_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (TrackerBusSteroidsIface), (GBaseInitFunc) tracker_bus_steroids_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType tracker_bus_steroids_type_id;
		tracker_bus_steroids_type_id = g_type_register_static (G_TYPE_INTERFACE, "TrackerBusSteroids", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (tracker_bus_steroids_type_id, G_TYPE_DBUS_PROXY);
		g_once_init_leave (&tracker_bus_steroids_type_id__volatile, tracker_bus_steroids_type_id);
	}
	return tracker_bus_steroids_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (TrackerBusSteroidsProxy, tracker_bus_steroids_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (TRACKER_BUS_TYPE_STEROIDS, tracker_bus_steroids_proxy_tracker_bus_steroids_interface_init) );
static void tracker_bus_steroids_proxy_class_init (TrackerBusSteroidsProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = tracker_bus_steroids_proxy_g_signal;
}


static void tracker_bus_steroids_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
}


static void tracker_bus_steroids_proxy_init (TrackerBusSteroidsProxy* self) {
}


static void tracker_bus_steroids_proxy_query_async (TrackerBusSteroids* self, const gchar* query, GUnixOutputStream* result_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GUnixFDList *_fd_list;
	TRACKER_SPARQL_ERROR;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Steroids", "Query");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (query));
	g_variant_builder_add (&_arguments_builder, "h", g_unix_fd_list_append (_fd_list, g_unix_output_stream_get_fd (result_stream), NULL));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_message_set_unix_fd_list (_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, _vala_g_async_ready_callback, g_simple_async_result_new (self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gchar** tracker_bus_steroids_proxy_query_finish (TrackerBusSteroids* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	GDBusMessage *_reply_message;
	gint _fd_index = 0;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	GVariant* _tmp2_;
	gchar** _tmp3_;
	int _tmp3__length;
	int _tmp3__size;
	int _tmp3__length1;
	GVariantIter _tmp4_;
	GVariant* _tmp5_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer (_res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp2_ = g_variant_iter_next_value (&_reply_iter);
	_tmp3_ = g_new (gchar*, 5);
	_tmp3__length = 0;
	_tmp3__size = 4;
	_tmp3__length1 = 0;
	g_variant_iter_init (&_tmp4_, _tmp2_);
	for (; _tmp5_ = g_variant_iter_next_value (&_tmp4_); _tmp3__length1++) {
		if (_tmp3__size == _tmp3__length) {
			_tmp3__size = 2 * _tmp3__size;
			_tmp3_ = g_renew (gchar*, _tmp3_, _tmp3__size + 1);
		}
		_tmp3_[_tmp3__length++] = g_variant_dup_string (_tmp5_, NULL);
		g_variant_unref (_tmp5_);
	}
	_result_length1 = _tmp3__length1;
	_tmp3_[_tmp3__length] = NULL;
	_result = _tmp3_;
	g_variant_unref (_tmp2_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static void tracker_bus_steroids_proxy_update_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GUnixFDList *_fd_list;
	TRACKER_SPARQL_ERROR;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Steroids", "Update");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	g_variant_builder_add (&_arguments_builder, "h", g_unix_fd_list_append (_fd_list, g_unix_input_stream_get_fd (sparql_stream), NULL));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_message_set_unix_fd_list (_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, _vala_g_async_ready_callback, g_simple_async_result_new (self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static void tracker_bus_steroids_proxy_update_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	gint _fd_index = 0;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer (_res_), error);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void tracker_bus_steroids_proxy_update_blank_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GUnixFDList *_fd_list;
	TRACKER_SPARQL_ERROR;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Steroids", "UpdateBlank");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	g_variant_builder_add (&_arguments_builder, "h", g_unix_fd_list_append (_fd_list, g_unix_input_stream_get_fd (sparql_stream), NULL));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_message_set_unix_fd_list (_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, _vala_g_async_ready_callback, g_simple_async_result_new (self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static GVariant* tracker_bus_steroids_proxy_update_blank_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	gint _fd_index = 0;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GVariant* _result;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer (_res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result = g_variant_iter_next_value (&_reply_iter);
	g_object_unref (_reply_message);
	return _result;
}


static void tracker_bus_steroids_proxy_batch_update_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GUnixFDList *_fd_list;
	TRACKER_SPARQL_ERROR;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Steroids", "BatchUpdate");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	g_variant_builder_add (&_arguments_builder, "h", g_unix_fd_list_append (_fd_list, g_unix_input_stream_get_fd (sparql_stream), NULL));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_message_set_unix_fd_list (_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, _vala_g_async_ready_callback, g_simple_async_result_new (self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static void tracker_bus_steroids_proxy_batch_update_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	gint _fd_index = 0;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer (_res_), error);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void tracker_bus_steroids_proxy_update_array_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GUnixFDList *_fd_list;
	TRACKER_SPARQL_ERROR;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Steroids", "UpdateArray");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	g_variant_builder_add (&_arguments_builder, "h", g_unix_fd_list_append (_fd_list, g_unix_input_stream_get_fd (sparql_stream), NULL));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_message_set_unix_fd_list (_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, _vala_g_async_ready_callback, g_simple_async_result_new (self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static GVariant* tracker_bus_steroids_proxy_update_array_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	gint _fd_index = 0;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GVariant* _result;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer (_res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result = g_variant_iter_next_value (&_reply_iter);
	g_object_unref (_reply_message);
	return _result;
}


static void tracker_bus_steroids_proxy_batch_update_array_async (TrackerBusSteroids* self, GUnixInputStream* sparql_stream, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GUnixFDList *_fd_list;
	TRACKER_SPARQL_ERROR;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Steroids", "BatchUpdateArray");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	g_variant_builder_add (&_arguments_builder, "h", g_unix_fd_list_append (_fd_list, g_unix_input_stream_get_fd (sparql_stream), NULL));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_message_set_unix_fd_list (_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, _vala_g_async_ready_callback, g_simple_async_result_new (self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static GVariant* tracker_bus_steroids_proxy_batch_update_array_finish (TrackerBusSteroids* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	gint _fd_index = 0;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GVariant* _result;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer (_res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result = g_variant_iter_next_value (&_reply_iter);
	g_object_unref (_reply_message);
	return _result;
}


static void tracker_bus_steroids_proxy_tracker_bus_steroids_interface_init (TrackerBusSteroidsIface* iface) {
	iface->query = tracker_bus_steroids_proxy_query_async;
	iface->query_finish = tracker_bus_steroids_proxy_query_finish;
	iface->update = tracker_bus_steroids_proxy_update_async;
	iface->update_finish = tracker_bus_steroids_proxy_update_finish;
	iface->update_blank = tracker_bus_steroids_proxy_update_blank_async;
	iface->update_blank_finish = tracker_bus_steroids_proxy_update_blank_finish;
	iface->batch_update = tracker_bus_steroids_proxy_batch_update_async;
	iface->batch_update_finish = tracker_bus_steroids_proxy_batch_update_finish;
	iface->update_array = tracker_bus_steroids_proxy_update_array_async;
	iface->update_array_finish = tracker_bus_steroids_proxy_update_array_finish;
	iface->batch_update_array = tracker_bus_steroids_proxy_batch_update_array_async;
	iface->batch_update_array_finish = tracker_bus_steroids_proxy_batch_update_array_finish;
}


static void _dbus_tracker_bus_steroids_query (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gint _fd_index = 0;
	gchar* query = NULL;
	GVariant* _tmp6_;
	GUnixOutputStream* result_stream = NULL;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp6_ = g_variant_iter_next_value (&_arguments_iter);
	query = g_variant_dup_string (_tmp6_, NULL);
	g_variant_unref (_tmp6_);
	g_variant_iter_next (&_arguments_iter, "h", &_fd_index);
	result_stream = (GUnixOutputStream *) g_unix_output_stream_new (g_unix_fd_list_get (g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)), _fd_index, NULL), TRUE);
	tracker_bus_steroids_query (self, query, result_stream, NULL, (GAsyncReadyCallback) _dbus_tracker_bus_steroids_query_ready, g_object_ref (invocation));
	_g_free0 (query);
	_g_object_unref0 (result_stream);
}


static void _dbus_tracker_bus_steroids_query_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GUnixFDList *_fd_list;
	gchar** result;
	int result_length1 = 0;
	gchar** _tmp7_;
	GVariantBuilder _tmp8_;
	int _tmp9_;
	invocation = _user_data_;
	error = NULL;
	result = tracker_bus_steroids_query_finish ((TrackerBusSteroids*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	_tmp7_ = result;
	g_variant_builder_init (&_tmp8_, G_VARIANT_TYPE ("as"));
	for (_tmp9_ = 0; _tmp9_ < result_length1; _tmp9_++) {
		g_variant_builder_add_value (&_tmp8_, g_variant_new_string (*_tmp7_));
		_tmp7_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp8_));
	result = (_vala_array_free (result,  result_length1, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_message_set_unix_fd_list (_reply_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_tracker_bus_steroids_update (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gint _fd_index = 0;
	GUnixInputStream* sparql_stream = NULL;
	g_variant_iter_init (&_arguments_iter, parameters);
	g_variant_iter_next (&_arguments_iter, "h", &_fd_index);
	sparql_stream = (GUnixInputStream *) g_unix_input_stream_new (g_unix_fd_list_get (g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)), _fd_index, NULL), TRUE);
	tracker_bus_steroids_update (self, sparql_stream, NULL, (GAsyncReadyCallback) _dbus_tracker_bus_steroids_update_ready, g_object_ref (invocation));
	_g_object_unref0 (sparql_stream);
}


static void _dbus_tracker_bus_steroids_update_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GUnixFDList *_fd_list;
	invocation = _user_data_;
	error = NULL;
	tracker_bus_steroids_update_finish ((TrackerBusSteroids*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_message_set_unix_fd_list (_reply_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_tracker_bus_steroids_update_blank (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gint _fd_index = 0;
	GUnixInputStream* sparql_stream = NULL;
	g_variant_iter_init (&_arguments_iter, parameters);
	g_variant_iter_next (&_arguments_iter, "h", &_fd_index);
	sparql_stream = (GUnixInputStream *) g_unix_input_stream_new (g_unix_fd_list_get (g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)), _fd_index, NULL), TRUE);
	tracker_bus_steroids_update_blank (self, sparql_stream, NULL, (GAsyncReadyCallback) _dbus_tracker_bus_steroids_update_blank_ready, g_object_ref (invocation));
	_g_object_unref0 (sparql_stream);
}


static void _dbus_tracker_bus_steroids_update_blank_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GUnixFDList *_fd_list;
	GVariant* result;
	invocation = _user_data_;
	error = NULL;
	result = tracker_bus_steroids_update_blank_finish ((TrackerBusSteroids*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	g_variant_builder_add_value (&_reply_builder, result);
	_g_variant_unref0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_message_set_unix_fd_list (_reply_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_tracker_bus_steroids_batch_update (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gint _fd_index = 0;
	GUnixInputStream* sparql_stream = NULL;
	g_variant_iter_init (&_arguments_iter, parameters);
	g_variant_iter_next (&_arguments_iter, "h", &_fd_index);
	sparql_stream = (GUnixInputStream *) g_unix_input_stream_new (g_unix_fd_list_get (g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)), _fd_index, NULL), TRUE);
	tracker_bus_steroids_batch_update (self, sparql_stream, NULL, (GAsyncReadyCallback) _dbus_tracker_bus_steroids_batch_update_ready, g_object_ref (invocation));
	_g_object_unref0 (sparql_stream);
}


static void _dbus_tracker_bus_steroids_batch_update_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GUnixFDList *_fd_list;
	invocation = _user_data_;
	error = NULL;
	tracker_bus_steroids_batch_update_finish ((TrackerBusSteroids*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_message_set_unix_fd_list (_reply_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_tracker_bus_steroids_update_array (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gint _fd_index = 0;
	GUnixInputStream* sparql_stream = NULL;
	g_variant_iter_init (&_arguments_iter, parameters);
	g_variant_iter_next (&_arguments_iter, "h", &_fd_index);
	sparql_stream = (GUnixInputStream *) g_unix_input_stream_new (g_unix_fd_list_get (g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)), _fd_index, NULL), TRUE);
	tracker_bus_steroids_update_array (self, sparql_stream, NULL, (GAsyncReadyCallback) _dbus_tracker_bus_steroids_update_array_ready, g_object_ref (invocation));
	_g_object_unref0 (sparql_stream);
}


static void _dbus_tracker_bus_steroids_update_array_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GUnixFDList *_fd_list;
	GVariant* result;
	invocation = _user_data_;
	error = NULL;
	result = tracker_bus_steroids_update_array_finish ((TrackerBusSteroids*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	g_variant_builder_add_value (&_reply_builder, result);
	_g_variant_unref0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_message_set_unix_fd_list (_reply_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_tracker_bus_steroids_batch_update_array (TrackerBusSteroids* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gint _fd_index = 0;
	GUnixInputStream* sparql_stream = NULL;
	g_variant_iter_init (&_arguments_iter, parameters);
	g_variant_iter_next (&_arguments_iter, "h", &_fd_index);
	sparql_stream = (GUnixInputStream *) g_unix_input_stream_new (g_unix_fd_list_get (g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)), _fd_index, NULL), TRUE);
	tracker_bus_steroids_batch_update_array (self, sparql_stream, NULL, (GAsyncReadyCallback) _dbus_tracker_bus_steroids_batch_update_array_ready, g_object_ref (invocation));
	_g_object_unref0 (sparql_stream);
}


static void _dbus_tracker_bus_steroids_batch_update_array_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GUnixFDList *_fd_list;
	GVariant* result;
	invocation = _user_data_;
	error = NULL;
	result = tracker_bus_steroids_batch_update_array_finish ((TrackerBusSteroids*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_fd_list = g_unix_fd_list_new ();
	g_variant_builder_add_value (&_reply_builder, result);
	_g_variant_unref0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_message_set_unix_fd_list (_reply_message, _fd_list);
	g_object_unref (_fd_list);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void tracker_bus_steroids_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "Query") == 0) {
		_dbus_tracker_bus_steroids_query (object, parameters, invocation);
	} else if (strcmp (method_name, "Update") == 0) {
		_dbus_tracker_bus_steroids_update (object, parameters, invocation);
	} else if (strcmp (method_name, "UpdateBlank") == 0) {
		_dbus_tracker_bus_steroids_update_blank (object, parameters, invocation);
	} else if (strcmp (method_name, "BatchUpdate") == 0) {
		_dbus_tracker_bus_steroids_batch_update (object, parameters, invocation);
	} else if (strcmp (method_name, "UpdateArray") == 0) {
		_dbus_tracker_bus_steroids_update_array (object, parameters, invocation);
	} else if (strcmp (method_name, "BatchUpdateArray") == 0) {
		_dbus_tracker_bus_steroids_batch_update_array (object, parameters, invocation);
	}
	g_object_unref (invocation);
}


static GVariant* tracker_bus_steroids_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean tracker_bus_steroids_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


guint tracker_bus_steroids_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, &_tracker_bus_steroids_dbus_interface_info, &_tracker_bus_steroids_dbus_interface_vtable, data, _tracker_bus_steroids_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _tracker_bus_steroids_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


gchar** tracker_bus_statistics_real_Get (TrackerBusStatistics* self, GCancellable* cancellable, int* result_length1, int* result_length2, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	g_critical ("Type `%s' does not implement abstract method `tracker_bus_statistics_Get'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
	return NULL;
}


gchar** tracker_bus_statistics_Get (TrackerBusStatistics* self, GCancellable* cancellable, int* result_length1, int* result_length2, GError** error) {
	return TRACKER_BUS_STATISTICS_GET_INTERFACE (self)->Get (self, cancellable, result_length1, result_length2, error);
}


void tracker_bus_statistics_Get_async (TrackerBusStatistics* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TRACKER_BUS_STATISTICS_GET_INTERFACE (self)->Get_async (self, cancellable, _callback_, _user_data_);
}


gchar** tracker_bus_statistics_Get_finish (TrackerBusStatistics* self, GAsyncResult* _res_, int* result_length1, int* result_length2, GError** error) {
	return TRACKER_BUS_STATISTICS_GET_INTERFACE (self)->Get_finish (self, _res_, result_length1, result_length2, error);
}


static void tracker_bus_statistics_base_init (TrackerBusStatisticsIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
		g_type_set_qdata (TRACKER_BUS_TYPE_STATISTICS, g_quark_from_static_string ("vala-dbus-register-object"), (void*) tracker_bus_statistics_register_object);
	}
}


GType tracker_bus_statistics_get_type (void) {
	static volatile gsize tracker_bus_statistics_type_id__volatile = 0;
	if (g_once_init_enter (&tracker_bus_statistics_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (TrackerBusStatisticsIface), (GBaseInitFunc) tracker_bus_statistics_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType tracker_bus_statistics_type_id;
		tracker_bus_statistics_type_id = g_type_register_static (G_TYPE_INTERFACE, "TrackerBusStatistics", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (tracker_bus_statistics_type_id, G_TYPE_DBUS_PROXY);
		g_once_init_leave (&tracker_bus_statistics_type_id__volatile, tracker_bus_statistics_type_id);
	}
	return tracker_bus_statistics_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (TrackerBusStatisticsProxy, tracker_bus_statistics_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (TRACKER_BUS_TYPE_STATISTICS, tracker_bus_statistics_proxy_tracker_bus_statistics_interface_init) );
static void tracker_bus_statistics_proxy_class_init (TrackerBusStatisticsProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = tracker_bus_statistics_proxy_g_signal;
}


static void tracker_bus_statistics_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
}


static void tracker_bus_statistics_proxy_init (TrackerBusStatisticsProxy* self) {
}


static gchar** tracker_bus_statistics_proxy_Get (TrackerBusStatistics* self, GCancellable* cancellable, int* result_length1, int* result_length2, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	int _result_length2;
	GVariant* _tmp10_;
	gchar** _tmp11_;
	int _tmp11__length;
	int _tmp11__size;
	int _tmp11__length1;
	GVariantIter _tmp12_;
	GVariant* _tmp13_;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Statistics", "Get");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_result_length2 = 0;
	_tmp10_ = g_variant_iter_next_value (&_reply_iter);
	_tmp11_ = g_new (gchar*, 5);
	_tmp11__length = 0;
	_tmp11__size = 4;
	_tmp11__length1 = 0;
	g_variant_iter_init (&_tmp12_, _tmp10_);
	for (; _tmp13_ = g_variant_iter_next_value (&_tmp12_); _tmp11__length1++) {
		int _tmp11__length2;
		GVariantIter _tmp14_;
		GVariant* _tmp15_;
		_tmp11__length2 = 0;
		g_variant_iter_init (&_tmp14_, _tmp13_);
		for (; _tmp15_ = g_variant_iter_next_value (&_tmp14_); _tmp11__length2++) {
			if (_tmp11__size == _tmp11__length) {
				_tmp11__size = 2 * _tmp11__size;
				_tmp11_ = g_renew (gchar*, _tmp11_, _tmp11__size + 1);
			}
			_tmp11_[_tmp11__length++] = g_variant_dup_string (_tmp15_, NULL);
			g_variant_unref (_tmp15_);
		}
		_result_length2 = _tmp11__length2;
		g_variant_unref (_tmp13_);
	}
	_result_length1 = _tmp11__length1;
	_tmp11_[_tmp11__length] = NULL;
	_result = _tmp11_;
	g_variant_unref (_tmp10_);
	*result_length1 = _result_length1;
	*result_length2 = _result_length2;
	g_object_unref (_reply_message);
	return _result;
}


static void tracker_bus_statistics_proxy_Get_async_async (TrackerBusStatistics* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.Tracker1.Statistics", "Get_async");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, cancellable, _vala_g_async_ready_callback, g_simple_async_result_new (self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gchar** tracker_bus_statistics_proxy_Get_async_finish (TrackerBusStatistics* self, GAsyncResult* _res_, int* result_length1, int* result_length2, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	int _result_length2;
	GVariant* _tmp16_;
	gchar** _tmp17_;
	int _tmp17__length;
	int _tmp17__size;
	int _tmp17__length1;
	GVariantIter _tmp18_;
	GVariant* _tmp19_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer (_res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_result_length2 = 0;
	_tmp16_ = g_variant_iter_next_value (&_reply_iter);
	_tmp17_ = g_new (gchar*, 5);
	_tmp17__length = 0;
	_tmp17__size = 4;
	_tmp17__length1 = 0;
	g_variant_iter_init (&_tmp18_, _tmp16_);
	for (; _tmp19_ = g_variant_iter_next_value (&_tmp18_); _tmp17__length1++) {
		int _tmp17__length2;
		GVariantIter _tmp20_;
		GVariant* _tmp21_;
		_tmp17__length2 = 0;
		g_variant_iter_init (&_tmp20_, _tmp19_);
		for (; _tmp21_ = g_variant_iter_next_value (&_tmp20_); _tmp17__length2++) {
			if (_tmp17__size == _tmp17__length) {
				_tmp17__size = 2 * _tmp17__size;
				_tmp17_ = g_renew (gchar*, _tmp17_, _tmp17__size + 1);
			}
			_tmp17_[_tmp17__length++] = g_variant_dup_string (_tmp21_, NULL);
			g_variant_unref (_tmp21_);
		}
		_result_length2 = _tmp17__length2;
		g_variant_unref (_tmp19_);
	}
	_result_length1 = _tmp17__length1;
	_tmp17_[_tmp17__length] = NULL;
	_result = _tmp17_;
	g_variant_unref (_tmp16_);
	*result_length1 = _result_length1;
	*result_length2 = _result_length2;
	g_object_unref (_reply_message);
	return _result;
}


static void tracker_bus_statistics_proxy_tracker_bus_statistics_interface_init (TrackerBusStatisticsIface* iface) {
	iface->Get = tracker_bus_statistics_proxy_Get;
	iface->Get_async = tracker_bus_statistics_proxy_Get_async_async;
	iface->Get_finish = tracker_bus_statistics_proxy_Get_async_finish;
}


static void _dbus_tracker_bus_statistics_Get (TrackerBusStatistics* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	int result_length2 = 0;
	gchar** _tmp22_;
	GVariantBuilder _tmp23_;
	int _tmp24_;
	error = NULL;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = tracker_bus_statistics_Get (self, NULL, &result_length1, &result_length2, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp22_ = result;
	g_variant_builder_init (&_tmp23_, G_VARIANT_TYPE ("aas"));
	for (_tmp24_ = 0; _tmp24_ < result_length1; _tmp24_++) {
		GVariantBuilder _tmp25_;
		int _tmp26_;
		g_variant_builder_init (&_tmp25_, G_VARIANT_TYPE ("aas"));
		for (_tmp26_ = 0; _tmp26_ < result_length2; _tmp26_++) {
			g_variant_builder_add_value (&_tmp25_, g_variant_new_string (*_tmp22_));
			_tmp22_++;
		}
		g_variant_builder_add_value (&_tmp23_, g_variant_builder_end (&_tmp25_));
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp23_));
	result = (_vala_array_free (result,  result_length1 *  result_length2, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (_reply_message);
}


static void _dbus_tracker_bus_statistics_Get_async (TrackerBusStatistics* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	g_variant_iter_init (&_arguments_iter, parameters);
	tracker_bus_statistics_Get_async (self, NULL, (GAsyncReadyCallback) _dbus_tracker_bus_statistics_Get_async_ready, g_object_ref (invocation));
}


static void _dbus_tracker_bus_statistics_Get_async_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	int result_length2 = 0;
	gchar** _tmp27_;
	GVariantBuilder _tmp28_;
	int _tmp29_;
	invocation = _user_data_;
	error = NULL;
	result = tracker_bus_statistics_Get_finish ((TrackerBusStatistics*) source_object, _res_, &result_length1, &result_length2, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (g_object_ref (invocation), error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp27_ = result;
	g_variant_builder_init (&_tmp28_, G_VARIANT_TYPE ("aas"));
	for (_tmp29_ = 0; _tmp29_ < result_length1; _tmp29_++) {
		GVariantBuilder _tmp30_;
		int _tmp31_;
		g_variant_builder_init (&_tmp30_, G_VARIANT_TYPE ("aas"));
		for (_tmp31_ = 0; _tmp31_ < result_length2; _tmp31_++) {
			g_variant_builder_add_value (&_tmp30_, g_variant_new_string (*_tmp27_));
			_tmp27_++;
		}
		g_variant_builder_add_value (&_tmp28_, g_variant_builder_end (&_tmp30_));
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp28_));
	result = (_vala_array_free (result,  result_length1 *  result_length2, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void tracker_bus_statistics_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "Get") == 0) {
		_dbus_tracker_bus_statistics_Get (object, parameters, invocation);
	} else if (strcmp (method_name, "Get_async") == 0) {
		_dbus_tracker_bus_statistics_Get_async (object, parameters, invocation);
	}
	g_object_unref (invocation);
}


static GVariant* tracker_bus_statistics_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean tracker_bus_statistics_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


guint tracker_bus_statistics_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, &_tracker_bus_statistics_dbus_interface_info, &_tracker_bus_statistics_dbus_interface_vtable, data, _tracker_bus_statistics_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _tracker_bus_statistics_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


TrackerBusConnection* tracker_bus_connection_construct (GType object_type, GError** error) {
	TrackerBusConnection * self = NULL;
	TrackerBusResources* _tmp0_;
	TrackerBusResources* _tmp1_;
	TrackerBusSteroids* _tmp2_;
	TrackerBusSteroids* _tmp3_;
	TrackerBusStatistics* _tmp4_;
	TrackerBusStatistics* _tmp5_;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (!tracker_bus_connection_initialized, NULL);
	self = (TrackerBusConnection*) tracker_sparql_connection_construct (object_type);
	_tmp0_ = (TrackerBusResources*) g_initable_new (TRACKER_BUS_TYPE_RESOURCES_PROXY, NULL, &_inner_error_, "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, "g-name", TRACKER_DBUS_SERVICE, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", TRACKER_DBUS_OBJECT_RESOURCES, "g-interface-name", "org.freedesktop.Tracker1.Resources", NULL);
	if (_inner_error_ != NULL) {
		if (((_inner_error_->domain == TRACKER_SPARQL_ERROR) || (_inner_error_->domain == G_IO_ERROR)) || (_inner_error_->domain == G_DBUS_ERROR)) {
			g_propagate_error (error, _inner_error_);
			_g_object_unref0 (self);
			return NULL;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
	}
	_tmp1_ = _tmp0_;
	_g_object_unref0 (tracker_bus_connection_resources_object);
	tracker_bus_connection_resources_object = _tmp1_;
	g_dbus_proxy_set_default_timeout ((GDBusProxy*) tracker_bus_connection_resources_object, G_MAXINT);
	_tmp2_ = (TrackerBusSteroids*) g_initable_new (TRACKER_BUS_TYPE_STEROIDS_PROXY, NULL, &_inner_error_, "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, "g-name", TRACKER_DBUS_SERVICE, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", TRACKER_DBUS_OBJECT_STEROIDS, "g-interface-name", "org.freedesktop.Tracker1.Steroids", NULL);
	if (_inner_error_ != NULL) {
		if (((_inner_error_->domain == TRACKER_SPARQL_ERROR) || (_inner_error_->domain == G_IO_ERROR)) || (_inner_error_->domain == G_DBUS_ERROR)) {
			g_propagate_error (error, _inner_error_);
			_g_object_unref0 (self);
			return NULL;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
	}
	_tmp3_ = _tmp2_;
	_g_object_unref0 (tracker_bus_connection_steroids_object);
	tracker_bus_connection_steroids_object = _tmp3_;
	g_dbus_proxy_set_default_timeout ((GDBusProxy*) tracker_bus_connection_steroids_object, G_MAXINT);
	_tmp4_ = (TrackerBusStatistics*) g_initable_new (TRACKER_BUS_TYPE_STATISTICS_PROXY, NULL, &_inner_error_, "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, "g-name", TRACKER_DBUS_SERVICE, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", TRACKER_DBUS_OBJECT_STATISTICS, "g-interface-name", "org.freedesktop.Tracker1.Statistics", NULL);
	if (_inner_error_ != NULL) {
		if (((_inner_error_->domain == TRACKER_SPARQL_ERROR) || (_inner_error_->domain == G_IO_ERROR)) || (_inner_error_->domain == G_DBUS_ERROR)) {
			g_propagate_error (error, _inner_error_);
			_g_object_unref0 (self);
			return NULL;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
	}
	_tmp5_ = _tmp4_;
	_g_object_unref0 (tracker_bus_connection_statistics_object);
	tracker_bus_connection_statistics_object = _tmp5_;
	tracker_bus_connection_initialized = TRUE;
	return self;
}


TrackerBusConnection* tracker_bus_connection_new (GError** error) {
	return tracker_bus_connection_construct (TRACKER_BUS_TYPE_CONNECTION, error);
}


static void tracker_bus_connection_pipe (TrackerBusConnection* self, GUnixInputStream** input, GUnixOutputStream** output, GError** error) {
	GUnixInputStream* _input = NULL;
	GUnixOutputStream* _output = NULL;
	gint pipefd[2] = {0};
	gint _tmp0_;
	GUnixInputStream* _tmp2_ = NULL;
	GUnixInputStream* _tmp3_;
	GUnixOutputStream* _tmp4_ = NULL;
	GUnixOutputStream* _tmp5_;
	GError * _inner_error_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = pipe (pipefd);
	if (_tmp0_ < 0) {
		GError* _tmp1_ = NULL;
		_tmp1_ = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED, "Pipe creation failed");
		_inner_error_ = _tmp1_;
		if (_inner_error_->domain == G_IO_ERROR) {
			g_propagate_error (error, _inner_error_);
			return;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return;
		}
	}
	_tmp2_ = (GUnixInputStream*) g_unix_input_stream_new (pipefd[0], TRUE);
	_tmp3_ = _tmp2_;
	_g_object_unref0 (_input);
	_input = _tmp3_;
	_tmp4_ = (GUnixOutputStream*) g_unix_output_stream_new (pipefd[1], TRUE);
	_tmp5_ = _tmp4_;
	_g_object_unref0 (_output);
	_output = _tmp5_;
	if (input) {
		*input = _input;
	} else {
		_g_object_unref0 (_input);
	}
	if (output) {
		*output = _output;
	} else {
		_g_object_unref0 (_output);
	}
}


static Block1Data* block1_data_ref (Block1Data* _data1_) {
	g_atomic_int_inc (&_data1_->_ref_count_);
	return _data1_;
}


static void block1_data_unref (Block1Data* _data1_) {
	if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
		_g_object_unref0 (_data1_->self);
		_g_object_unref0 (_data1_->async_res);
		_g_main_loop_unref0 (_data1_->loop);
		g_slice_free (Block1Data, _data1_);
	}
}


static gpointer _g_object_ref0 (gpointer self) {
	return self ? g_object_ref (self) : NULL;
}


static void _lambda1_ (GObject* o, GAsyncResult* res, Block1Data* _data1_) {
	TrackerBusConnection * self;
	GAsyncResult* _tmp0_;
	GAsyncResult* _tmp1_;
	self = _data1_->self;
	g_return_if_fail (res != NULL);
	_tmp0_ = _g_object_ref0 (res);
	_tmp1_ = _tmp0_;
	_g_object_unref0 (_data1_->async_res);
	_data1_->async_res = _tmp1_;
	g_main_loop_quit (_data1_->loop);
}


static void __lambda1__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	_lambda1_ (source_object, res, self);
	block1_data_unref (self);
}


static TrackerSparqlCursor* tracker_bus_connection_real_query (TrackerSparqlConnection* base, const gchar* sparql, GCancellable* cancellable, GError** error) {
	TrackerBusConnection * self;
	TrackerSparqlCursor* result = NULL;
	Block1Data* _data1_;
	GMainContext* _tmp0_ = NULL;
	GMainContext* context;
	GMainLoop* _tmp1_ = NULL;
	TrackerSparqlCursor* _tmp2_ = NULL;
	TrackerSparqlCursor* _tmp3_;
	GError * _inner_error_ = NULL;
	self = (TrackerBusConnection*) base;
	g_return_val_if_fail (sparql != NULL, NULL);
	_data1_ = g_slice_new0 (Block1Data);
	_data1_->_ref_count_ = 1;
	_data1_->self = g_object_ref (self);
	_tmp0_ = g_main_context_new ();
	context = _tmp0_;
	_tmp1_ = g_main_loop_new (context, FALSE);
	_data1_->loop = _tmp1_;
	g_main_context_push_thread_default (context);
	_data1_->async_res = NULL;
	tracker_sparql_connection_query_async ((TrackerSparqlConnection*) self, sparql, cancellable, __lambda1__gasync_ready_callback, block1_data_ref (_data1_));
	g_main_loop_run (_data1_->loop);
	g_main_context_pop_thread_default (context);
	_tmp2_ = tracker_sparql_connection_query_finish ((TrackerSparqlConnection*) self, _data1_->async_res, &_inner_error_);
	_tmp3_ = _tmp2_;
	if (_inner_error_ != NULL) {
		if (((_inner_error_->domain == TRACKER_SPARQL_ERROR) || (_inner_error_->domain == G_IO_ERROR)) || (_inner_error_->domain == G_DBUS_ERROR)) {
			g_propagate_error (error, _inner_error_);
			_g_main_context_unref0 (context);
			block1_data_unref (_data1_);
			return NULL;
		} else {
			_g_main_context_unref0 (context);
			block1_data_unref (_data1_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
	}
	result = _tmp3_;
	_g_main_context_unref0 (context);
	block1_data_unref (_data1_);
	return result;
}


static void tracker_bus_connection_real_query_async_data_free (gpointer _data) {
	TrackerBusConnectionQueryAsyncData* data;
	data = _data;
	_g_free0 (data->sparql);
	_g_object_unref0 (data->cancellable);
	_g_object_unref0 (data->result);
	_g_object_unref0 (data->self);
	g_slice_free (TrackerBusConnectionQueryAsyncData, data);
}


static void tracker_bus_connection_real_query_async (TrackerSparqlConnection* base, const gchar* sparql, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TrackerBusConnection * self;
	TrackerBusConnectionQueryAsyncData* _data_;
	self = (TrackerBusConnection*) base;
	_data_ = g_slice_new0 (TrackerBusConnectionQueryAsyncData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, tracker_bus_connection_real_query_async);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, tracker_bus_connection_real_query_async_data_free);
	_data_->self = _g_object_ref0 (self);
	_data_->sparql = g_strdup (sparql);
	_data_->cancellable = _g_object_ref0 (cancellable);
	tracker_bus_connection_real_query_async_co (_data_);
}


static TrackerSparqlCursor* tracker_bus_connection_real_query_finish (TrackerSparqlConnection* base, GAsyncResult* _res_, GError** error) {
	TrackerSparqlCursor* result;
	TrackerBusConnectionQueryAsyncData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void tracker_bus_connection_query_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	TrackerBusConnectionQueryAsyncData* data;
	data = _user_data_;
	data->_source_object_ = source_object;
	data->_res_ = _res_;
	tracker_bus_connection_real_query_async_co (data);
}


static Block2Data* block2_data_ref (Block2Data* _data2_) {
	g_atomic_int_inc (&_data2_->_ref_count_);
	return _data2_;
}


static void block2_data_unref (Block2Data* _data2_) {
	if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
		_g_object_unref0 (_data2_->self);
		_g_object_unref0 (_data2_->dbus_res);
		g_slice_free (Block2Data, _data2_);
	}
}


static void _lambda0_ (GObject* o, GAsyncResult* res, Block2Data* _data2_) {
	TrackerBusConnection * self;
	GAsyncResult* _tmp0_;
	GAsyncResult* _tmp1_;
	self = _data2_->self;
	g_return_if_fail (res != NULL);
	_tmp0_ = _g_object_ref0 (res);
	_tmp1_ = _tmp0_;
	_g_object_unref0 (_data2_->dbus_res);
	_data2_->dbus_res = _tmp1_;
	if (_data2_->received_result) {
		tracker_bus_connection_real_query_async_co (_data2_->_async_data_);
	}
}


static void __lambda0__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	_lambda0_ (source_object, res, self);
	block2_data_unref (self);
}


static void* _g_realloc_grealloc_func (void* data, gsize size) {
	void* result;
	result = g_realloc (data, size);
	return result;
}


static void _g_free_gdestroy_notify (void* data) {
	g_free (data);
}


static gboolean tracker_bus_connection_real_query_async_co (TrackerBusConnectionQueryAsyncData* data) {
	switch (data->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		case 2:
		goto _state_2;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	data->_data2_ = g_slice_new0 (Block2Data);
	data->_data2_->_ref_count_ = 1;
	data->_data2_->self = g_object_ref (data->self);
	data->_data2_->_async_data_ = data;
	data->_tmp0_ = NULL;
	data->_tmp1_ = NULL;
	tracker_bus_connection_pipe (data->self, &data->_tmp0_, &data->_tmp1_, &data->_inner_error_);
	_g_object_unref0 (data->input);
	data->input = data->_tmp0_;
	_g_object_unref0 (data->output);
	data->output = data->_tmp1_;
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block2_data_unref (data->_data2_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block2_data_unref (data->_data2_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->_data2_->dbus_res = NULL;
	data->_data2_->received_result = FALSE;
	tracker_bus_steroids_query (tracker_bus_connection_steroids_object, data->sparql, data->output, data->cancellable, __lambda0__gasync_ready_callback, block2_data_ref (data->_data2_));
	data->_tmp2_ = NULL;
	_g_object_unref0 (data->output);
	data->output = data->_tmp2_;
	data->_tmp3_ = NULL;
	data->_tmp3_ = (GMemoryOutputStream*) g_memory_output_stream_new (NULL, 0, _g_realloc_grealloc_func, _g_free_gdestroy_notify);
	data->mem_stream = data->_tmp3_;
	data->_state_ = 1;
	g_output_stream_splice_async ((GOutputStream*) data->mem_stream, (GInputStream*) data->input, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, G_PRIORITY_DEFAULT, data->cancellable, tracker_bus_connection_query_async_ready, data);
	return FALSE;
	_state_1:
	g_output_stream_splice_finish ((GOutputStream*) data->mem_stream, data->_res_, &data->_inner_error_);
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->mem_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block2_data_unref (data->_data2_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->mem_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block2_data_unref (data->_data2_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->_data2_->received_result = TRUE;
	if (data->_data2_->dbus_res == NULL) {
		data->_state_ = 2;
		return FALSE;
		_state_2:
		;
	}
	data->_tmp5_ = NULL;
	data->_tmp5_ = tracker_bus_steroids_query_finish (tracker_bus_connection_steroids_object, data->_data2_->dbus_res, &data->_tmp4_, &data->_inner_error_);
	data->_tmp6_ = data->_tmp5_;
	data->variable_names_length1 = data->_tmp4_;
	data->_variable_names_size_ = data->variable_names_length1;
	data->variable_names = data->_tmp6_;
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->mem_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block2_data_unref (data->_data2_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->mem_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block2_data_unref (data->_data2_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	g_output_stream_close ((GOutputStream*) data->mem_stream, NULL, &data->_inner_error_);
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			data->variable_names = (_vala_array_free (data->variable_names, data->variable_names_length1, (GDestroyNotify) g_free), NULL);
			_g_object_unref0 (data->mem_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block2_data_unref (data->_data2_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			data->variable_names = (_vala_array_free (data->variable_names, data->variable_names_length1, (GDestroyNotify) g_free), NULL);
			_g_object_unref0 (data->mem_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block2_data_unref (data->_data2_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->_tmp7_ = NULL;
	data->_tmp7_ = g_memory_output_stream_steal_data (data->mem_stream);
	data->_tmp8_ = g_memory_output_stream_get_data_size (data->mem_stream);
	data->_tmp9_ = NULL;
	data->_tmp9_ = tracker_bus_fd_cursor_new (data->_tmp7_, data->_tmp8_, data->variable_names, data->variable_names_length1);
	data->result = (TrackerSparqlCursor*) data->_tmp9_;
	data->variable_names = (_vala_array_free (data->variable_names, data->variable_names_length1, (GDestroyNotify) g_free), NULL);
	_g_object_unref0 (data->mem_stream);
	_g_object_unref0 (data->output);
	_g_object_unref0 (data->input);
	block2_data_unref (data->_data2_);
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
	data->variable_names = (_vala_array_free (data->variable_names, data->variable_names_length1, (GDestroyNotify) g_free), NULL);
	_g_object_unref0 (data->mem_stream);
	_g_object_unref0 (data->output);
	_g_object_unref0 (data->input);
	block2_data_unref (data->_data2_);
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
}


static Block3Data* block3_data_ref (Block3Data* _data3_) {
	g_atomic_int_inc (&_data3_->_ref_count_);
	return _data3_;
}


static void block3_data_unref (Block3Data* _data3_) {
	if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
		_g_object_unref0 (_data3_->self);
		_g_object_unref0 (_data3_->async_res);
		_g_main_loop_unref0 (_data3_->loop);
		g_slice_free (Block3Data, _data3_);
	}
}


static void _lambda3_ (GObject* o, GAsyncResult* res, Block3Data* _data3_) {
	TrackerBusConnection * self;
	GAsyncResult* _tmp0_;
	GAsyncResult* _tmp1_;
	self = _data3_->self;
	g_return_if_fail (res != NULL);
	_tmp0_ = _g_object_ref0 (res);
	_tmp1_ = _tmp0_;
	_g_object_unref0 (_data3_->async_res);
	_data3_->async_res = _tmp1_;
	g_main_loop_quit (_data3_->loop);
}


static void __lambda3__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	_lambda3_ (source_object, res, self);
	block3_data_unref (self);
}


static void tracker_bus_connection_real_update (TrackerSparqlConnection* base, const gchar* sparql, gint priority, GCancellable* cancellable, GError** error) {
	TrackerBusConnection * self;
	Block3Data* _data3_;
	GMainContext* _tmp0_ = NULL;
	GMainContext* context;
	GMainLoop* _tmp1_ = NULL;
	GError * _inner_error_ = NULL;
	self = (TrackerBusConnection*) base;
	g_return_if_fail (sparql != NULL);
	_data3_ = g_slice_new0 (Block3Data);
	_data3_->_ref_count_ = 1;
	_data3_->self = g_object_ref (self);
	_tmp0_ = g_main_context_new ();
	context = _tmp0_;
	_tmp1_ = g_main_loop_new (context, FALSE);
	_data3_->loop = _tmp1_;
	g_main_context_push_thread_default (context);
	_data3_->async_res = NULL;
	tracker_sparql_connection_update_async ((TrackerSparqlConnection*) self, sparql, priority, cancellable, __lambda3__gasync_ready_callback, block3_data_ref (_data3_));
	g_main_loop_run (_data3_->loop);
	g_main_context_pop_thread_default (context);
	tracker_sparql_connection_update_finish ((TrackerSparqlConnection*) self, _data3_->async_res, &_inner_error_);
	if (_inner_error_ != NULL) {
		if (((_inner_error_->domain == TRACKER_SPARQL_ERROR) || (_inner_error_->domain == G_IO_ERROR)) || (_inner_error_->domain == G_DBUS_ERROR)) {
			g_propagate_error (error, _inner_error_);
			_g_main_context_unref0 (context);
			block3_data_unref (_data3_);
			return;
		} else {
			_g_main_context_unref0 (context);
			block3_data_unref (_data3_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return;
		}
	}
	_g_main_context_unref0 (context);
	block3_data_unref (_data3_);
}


static void tracker_bus_connection_real_update_async_data_free (gpointer _data) {
	TrackerBusConnectionUpdateAsyncData* data;
	data = _data;
	_g_free0 (data->sparql);
	_g_object_unref0 (data->cancellable);
	_g_object_unref0 (data->self);
	g_slice_free (TrackerBusConnectionUpdateAsyncData, data);
}


static void tracker_bus_connection_real_update_async (TrackerSparqlConnection* base, const gchar* sparql, gint priority, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TrackerBusConnection * self;
	TrackerBusConnectionUpdateAsyncData* _data_;
	self = (TrackerBusConnection*) base;
	_data_ = g_slice_new0 (TrackerBusConnectionUpdateAsyncData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, tracker_bus_connection_real_update_async);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, tracker_bus_connection_real_update_async_data_free);
	_data_->self = _g_object_ref0 (self);
	_data_->sparql = g_strdup (sparql);
	_data_->priority = priority;
	_data_->cancellable = _g_object_ref0 (cancellable);
	tracker_bus_connection_real_update_async_co (_data_);
}


static void tracker_bus_connection_real_update_finish (TrackerSparqlConnection* base, GAsyncResult* _res_, GError** error) {
	TrackerBusConnectionUpdateAsyncData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void tracker_bus_connection_update_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	TrackerBusConnectionUpdateAsyncData* data;
	data = _user_data_;
	data->_source_object_ = source_object;
	data->_res_ = _res_;
	tracker_bus_connection_real_update_async_co (data);
}


static Block4Data* block4_data_ref (Block4Data* _data4_) {
	g_atomic_int_inc (&_data4_->_ref_count_);
	return _data4_;
}


static void block4_data_unref (Block4Data* _data4_) {
	if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
		_g_object_unref0 (_data4_->self);
		_g_object_unref0 (_data4_->dbus_res);
		g_slice_free (Block4Data, _data4_);
	}
}


static void _lambda2_ (GObject* o, GAsyncResult* res, Block4Data* _data4_) {
	TrackerBusConnection * self;
	GAsyncResult* _tmp0_;
	GAsyncResult* _tmp1_;
	self = _data4_->self;
	g_return_if_fail (res != NULL);
	_tmp0_ = _g_object_ref0 (res);
	_tmp1_ = _tmp0_;
	_g_object_unref0 (_data4_->dbus_res);
	_data4_->dbus_res = _tmp1_;
	if (_data4_->sent_update) {
		tracker_bus_connection_real_update_async_co (_data4_->_async_data_);
	}
}


static void __lambda2__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	_lambda2_ (source_object, res, self);
}


static gboolean tracker_bus_connection_real_update_async_co (TrackerBusConnectionUpdateAsyncData* data) {
	switch (data->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	data->_data4_ = g_slice_new0 (Block4Data);
	data->_data4_->_ref_count_ = 1;
	data->_data4_->self = g_object_ref (data->self);
	data->_data4_->_async_data_ = data;
	data->_tmp0_ = NULL;
	data->_tmp1_ = NULL;
	tracker_bus_connection_pipe (data->self, &data->_tmp0_, &data->_tmp1_, &data->_inner_error_);
	_g_object_unref0 (data->input);
	data->input = data->_tmp0_;
	_g_object_unref0 (data->output);
	data->output = data->_tmp1_;
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block4_data_unref (data->_data4_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block4_data_unref (data->_data4_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->_data4_->dbus_res = NULL;
	data->_data4_->sent_update = FALSE;
	tracker_bus_steroids_update_begin (tracker_bus_connection_steroids_object, data->input, data->priority, data->cancellable, __lambda2__gasync_ready_callback, data->_data4_);
	data->_tmp2_ = NULL;
	data->_tmp2_ = g_data_output_stream_new ((GOutputStream*) data->output);
	data->data_stream = data->_tmp2_;
	g_data_output_stream_set_byte_order (data->data_stream, G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN);
	data->_tmp3_ = strlen (data->sparql);
	g_data_output_stream_put_int32 (data->data_stream, (gint32) data->_tmp3_, NULL, &data->_inner_error_);
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block4_data_unref (data->_data4_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block4_data_unref (data->_data4_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	g_data_output_stream_put_string (data->data_stream, data->sparql, NULL, &data->_inner_error_);
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block4_data_unref (data->_data4_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block4_data_unref (data->_data4_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->_tmp4_ = NULL;
	_g_object_unref0 (data->data_stream);
	data->data_stream = data->_tmp4_;
	data->_data4_->sent_update = TRUE;
	if (data->_data4_->dbus_res == NULL) {
		data->_state_ = 1;
		return FALSE;
		_state_1:
		;
	}
	if (data->priority <= G_PRIORITY_DEFAULT) {
		tracker_bus_steroids_update_finish (tracker_bus_connection_steroids_object, data->_data4_->dbus_res, &data->_inner_error_);
		if (data->_inner_error_ != NULL) {
			if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
				g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
				g_error_free (data->_inner_error_);
				_g_object_unref0 (data->data_stream);
				_g_object_unref0 (data->output);
				_g_object_unref0 (data->input);
				block4_data_unref (data->_data4_);
				if (data->_state_ == 0) {
					g_simple_async_result_complete_in_idle (data->_async_result);
				} else {
					g_simple_async_result_complete (data->_async_result);
				}
				g_object_unref (data->_async_result);
				return FALSE;
			} else {
				_g_object_unref0 (data->data_stream);
				_g_object_unref0 (data->output);
				_g_object_unref0 (data->input);
				block4_data_unref (data->_data4_);
				g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
				g_clear_error (&data->_inner_error_);
				return FALSE;
			}
		}
	} else {
		tracker_bus_steroids_batch_update_finish (tracker_bus_connection_steroids_object, data->_data4_->dbus_res, &data->_inner_error_);
		if (data->_inner_error_ != NULL) {
			if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
				g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
				g_error_free (data->_inner_error_);
				_g_object_unref0 (data->data_stream);
				_g_object_unref0 (data->output);
				_g_object_unref0 (data->input);
				block4_data_unref (data->_data4_);
				if (data->_state_ == 0) {
					g_simple_async_result_complete_in_idle (data->_async_result);
				} else {
					g_simple_async_result_complete (data->_async_result);
				}
				g_object_unref (data->_async_result);
				return FALSE;
			} else {
				_g_object_unref0 (data->data_stream);
				_g_object_unref0 (data->output);
				_g_object_unref0 (data->input);
				block4_data_unref (data->_data4_);
				g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
				g_clear_error (&data->_inner_error_);
				return FALSE;
			}
		}
	}
	_g_object_unref0 (data->data_stream);
	_g_object_unref0 (data->output);
	_g_object_unref0 (data->input);
	block4_data_unref (data->_data4_);
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
}


static void tracker_bus_connection_real_update_array_async_data_free (gpointer _data) {
	TrackerBusConnectionUpdateArrayAsyncData* data;
	data = _data;
	data->sparql = (_vala_array_free (data->sparql, data->sparql_length1, (GDestroyNotify) g_free), NULL);
	_g_object_unref0 (data->cancellable);
	_g_ptr_array_unref0 (data->result);
	_g_object_unref0 (data->self);
	g_slice_free (TrackerBusConnectionUpdateArrayAsyncData, data);
}


static gchar** _vala_array_dup1 (gchar** self, int length) {
	gchar** result;
	int i;
	result = g_new0 (gchar*, length + 1);
	for (i = 0; i < length; i++) {
		result[i] = g_strdup (self[i]);
	}
	return result;
}


static void tracker_bus_connection_real_update_array_async (TrackerSparqlConnection* base, gchar** sparql, int sparql_length1, gint priority, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TrackerBusConnection * self;
	TrackerBusConnectionUpdateArrayAsyncData* _data_;
	gchar** _tmp0_;
	self = (TrackerBusConnection*) base;
	_data_ = g_slice_new0 (TrackerBusConnectionUpdateArrayAsyncData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, tracker_bus_connection_real_update_array_async);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, tracker_bus_connection_real_update_array_async_data_free);
	_data_->self = _g_object_ref0 (self);
	_data_->sparql = (_tmp0_ = sparql, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup1 (_tmp0_, sparql_length1));
	_data_->sparql_length1 = sparql_length1;
	_data_->priority = priority;
	_data_->cancellable = _g_object_ref0 (cancellable);
	tracker_bus_connection_real_update_array_async_co (_data_);
}


static GPtrArray* tracker_bus_connection_real_update_array_finish (TrackerSparqlConnection* base, GAsyncResult* _res_, GError** error) {
	GPtrArray* result;
	TrackerBusConnectionUpdateArrayAsyncData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void tracker_bus_connection_update_array_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	TrackerBusConnectionUpdateArrayAsyncData* data;
	data = _user_data_;
	data->_source_object_ = source_object;
	data->_res_ = _res_;
	tracker_bus_connection_real_update_array_async_co (data);
}


static Block5Data* block5_data_ref (Block5Data* _data5_) {
	g_atomic_int_inc (&_data5_->_ref_count_);
	return _data5_;
}


static void block5_data_unref (Block5Data* _data5_) {
	if (g_atomic_int_dec_and_test (&_data5_->_ref_count_)) {
		_g_object_unref0 (_data5_->self);
		_g_object_unref0 (_data5_->dbus_res);
		g_slice_free (Block5Data, _data5_);
	}
}


static void _lambda4_ (GObject* o, GAsyncResult* res, Block5Data* _data5_) {
	TrackerBusConnection * self;
	GAsyncResult* _tmp0_;
	GAsyncResult* _tmp1_;
	self = _data5_->self;
	g_return_if_fail (res != NULL);
	_tmp0_ = _g_object_ref0 (res);
	_tmp1_ = _tmp0_;
	_g_object_unref0 (_data5_->dbus_res);
	_data5_->dbus_res = _tmp1_;
	if (_data5_->sent_update) {
		tracker_bus_connection_real_update_array_async_co (_data5_->_async_data_);
	}
}


static void __lambda4__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	_lambda4_ (source_object, res, self);
}


static void _g_error_free0_ (gpointer var) {
	(var == NULL) ? NULL : (var = (g_error_free (var), NULL));
}


static gboolean tracker_bus_connection_real_update_array_async_co (TrackerBusConnectionUpdateArrayAsyncData* data) {
	switch (data->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	data->_data5_ = g_slice_new0 (Block5Data);
	data->_data5_->_ref_count_ = 1;
	data->_data5_->self = g_object_ref (data->self);
	data->_data5_->_async_data_ = data;
	data->_tmp0_ = NULL;
	data->_tmp1_ = NULL;
	tracker_bus_connection_pipe (data->self, &data->_tmp0_, &data->_tmp1_, &data->_inner_error_);
	_g_object_unref0 (data->input);
	data->input = data->_tmp0_;
	_g_object_unref0 (data->output);
	data->output = data->_tmp1_;
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block5_data_unref (data->_data5_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block5_data_unref (data->_data5_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->_data5_->dbus_res = NULL;
	data->_data5_->sent_update = FALSE;
	tracker_bus_steroids_update_array_begin (tracker_bus_connection_steroids_object, data->input, data->priority, data->cancellable, __lambda4__gasync_ready_callback, data->_data5_);
	data->_tmp2_ = NULL;
	data->_tmp2_ = g_data_output_stream_new ((GOutputStream*) data->output);
	data->data_stream = data->_tmp2_;
	g_data_output_stream_set_byte_order (data->data_stream, G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN);
	g_data_output_stream_put_int32 (data->data_stream, (gint32) data->sparql_length1, NULL, &data->_inner_error_);
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block5_data_unref (data->_data5_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block5_data_unref (data->_data5_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	{
		data->i = 0;
		{
			data->_tmp3_ = TRUE;
			while (TRUE) {
				if (!data->_tmp3_) {
					data->i++;
				}
				data->_tmp3_ = FALSE;
				if (!(data->i < data->sparql_length1)) {
					break;
				}
				data->_tmp4_ = strlen (data->sparql[data->i]);
				g_data_output_stream_put_int32 (data->data_stream, (gint32) data->_tmp4_, NULL, &data->_inner_error_);
				if (data->_inner_error_ != NULL) {
					if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
						g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
						g_error_free (data->_inner_error_);
						_g_object_unref0 (data->data_stream);
						_g_object_unref0 (data->output);
						_g_object_unref0 (data->input);
						block5_data_unref (data->_data5_);
						if (data->_state_ == 0) {
							g_simple_async_result_complete_in_idle (data->_async_result);
						} else {
							g_simple_async_result_complete (data->_async_result);
						}
						g_object_unref (data->_async_result);
						return FALSE;
					} else {
						_g_object_unref0 (data->data_stream);
						_g_object_unref0 (data->output);
						_g_object_unref0 (data->input);
						block5_data_unref (data->_data5_);
						g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
						g_clear_error (&data->_inner_error_);
						return FALSE;
					}
				}
				g_data_output_stream_put_string (data->data_stream, data->sparql[data->i], NULL, &data->_inner_error_);
				if (data->_inner_error_ != NULL) {
					if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
						g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
						g_error_free (data->_inner_error_);
						_g_object_unref0 (data->data_stream);
						_g_object_unref0 (data->output);
						_g_object_unref0 (data->input);
						block5_data_unref (data->_data5_);
						if (data->_state_ == 0) {
							g_simple_async_result_complete_in_idle (data->_async_result);
						} else {
							g_simple_async_result_complete (data->_async_result);
						}
						g_object_unref (data->_async_result);
						return FALSE;
					} else {
						_g_object_unref0 (data->data_stream);
						_g_object_unref0 (data->output);
						_g_object_unref0 (data->input);
						block5_data_unref (data->_data5_);
						g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
						g_clear_error (&data->_inner_error_);
						return FALSE;
					}
				}
			}
		}
	}
	data->_tmp5_ = NULL;
	_g_object_unref0 (data->data_stream);
	data->data_stream = data->_tmp5_;
	data->_data5_->sent_update = TRUE;
	if (data->_data5_->dbus_res == NULL) {
		data->_state_ = 1;
		return FALSE;
		_state_1:
		;
	}
	data->_tmp6_ = NULL;
	data->_tmp6_ = g_ptr_array_new_with_free_func (_g_error_free0_);
	data->_result_ = data->_tmp6_;
	if (data->priority <= G_PRIORITY_DEFAULT) {
		data->_tmp7_ = NULL;
		data->_tmp7_ = tracker_bus_steroids_update_array_finish (tracker_bus_connection_steroids_object, data->_data5_->dbus_res, &data->_inner_error_);
		data->_tmp8_ = data->_tmp7_;
		if (data->_inner_error_ != NULL) {
			if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
				g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
				g_error_free (data->_inner_error_);
				_g_variant_unref0 (data->resultv);
				_g_ptr_array_unref0 (data->_result_);
				_g_object_unref0 (data->data_stream);
				_g_object_unref0 (data->output);
				_g_object_unref0 (data->input);
				block5_data_unref (data->_data5_);
				if (data->_state_ == 0) {
					g_simple_async_result_complete_in_idle (data->_async_result);
				} else {
					g_simple_async_result_complete (data->_async_result);
				}
				g_object_unref (data->_async_result);
				return FALSE;
			} else {
				_g_variant_unref0 (data->resultv);
				_g_ptr_array_unref0 (data->_result_);
				_g_object_unref0 (data->data_stream);
				_g_object_unref0 (data->output);
				_g_object_unref0 (data->input);
				block5_data_unref (data->_data5_);
				g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
				g_clear_error (&data->_inner_error_);
				return FALSE;
			}
		}
		data->_tmp9_ = data->_tmp8_;
		_g_variant_unref0 (data->resultv);
		data->resultv = data->_tmp9_;
	} else {
		data->_tmp10_ = NULL;
		data->_tmp10_ = tracker_bus_steroids_batch_update_array_finish (tracker_bus_connection_steroids_object, data->_data5_->dbus_res, &data->_inner_error_);
		data->_tmp11_ = data->_tmp10_;
		if (data->_inner_error_ != NULL) {
			if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
				g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
				g_error_free (data->_inner_error_);
				_g_variant_unref0 (data->resultv);
				_g_ptr_array_unref0 (data->_result_);
				_g_object_unref0 (data->data_stream);
				_g_object_unref0 (data->output);
				_g_object_unref0 (data->input);
				block5_data_unref (data->_data5_);
				if (data->_state_ == 0) {
					g_simple_async_result_complete_in_idle (data->_async_result);
				} else {
					g_simple_async_result_complete (data->_async_result);
				}
				g_object_unref (data->_async_result);
				return FALSE;
			} else {
				_g_variant_unref0 (data->resultv);
				_g_ptr_array_unref0 (data->_result_);
				_g_object_unref0 (data->data_stream);
				_g_object_unref0 (data->output);
				_g_object_unref0 (data->input);
				block5_data_unref (data->_data5_);
				g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
				g_clear_error (&data->_inner_error_);
				return FALSE;
			}
		}
		data->_tmp12_ = data->_tmp11_;
		_g_variant_unref0 (data->resultv);
		data->resultv = data->_tmp12_;
	}
	data->_tmp13_ = NULL;
	data->_tmp13_ = g_variant_iter_new (data->resultv);
	data->iter = data->_tmp13_;
	while (TRUE) {
		data->_tmp14_ = g_variant_iter_next (data->iter, "s", &data->code, NULL);
		if (!data->_tmp14_) {
			break;
		}
		data->_tmp15_ = g_variant_iter_next (data->iter, "s", &data->message, NULL);
		if (data->_tmp15_) {
			if (g_strcmp0 (data->code, "") != 0) {
				data->_tmp16_ = g_strcmp0 (data->message, "") != 0;
			} else {
				data->_tmp16_ = FALSE;
			}
			if (data->_tmp16_) {
				data->_tmp17_ = NULL;
				data->_tmp17_ = g_error_new_literal (TRACKER_SPARQL_ERROR, TRACKER_SPARQL_ERROR_INTERNAL, data->message);
				g_ptr_array_add (data->_result_, data->_tmp17_);
			} else {
				g_ptr_array_add (data->_result_, NULL);
			}
		}
	}
	data->result = data->_result_;
	_g_free0 (data->message);
	_g_free0 (data->code);
	_g_variant_iter_free0 (data->iter);
	_g_variant_unref0 (data->resultv);
	_g_object_unref0 (data->data_stream);
	_g_object_unref0 (data->output);
	_g_object_unref0 (data->input);
	block5_data_unref (data->_data5_);
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
	_g_free0 (data->message);
	_g_free0 (data->code);
	_g_variant_iter_free0 (data->iter);
	_g_variant_unref0 (data->resultv);
	_g_ptr_array_unref0 (data->_result_);
	_g_object_unref0 (data->data_stream);
	_g_object_unref0 (data->output);
	_g_object_unref0 (data->input);
	block5_data_unref (data->_data5_);
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
}


static Block6Data* block6_data_ref (Block6Data* _data6_) {
	g_atomic_int_inc (&_data6_->_ref_count_);
	return _data6_;
}


static void block6_data_unref (Block6Data* _data6_) {
	if (g_atomic_int_dec_and_test (&_data6_->_ref_count_)) {
		_g_object_unref0 (_data6_->self);
		_g_object_unref0 (_data6_->async_res);
		_g_main_loop_unref0 (_data6_->loop);
		g_slice_free (Block6Data, _data6_);
	}
}


static void _lambda6_ (GObject* o, GAsyncResult* res, Block6Data* _data6_) {
	TrackerBusConnection * self;
	GAsyncResult* _tmp0_;
	GAsyncResult* _tmp1_;
	self = _data6_->self;
	g_return_if_fail (res != NULL);
	_tmp0_ = _g_object_ref0 (res);
	_tmp1_ = _tmp0_;
	_g_object_unref0 (_data6_->async_res);
	_data6_->async_res = _tmp1_;
	g_main_loop_quit (_data6_->loop);
}


static void __lambda6__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	_lambda6_ (source_object, res, self);
	block6_data_unref (self);
}


static GVariant* tracker_bus_connection_real_update_blank (TrackerSparqlConnection* base, const gchar* sparql, gint priority, GCancellable* cancellable, GError** error) {
	TrackerBusConnection * self;
	GVariant* result = NULL;
	Block6Data* _data6_;
	GMainContext* _tmp0_ = NULL;
	GMainContext* context;
	GMainLoop* _tmp1_ = NULL;
	GVariant* _tmp2_ = NULL;
	GVariant* _tmp3_;
	GError * _inner_error_ = NULL;
	self = (TrackerBusConnection*) base;
	g_return_val_if_fail (sparql != NULL, NULL);
	_data6_ = g_slice_new0 (Block6Data);
	_data6_->_ref_count_ = 1;
	_data6_->self = g_object_ref (self);
	_tmp0_ = g_main_context_new ();
	context = _tmp0_;
	_tmp1_ = g_main_loop_new (context, FALSE);
	_data6_->loop = _tmp1_;
	g_main_context_push_thread_default (context);
	_data6_->async_res = NULL;
	tracker_sparql_connection_update_blank_async ((TrackerSparqlConnection*) self, sparql, priority, cancellable, __lambda6__gasync_ready_callback, block6_data_ref (_data6_));
	g_main_loop_run (_data6_->loop);
	g_main_context_pop_thread_default (context);
	_tmp2_ = tracker_sparql_connection_update_blank_finish ((TrackerSparqlConnection*) self, _data6_->async_res, &_inner_error_);
	_tmp3_ = _tmp2_;
	if (_inner_error_ != NULL) {
		if (((_inner_error_->domain == TRACKER_SPARQL_ERROR) || (_inner_error_->domain == G_IO_ERROR)) || (_inner_error_->domain == G_DBUS_ERROR)) {
			g_propagate_error (error, _inner_error_);
			_g_main_context_unref0 (context);
			block6_data_unref (_data6_);
			return NULL;
		} else {
			_g_main_context_unref0 (context);
			block6_data_unref (_data6_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
	}
	result = _tmp3_;
	_g_main_context_unref0 (context);
	block6_data_unref (_data6_);
	return result;
}


static void tracker_bus_connection_real_update_blank_async_data_free (gpointer _data) {
	TrackerBusConnectionUpdateBlankAsyncData* data;
	data = _data;
	_g_free0 (data->sparql);
	_g_object_unref0 (data->cancellable);
	_g_variant_unref0 (data->result);
	_g_object_unref0 (data->self);
	g_slice_free (TrackerBusConnectionUpdateBlankAsyncData, data);
}


static void tracker_bus_connection_real_update_blank_async (TrackerSparqlConnection* base, const gchar* sparql, gint priority, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TrackerBusConnection * self;
	TrackerBusConnectionUpdateBlankAsyncData* _data_;
	self = (TrackerBusConnection*) base;
	_data_ = g_slice_new0 (TrackerBusConnectionUpdateBlankAsyncData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, tracker_bus_connection_real_update_blank_async);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, tracker_bus_connection_real_update_blank_async_data_free);
	_data_->self = _g_object_ref0 (self);
	_data_->sparql = g_strdup (sparql);
	_data_->priority = priority;
	_data_->cancellable = _g_object_ref0 (cancellable);
	tracker_bus_connection_real_update_blank_async_co (_data_);
}


static GVariant* tracker_bus_connection_real_update_blank_finish (TrackerSparqlConnection* base, GAsyncResult* _res_, GError** error) {
	GVariant* result;
	TrackerBusConnectionUpdateBlankAsyncData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void tracker_bus_connection_update_blank_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	TrackerBusConnectionUpdateBlankAsyncData* data;
	data = _user_data_;
	data->_source_object_ = source_object;
	data->_res_ = _res_;
	tracker_bus_connection_real_update_blank_async_co (data);
}


static Block7Data* block7_data_ref (Block7Data* _data7_) {
	g_atomic_int_inc (&_data7_->_ref_count_);
	return _data7_;
}


static void block7_data_unref (Block7Data* _data7_) {
	if (g_atomic_int_dec_and_test (&_data7_->_ref_count_)) {
		_g_object_unref0 (_data7_->self);
		_g_object_unref0 (_data7_->dbus_res);
		g_slice_free (Block7Data, _data7_);
	}
}


static void _lambda5_ (GObject* o, GAsyncResult* res, Block7Data* _data7_) {
	TrackerBusConnection * self;
	GAsyncResult* _tmp0_;
	GAsyncResult* _tmp1_;
	self = _data7_->self;
	g_return_if_fail (res != NULL);
	_tmp0_ = _g_object_ref0 (res);
	_tmp1_ = _tmp0_;
	_g_object_unref0 (_data7_->dbus_res);
	_data7_->dbus_res = _tmp1_;
	if (_data7_->sent_update) {
		tracker_bus_connection_real_update_blank_async_co (_data7_->_async_data_);
	}
}


static void __lambda5__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	_lambda5_ (source_object, res, self);
	block7_data_unref (self);
}


static gboolean tracker_bus_connection_real_update_blank_async_co (TrackerBusConnectionUpdateBlankAsyncData* data) {
	switch (data->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	data->_data7_ = g_slice_new0 (Block7Data);
	data->_data7_->_ref_count_ = 1;
	data->_data7_->self = g_object_ref (data->self);
	data->_data7_->_async_data_ = data;
	data->_tmp0_ = NULL;
	data->_tmp1_ = NULL;
	tracker_bus_connection_pipe (data->self, &data->_tmp0_, &data->_tmp1_, &data->_inner_error_);
	_g_object_unref0 (data->input);
	data->input = data->_tmp0_;
	_g_object_unref0 (data->output);
	data->output = data->_tmp1_;
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block7_data_unref (data->_data7_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block7_data_unref (data->_data7_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->_data7_->dbus_res = NULL;
	data->_data7_->sent_update = FALSE;
	tracker_bus_steroids_update_blank (tracker_bus_connection_steroids_object, data->input, data->cancellable, __lambda5__gasync_ready_callback, block7_data_ref (data->_data7_));
	data->_tmp2_ = NULL;
	data->_tmp2_ = g_data_output_stream_new ((GOutputStream*) data->output);
	data->data_stream = data->_tmp2_;
	g_data_output_stream_set_byte_order (data->data_stream, G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN);
	data->_tmp3_ = strlen (data->sparql);
	g_data_output_stream_put_int32 (data->data_stream, (gint32) data->_tmp3_, NULL, &data->_inner_error_);
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block7_data_unref (data->_data7_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block7_data_unref (data->_data7_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	g_data_output_stream_put_string (data->data_stream, data->sparql, NULL, &data->_inner_error_);
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block7_data_unref (data->_data7_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block7_data_unref (data->_data7_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->_tmp4_ = NULL;
	_g_object_unref0 (data->data_stream);
	data->data_stream = data->_tmp4_;
	data->_data7_->sent_update = TRUE;
	if (data->_data7_->dbus_res == NULL) {
		data->_state_ = 1;
		return FALSE;
		_state_1:
		;
	}
	data->_tmp5_ = NULL;
	data->_tmp5_ = tracker_bus_steroids_update_blank_finish (tracker_bus_connection_steroids_object, data->_data7_->dbus_res, &data->_inner_error_);
	data->_tmp6_ = data->_tmp5_;
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block7_data_unref (data->_data7_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (data->data_stream);
			_g_object_unref0 (data->output);
			_g_object_unref0 (data->input);
			block7_data_unref (data->_data7_);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->result = data->_tmp6_;
	_g_object_unref0 (data->data_stream);
	_g_object_unref0 (data->output);
	_g_object_unref0 (data->input);
	block7_data_unref (data->_data7_);
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
	_g_object_unref0 (data->data_stream);
	_g_object_unref0 (data->output);
	_g_object_unref0 (data->input);
	block7_data_unref (data->_data7_);
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
}


static void tracker_bus_connection_real_load (TrackerSparqlConnection* base, GFile* file, GCancellable* cancellable, GError** error) {
	TrackerBusConnection * self;
	gchar* _tmp0_ = NULL;
	gchar* _tmp1_;
	gboolean _tmp2_ = FALSE;
	GError * _inner_error_ = NULL;
	self = (TrackerBusConnection*) base;
	g_return_if_fail (file != NULL);
	_tmp0_ = g_file_get_uri (file);
	_tmp1_ = _tmp0_;
	tracker_bus_resources_load (tracker_bus_connection_resources_object, _tmp1_, cancellable, &_inner_error_);
	_g_free0 (_tmp1_);
	if (_inner_error_ != NULL) {
		if (((_inner_error_->domain == TRACKER_SPARQL_ERROR) || (_inner_error_->domain == G_IO_ERROR)) || (_inner_error_->domain == G_DBUS_ERROR)) {
			g_propagate_error (error, _inner_error_);
			return;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return;
		}
	}
	if (cancellable != NULL) {
		gboolean _tmp3_;
		_tmp3_ = g_cancellable_is_cancelled (cancellable);
		_tmp2_ = _tmp3_;
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		GError* _tmp4_ = NULL;
		_tmp4_ = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_CANCELLED, "Operation was cancelled");
		_inner_error_ = _tmp4_;
		if (((_inner_error_->domain == TRACKER_SPARQL_ERROR) || (_inner_error_->domain == G_IO_ERROR)) || (_inner_error_->domain == G_DBUS_ERROR)) {
			g_propagate_error (error, _inner_error_);
			return;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return;
		}
	}
}


static void tracker_bus_connection_real_load_async_data_free (gpointer _data) {
	TrackerBusConnectionLoadAsyncData* data;
	data = _data;
	_g_object_unref0 (data->file);
	_g_object_unref0 (data->cancellable);
	_g_object_unref0 (data->self);
	g_slice_free (TrackerBusConnectionLoadAsyncData, data);
}


static void tracker_bus_connection_real_load_async (TrackerSparqlConnection* base, GFile* file, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TrackerBusConnection * self;
	TrackerBusConnectionLoadAsyncData* _data_;
	self = (TrackerBusConnection*) base;
	_data_ = g_slice_new0 (TrackerBusConnectionLoadAsyncData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, tracker_bus_connection_real_load_async);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, tracker_bus_connection_real_load_async_data_free);
	_data_->self = _g_object_ref0 (self);
	_data_->file = _g_object_ref0 (file);
	_data_->cancellable = _g_object_ref0 (cancellable);
	tracker_bus_connection_real_load_async_co (_data_);
}


static void tracker_bus_connection_real_load_finish (TrackerSparqlConnection* base, GAsyncResult* _res_, GError** error) {
	TrackerBusConnectionLoadAsyncData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void tracker_bus_connection_load_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	TrackerBusConnectionLoadAsyncData* data;
	data = _user_data_;
	data->_source_object_ = source_object;
	data->_res_ = _res_;
	tracker_bus_connection_real_load_async_co (data);
}


static gboolean tracker_bus_connection_real_load_async_co (TrackerBusConnectionLoadAsyncData* data) {
	switch (data->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	data->_tmp0_ = NULL;
	data->_tmp0_ = g_file_get_uri (data->file);
	data->_tmp1_ = data->_tmp0_;
	data->_state_ = 1;
	tracker_bus_resources_load_async (tracker_bus_connection_resources_object, data->_tmp1_, data->cancellable, tracker_bus_connection_load_async_ready, data);
	return FALSE;
	_state_1:
	tracker_bus_resources_load_finish (tracker_bus_connection_resources_object, data->_res_, &data->_inner_error_);
	_g_free0 (data->_tmp1_);
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	if (data->cancellable != NULL) {
		data->_tmp3_ = g_cancellable_is_cancelled (data->cancellable);
		data->_tmp2_ = data->_tmp3_;
	} else {
		data->_tmp2_ = FALSE;
	}
	if (data->_tmp2_) {
		data->_tmp4_ = NULL;
		data->_tmp4_ = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_CANCELLED, "Operation was cancelled");
		data->_inner_error_ = data->_tmp4_;
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
}


static TrackerSparqlCursor* tracker_bus_connection_real_statistics (TrackerSparqlConnection* base, GCancellable* cancellable, GError** error) {
	TrackerBusConnection * self;
	TrackerSparqlCursor* result = NULL;
	gint _tmp0_;
	gint _tmp1_;
	gchar** _tmp2_ = NULL;
	gint results_length1;
	gint results_length2;
	gchar** _tmp3_;
	gchar** results;
	TrackerSparqlValueType* _tmp4_ = NULL;
	gint types_length1;
	gint _types_size_;
	TrackerSparqlValueType* _tmp5_;
	TrackerSparqlValueType* types;
	gchar** _tmp6_ = NULL;
	gint var_names_length1;
	gint _var_names_size_;
	gchar** _tmp7_;
	gchar** var_names;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	gchar** _tmp12_;
	TrackerBusArrayCursor* _tmp13_ = NULL;
	GError * _inner_error_ = NULL;
	self = (TrackerBusConnection*) base;
	_tmp2_ = tracker_bus_statistics_Get (tracker_bus_connection_statistics_object, cancellable, &_tmp0_, &_tmp1_, &_inner_error_);
	_tmp3_ = _tmp2_;
	results_length1 = _tmp0_;
	results_length2 = _tmp1_;
	results = _tmp3_;
	if (_inner_error_ != NULL) {
		if (((_inner_error_->domain == TRACKER_SPARQL_ERROR) || (_inner_error_->domain == G_IO_ERROR)) || (_inner_error_->domain == G_DBUS_ERROR)) {
			g_propagate_error (error, _inner_error_);
			return NULL;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
	}
	_tmp4_ = g_new0 (TrackerSparqlValueType, 2);
	_tmp5_ = _tmp4_;
	types_length1 = 2;
	_types_size_ = types_length1;
	types = _tmp5_;
	_tmp6_ = g_new0 (gchar*, 2 + 1);
	_tmp7_ = _tmp6_;
	var_names_length1 = 2;
	_var_names_size_ = var_names_length1;
	var_names = _tmp7_;
	_tmp8_ = g_strdup ("class");
	_tmp9_ = _tmp8_;
	_g_free0 (var_names[0]);
	var_names[0] = _tmp9_;
	_tmp10_ = g_strdup ("count");
	_tmp11_ = _tmp10_;
	_g_free0 (var_names[1]);
	var_names[1] = _tmp11_;
	types[0] = TRACKER_SPARQL_VALUE_TYPE_STRING;
	types[1] = TRACKER_SPARQL_VALUE_TYPE_INTEGER;
	_tmp12_ = results;
	results = NULL;
	_tmp13_ = tracker_bus_array_cursor_new (_tmp12_, results_length1, results_length2, results_length1, results_length2, var_names, var_names_length1, types, types_length1);
	result = (TrackerSparqlCursor*) _tmp13_;
	var_names = (_vala_array_free (var_names, var_names_length1, (GDestroyNotify) g_free), NULL);
	types = (g_free (types), NULL);
	results = (_vala_array_free (results, results_length1 * results_length2, (GDestroyNotify) g_free), NULL);
	return result;
}


static void tracker_bus_connection_real_statistics_async_data_free (gpointer _data) {
	TrackerBusConnectionStatisticsAsyncData* data;
	data = _data;
	_g_object_unref0 (data->cancellable);
	_g_object_unref0 (data->result);
	_g_object_unref0 (data->self);
	g_slice_free (TrackerBusConnectionStatisticsAsyncData, data);
}


static void tracker_bus_connection_real_statistics_async (TrackerSparqlConnection* base, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	TrackerBusConnection * self;
	TrackerBusConnectionStatisticsAsyncData* _data_;
	self = (TrackerBusConnection*) base;
	_data_ = g_slice_new0 (TrackerBusConnectionStatisticsAsyncData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, tracker_bus_connection_real_statistics_async);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, tracker_bus_connection_real_statistics_async_data_free);
	_data_->self = _g_object_ref0 (self);
	_data_->cancellable = _g_object_ref0 (cancellable);
	tracker_bus_connection_real_statistics_async_co (_data_);
}


static TrackerSparqlCursor* tracker_bus_connection_real_statistics_finish (TrackerSparqlConnection* base, GAsyncResult* _res_, GError** error) {
	TrackerSparqlCursor* result;
	TrackerBusConnectionStatisticsAsyncData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void tracker_bus_connection_statistics_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	TrackerBusConnectionStatisticsAsyncData* data;
	data = _user_data_;
	data->_source_object_ = source_object;
	data->_res_ = _res_;
	tracker_bus_connection_real_statistics_async_co (data);
}


static gboolean tracker_bus_connection_real_statistics_async_co (TrackerBusConnectionStatisticsAsyncData* data) {
	switch (data->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	data->_state_ = 1;
	tracker_bus_statistics_Get_async (tracker_bus_connection_statistics_object, data->cancellable, tracker_bus_connection_statistics_async_ready, data);
	return FALSE;
	_state_1:
	data->_tmp2_ = NULL;
	data->_tmp2_ = tracker_bus_statistics_Get_finish (tracker_bus_connection_statistics_object, data->_res_, &data->_tmp0_, &data->_tmp1_, &data->_inner_error_);
	data->_tmp3_ = data->_tmp2_;
	data->results_length1 = data->_tmp0_;
	data->results_length2 = data->_tmp1_;
	data->results = data->_tmp3_;
	if (data->_inner_error_ != NULL) {
		if (((data->_inner_error_->domain == TRACKER_SPARQL_ERROR) || (data->_inner_error_->domain == G_IO_ERROR)) || (data->_inner_error_->domain == G_DBUS_ERROR)) {
			g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
			g_error_free (data->_inner_error_);
			if (data->_state_ == 0) {
				g_simple_async_result_complete_in_idle (data->_async_result);
			} else {
				g_simple_async_result_complete (data->_async_result);
			}
			g_object_unref (data->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
			g_clear_error (&data->_inner_error_);
			return FALSE;
		}
	}
	data->_tmp4_ = NULL;
	data->_tmp4_ = g_new0 (TrackerSparqlValueType, 2);
	data->_tmp5_ = data->_tmp4_;
	data->types_length1 = 2;
	data->_types_size_ = data->types_length1;
	data->types = data->_tmp5_;
	data->_tmp6_ = NULL;
	data->_tmp6_ = g_new0 (gchar*, 2 + 1);
	data->_tmp7_ = data->_tmp6_;
	data->var_names_length1 = 2;
	data->_var_names_size_ = data->var_names_length1;
	data->var_names = data->_tmp7_;
	data->_tmp8_ = g_strdup ("class");
	data->_tmp9_ = data->_tmp8_;
	_g_free0 (data->var_names[0]);
	data->var_names[0] = data->_tmp9_;
	data->_tmp10_ = g_strdup ("count");
	data->_tmp11_ = data->_tmp10_;
	_g_free0 (data->var_names[1]);
	data->var_names[1] = data->_tmp11_;
	data->types[0] = TRACKER_SPARQL_VALUE_TYPE_STRING;
	data->types[1] = TRACKER_SPARQL_VALUE_TYPE_INTEGER;
	data->_tmp12_ = data->results;
	data->results = NULL;
	data->_tmp13_ = NULL;
	data->_tmp13_ = tracker_bus_array_cursor_new (data->_tmp12_, data->results_length1, data->results_length2, data->results_length1, data->results_length2, data->var_names, data->var_names_length1, data->types, data->types_length1);
	data->result = (TrackerSparqlCursor*) data->_tmp13_;
	data->var_names = (_vala_array_free (data->var_names, data->var_names_length1, (GDestroyNotify) g_free), NULL);
	data->types = (g_free (data->types), NULL);
	data->results = (_vala_array_free (data->results, data->results_length1 * data->results_length2, (GDestroyNotify) g_free), NULL);
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
	data->var_names = (_vala_array_free (data->var_names, data->var_names_length1, (GDestroyNotify) g_free), NULL);
	data->types = (g_free (data->types), NULL);
	data->results = (_vala_array_free (data->results, data->results_length1 * data->results_length2, (GDestroyNotify) g_free), NULL);
	if (data->_state_ == 0) {
		g_simple_async_result_complete_in_idle (data->_async_result);
	} else {
		g_simple_async_result_complete (data->_async_result);
	}
	g_object_unref (data->_async_result);
	return FALSE;
}


static void tracker_bus_connection_class_init (TrackerBusConnectionClass * klass) {
	tracker_bus_connection_parent_class = g_type_class_peek_parent (klass);
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->query = tracker_bus_connection_real_query;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->query_async = tracker_bus_connection_real_query_async;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->query_finish = tracker_bus_connection_real_query_finish;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->update = tracker_bus_connection_real_update;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->update_async = tracker_bus_connection_real_update_async;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->update_finish = tracker_bus_connection_real_update_finish;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->update_array_async = tracker_bus_connection_real_update_array_async;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->update_array_finish = tracker_bus_connection_real_update_array_finish;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->update_blank = tracker_bus_connection_real_update_blank;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->update_blank_async = tracker_bus_connection_real_update_blank_async;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->update_blank_finish = tracker_bus_connection_real_update_blank_finish;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->load = tracker_bus_connection_real_load;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->load_async = tracker_bus_connection_real_load_async;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->load_finish = tracker_bus_connection_real_load_finish;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->statistics = tracker_bus_connection_real_statistics;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->statistics_async = tracker_bus_connection_real_statistics_async;
	TRACKER_SPARQL_CONNECTION_CLASS (klass)->statistics_finish = tracker_bus_connection_real_statistics_finish;
	G_OBJECT_CLASS (klass)->finalize = tracker_bus_connection_finalize;
}


static void tracker_bus_connection_instance_init (TrackerBusConnection * self) {
}


static void tracker_bus_connection_finalize (GObject* obj) {
	TrackerBusConnection * self;
	self = TRACKER_BUS_CONNECTION (obj);
	tracker_bus_connection_initialized = FALSE;
	G_OBJECT_CLASS (tracker_bus_connection_parent_class)->finalize (obj);
}


GType tracker_bus_connection_get_type (void) {
	static volatile gsize tracker_bus_connection_type_id__volatile = 0;
	if (g_once_init_enter (&tracker_bus_connection_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (TrackerBusConnectionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) tracker_bus_connection_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TrackerBusConnection), 0, (GInstanceInitFunc) tracker_bus_connection_instance_init, NULL };
		GType tracker_bus_connection_type_id;
		tracker_bus_connection_type_id = g_type_register_static (TRACKER_SPARQL_TYPE_CONNECTION, "TrackerBusConnection", &g_define_type_info, 0);
		g_once_init_leave (&tracker_bus_connection_type_id__volatile, tracker_bus_connection_type_id);
	}
	return tracker_bus_connection_type_id__volatile;
}


TrackerSparqlConnection* module_init (void) {
	TrackerSparqlConnection* result = NULL;
	TrackerBusConnection* _tmp0_ = NULL;
	TrackerSparqlConnection* plugin;
	GError * _inner_error_ = NULL;
	_tmp0_ = tracker_bus_connection_new (&_inner_error_);
	plugin = (TrackerSparqlConnection*) _tmp0_;
	if (_inner_error_ != NULL) {
		goto __catch0_g_error;
	}
	result = plugin;
	return result;
	_g_object_unref0 (plugin);
	goto __finally0;
	__catch0_g_error:
	{
		g_clear_error (&_inner_error_);
		_inner_error_ = NULL;
		result = NULL;
		return result;
	}
	__finally0:
	g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
	g_clear_error (&_inner_error_);
	return NULL;
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	if ((array != NULL) && (destroy_func != NULL)) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}



