/* dbus.c generated by valac 0.30.0.38-a55d, the Vala compiler
 * generated from dbus.vala, do not modify */

/*
 * This file is part of gnome-code-assistance.
 *
 * Copyright (C) 2013 - Jesse van den Kieboom
 *
 * gnome-code-assistance is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * gnome-code-assistance 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with gnome-code-assistance.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <glib.h>
#include <glib-object.h>
#include <gio/gio.h>
#include "backends/vala/libvalashared.h"
#include <string.h>
#include <stdlib.h>
#include <gee.h>
#include <stdio.h>
#include <gobject/gvaluecollector.h>


#define DBUS_TYPE_DOCUMENT_IFACE (dbus_document_iface_get_type ())
#define DBUS_DOCUMENT_IFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_TYPE_DOCUMENT_IFACE, DBusDocumentIface))
#define DBUS_DOCUMENT_IFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_TYPE_DOCUMENT_IFACE, DBusDocumentIfaceClass))
#define DBUS_IS_DOCUMENT_IFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_TYPE_DOCUMENT_IFACE))
#define DBUS_IS_DOCUMENT_IFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_TYPE_DOCUMENT_IFACE))
#define DBUS_DOCUMENT_IFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_TYPE_DOCUMENT_IFACE, DBusDocumentIfaceClass))

typedef struct _DBusDocumentIface DBusDocumentIface;
typedef struct _DBusDocumentIfaceClass DBusDocumentIfaceClass;
typedef struct _DBusDocumentIfacePrivate DBusDocumentIfacePrivate;

#define TYPE_DOCUMENT (document_get_type ())
#define DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DOCUMENT, Document))
#define DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_DOCUMENT, DocumentClass))
#define IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DOCUMENT))
#define IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_DOCUMENT))
#define DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_DOCUMENT, DocumentClass))

typedef struct _Document Document;
typedef struct _DocumentClass DocumentClass;
#define _document_unref0(var) ((var == NULL) ? NULL : (var = (document_unref (var), NULL)))

#define DBUS_TYPE_DIAGNOSTICS_IFACE (dbus_diagnostics_iface_get_type ())
#define DBUS_DIAGNOSTICS_IFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_TYPE_DIAGNOSTICS_IFACE, DBusDiagnosticsIface))
#define DBUS_DIAGNOSTICS_IFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_TYPE_DIAGNOSTICS_IFACE, DBusDiagnosticsIfaceClass))
#define DBUS_IS_DIAGNOSTICS_IFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_TYPE_DIAGNOSTICS_IFACE))
#define DBUS_IS_DIAGNOSTICS_IFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_TYPE_DIAGNOSTICS_IFACE))
#define DBUS_DIAGNOSTICS_IFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_TYPE_DIAGNOSTICS_IFACE, DBusDiagnosticsIfaceClass))

typedef struct _DBusDiagnosticsIface DBusDiagnosticsIface;
typedef struct _DBusDiagnosticsIfaceClass DBusDiagnosticsIfaceClass;
typedef struct _DBusDiagnosticsIfacePrivate DBusDiagnosticsIfacePrivate;

#define DBUS_TYPE_FREEDESKTOP_DBUS (dbus_freedesktop_dbus_get_type ())
#define DBUS_FREEDESKTOP_DBUS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_TYPE_FREEDESKTOP_DBUS, DBusFreedesktopDBus))
#define DBUS_IS_FREEDESKTOP_DBUS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_TYPE_FREEDESKTOP_DBUS))
#define DBUS_FREEDESKTOP_DBUS_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), DBUS_TYPE_FREEDESKTOP_DBUS, DBusFreedesktopDBusIface))

typedef struct _DBusFreedesktopDBus DBusFreedesktopDBus;
typedef struct _DBusFreedesktopDBusIface DBusFreedesktopDBusIface;

#define DBUS_TYPE_FREEDESKTOP_DBUS_PROXY (dbus_freedesktop_dbus_proxy_get_type ())
typedef GDBusProxy DBusFreedesktopDBusProxy;
typedef GDBusProxyClass DBusFreedesktopDBusProxyClass;
#define _g_free0(var) (var = (g_free (var), NULL))

#define DBUS_TYPE_SERVICE_IFACE (dbus_service_iface_get_type ())
#define DBUS_SERVICE_IFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_TYPE_SERVICE_IFACE, DBusServiceIface))
#define DBUS_SERVICE_IFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_TYPE_SERVICE_IFACE, DBusServiceIfaceClass))
#define DBUS_IS_SERVICE_IFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_TYPE_SERVICE_IFACE))
#define DBUS_IS_SERVICE_IFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_TYPE_SERVICE_IFACE))
#define DBUS_SERVICE_IFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_TYPE_SERVICE_IFACE, DBusServiceIfaceClass))

typedef struct _DBusServiceIface DBusServiceIface;
typedef struct _DBusServiceIfaceClass DBusServiceIfaceClass;
typedef struct _DBusServiceIfacePrivate DBusServiceIfacePrivate;

#define DBUS_TYPE_SERVER (dbus_server_get_type ())
#define DBUS_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_TYPE_SERVER, DBusServer))
#define DBUS_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_TYPE_SERVER, DBusServerClass))
#define DBUS_IS_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_TYPE_SERVER))
#define DBUS_IS_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_TYPE_SERVER))
#define DBUS_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_TYPE_SERVER, DBusServerClass))

typedef struct _DBusServer DBusServer;
typedef struct _DBusServerClass DBusServerClass;
#define _dbus_server_unref0(var) ((var == NULL) ? NULL : (var = (dbus_server_unref (var), NULL)))
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
typedef struct _DbusServiceIfaceParseData DbusServiceIfaceParseData;

#define DBUS_TYPE_PROJECT_IFACE (dbus_project_iface_get_type ())
#define DBUS_PROJECT_IFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_TYPE_PROJECT_IFACE, DBusProjectIface))
#define DBUS_PROJECT_IFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_TYPE_PROJECT_IFACE, DBusProjectIfaceClass))
#define DBUS_IS_PROJECT_IFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_TYPE_PROJECT_IFACE))
#define DBUS_IS_PROJECT_IFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_TYPE_PROJECT_IFACE))
#define DBUS_PROJECT_IFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_TYPE_PROJECT_IFACE, DBusProjectIfaceClass))

typedef struct _DBusProjectIface DBusProjectIface;
typedef struct _DBusProjectIfaceClass DBusProjectIfaceClass;
typedef struct _DBusProjectIfacePrivate DBusProjectIfacePrivate;
typedef struct _DbusProjectIfaceParseAllData DbusProjectIfaceParseAllData;
typedef struct _DBusServerPrivate DBusServerPrivate;

#define DBUS_SERVER_TYPE_APP (dbus_server_app_get_type ())
#define DBUS_SERVER_APP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_SERVER_TYPE_APP, DBusServerApp))
#define DBUS_SERVER_APP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_SERVER_TYPE_APP, DBusServerAppClass))
#define DBUS_SERVER_IS_APP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_SERVER_TYPE_APP))
#define DBUS_SERVER_IS_APP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_SERVER_TYPE_APP))
#define DBUS_SERVER_APP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_SERVER_TYPE_APP, DBusServerAppClass))

typedef struct _DBusServerApp DBusServerApp;
typedef struct _DBusServerAppClass DBusServerAppClass;
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
#define _dbus_server_app_unref0(var) ((var == NULL) ? NULL : (var = (dbus_server_app_unref (var), NULL)))

#define DBUS_SERVER_TYPE_EXPORTED_DOCUMENT (dbus_server_exported_document_get_type ())
#define DBUS_SERVER_EXPORTED_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_SERVER_TYPE_EXPORTED_DOCUMENT, DBusServerExportedDocument))
#define DBUS_SERVER_EXPORTED_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_SERVER_TYPE_EXPORTED_DOCUMENT, DBusServerExportedDocumentClass))
#define DBUS_SERVER_IS_EXPORTED_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_SERVER_TYPE_EXPORTED_DOCUMENT))
#define DBUS_SERVER_IS_EXPORTED_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_SERVER_TYPE_EXPORTED_DOCUMENT))
#define DBUS_SERVER_EXPORTED_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_SERVER_TYPE_EXPORTED_DOCUMENT, DBusServerExportedDocumentClass))

typedef struct _DBusServerExportedDocument DBusServerExportedDocument;
typedef struct _DBusServerExportedDocumentClass DBusServerExportedDocumentClass;
typedef struct _DBusServerAppPrivate DBusServerAppPrivate;

#define TYPE_SERVICE (service_get_type ())
#define SERVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SERVICE, Service))
#define SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SERVICE, ServiceClass))
#define IS_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SERVICE))
#define IS_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SERVICE))
#define SERVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SERVICE, ServiceClass))

typedef struct _Service Service;
typedef struct _ServiceClass ServiceClass;
typedef struct _DBusServerExportedDocumentPrivate DBusServerExportedDocumentPrivate;
#define _dbus_server_exported_document_unref0(var) ((var == NULL) ? NULL : (var = (dbus_server_exported_document_unref (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
typedef struct _DbusServerParseData DbusServerParseData;
typedef struct _DbusServerParseAllData DbusServerParseAllData;
typedef struct _DBusServerParamSpecExportedDocument DBusServerParamSpecExportedDocument;
#define _service_unref0(var) ((var == NULL) ? NULL : (var = (service_unref (var), NULL)))
typedef struct _DBusServerParamSpecApp DBusServerParamSpecApp;
typedef struct _DBusParamSpecServer DBusParamSpecServer;

#define DBUS_TYPE_TRANSPORT (dbus_transport_get_type ())
#define DBUS_TRANSPORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_TYPE_TRANSPORT, DBusTransport))
#define DBUS_TRANSPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_TYPE_TRANSPORT, DBusTransportClass))
#define DBUS_IS_TRANSPORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_TYPE_TRANSPORT))
#define DBUS_IS_TRANSPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_TYPE_TRANSPORT))
#define DBUS_TRANSPORT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_TYPE_TRANSPORT, DBusTransportClass))

typedef struct _DBusTransport DBusTransport;
typedef struct _DBusTransportClass DBusTransportClass;
typedef struct _DBusTransportPrivate DBusTransportPrivate;
typedef struct _DBusParamSpecTransport DBusParamSpecTransport;

struct _DBusDocumentIface {
	GObject parent_instance;
	DBusDocumentIfacePrivate * priv;
};

struct _DBusDocumentIfaceClass {
	GObjectClass parent_class;
};

struct _DBusDocumentIfacePrivate {
	Document* d_document;
};

struct _DBusDiagnosticsIface {
	GObject parent_instance;
	DBusDiagnosticsIfacePrivate * priv;
};

struct _DBusDiagnosticsIfaceClass {
	GObjectClass parent_class;
};

struct _DBusDiagnosticsIfacePrivate {
	Document* d_document;
};

struct _DBusFreedesktopDBusIface {
	GTypeInterface parent_iface;
};

struct _DBusServiceIface {
	GObject parent_instance;
	DBusServiceIfacePrivate * priv;
};

struct _DBusServiceIfaceClass {
	GObjectClass parent_class;
};

struct _DBusServiceIfacePrivate {
	DBusServer* d_server;
};

struct _DbusServiceIfaceParseData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceIface* self;
	gchar* path;
	gchar* data_path;
	SourceLocation cursor;
	GHashTable* options;
	char* sender;
	char* result;
	char* _tmp0_;
	DBusServer* _tmp1_;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	SourceLocation _tmp4_;
	GHashTable* _tmp5_;
	const char* _tmp6_;
	char* _tmp7_;
	char* _tmp8_;
	GError * _inner_error_;
};

struct _DBusProjectIface {
	GObject parent_instance;
	DBusProjectIfacePrivate * priv;
};

struct _DBusProjectIfaceClass {
	GObjectClass parent_class;
};

struct _DBusProjectIfacePrivate {
	DBusServer* d_server;
};

struct _DbusProjectIfaceParseAllData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusProjectIface* self;
	gchar* path;
	OpenDocument* documents;
	gint documents_length1;
	SourceLocation cursor;
	GHashTable* options;
	char* sender;
	RemoteDocument* result;
	gint result_length1;
	RemoteDocument* _tmp0_;
	DBusServer* _tmp1_;
	const gchar* _tmp2_;
	OpenDocument* _tmp3_;
	gint _tmp3__length1;
	SourceLocation _tmp4_;
	GHashTable* _tmp5_;
	const char* _tmp6_;
	gint _tmp7_;
	RemoteDocument* _tmp8_;
	gint _tmp0__length1;
	gint __tmp0__size_;
	RemoteDocument* _tmp9_;
	gint _tmp9__length1;
	RemoteDocument* _tmp10_;
	gint _tmp10__length1;
	GError * _inner_error_;
};

struct _DBusServer {
	GTypeInstance parent_instance;
	volatile int ref_count;
	DBusServerPrivate * priv;
};

struct _DBusServerClass {
	GTypeClass parent_class;
	void (*finalize) (DBusServer *self);
};

struct _DBusServerPrivate {
	GMainLoop* d_main;
	GDBusConnection* d_conn;
	GeeHashMap* d_apps;
	GRecMutex __lock_d_apps;
	guint d_nextid;
	DBusFreedesktopDBus* d_proxy;
};

struct _DBusServerApp {
	GTypeInstance parent_instance;
	volatile int ref_count;
	DBusServerAppPrivate * priv;
	guint id;
	gchar* name;
	Service* service;
	GeeHashMap* docs;
	guint nextid;
};

struct _DBusServerAppClass {
	GTypeClass parent_class;
	void (*finalize) (DBusServerApp *self);
};

struct _DBusServerExportedDocument {
	GTypeInstance parent_instance;
	volatile int ref_count;
	DBusServerExportedDocumentPrivate * priv;
	Document* document;
	DBusDocumentIface* ddocument;
	guint ddocument_regid;
	DBusDiagnosticsIface* ddiagnostics;
	guint ddiagnostics_regid;
};

struct _DBusServerExportedDocumentClass {
	GTypeClass parent_class;
	void (*finalize) (DBusServerExportedDocument *self);
};

struct _DbusServerParseData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServer* self;
	gchar* path;
	gchar* data_path;
	SourceLocation cursor;
	GHashTable* options;
	char* sender;
	char* result;
	DBusServerApp* app;
	DBusServerExportedDocument* doc;
	GeeHashMap* _tmp0_;
	const char* _tmp1_;
	DBusServerApp* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	SourceLocation _tmp5_;
	DBusServerExportedDocument* _tmp6_;
	GeeHashMap* _tmp7_;
	Service* _tmp8_;
	Document* _tmp9_;
	GHashTable* _tmp10_;
	Document* _tmp11_;
	char* _tmp12_;
	GError * _inner_error_;
};

struct _DbusServerParseAllData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServer* self;
	gchar* path;
	OpenDocument* documents;
	gint documents_length1;
	SourceLocation cursor;
	GHashTable* options;
	char* sender;
	RemoteDocument* result;
	gint result_length1;
	DBusServerApp* app;
	DBusServerExportedDocument* doc;
	Document** opendocs;
	gint opendocs_length1;
	gint _opendocs_size_;
	GeeHashMap* _tmp0_;
	const char* _tmp1_;
	DBusServerApp* _tmp2_;
	DBusServerApp* _tmp3_;
	const gchar* _tmp4_;
	SourceLocation _tmp5_;
	DBusServerExportedDocument* _tmp6_;
	OpenDocument* _tmp7_;
	gint _tmp7__length1;
	Document** _tmp8_;
	gint i;
	gboolean _tmp9_;
	gint _tmp10_;
	gint _tmp11_;
	OpenDocument* _tmp12_;
	gint _tmp12__length1;
	DBusServerExportedDocument* rdoc;
	DBusServerApp* _tmp13_;
	OpenDocument* _tmp14_;
	gint _tmp14__length1;
	gint _tmp15_;
	OpenDocument _tmp16_;
	const gchar* _tmp17_;
	OpenDocument* _tmp18_;
	gint _tmp18__length1;
	gint _tmp19_;
	OpenDocument _tmp20_;
	const gchar* _tmp21_;
	DBusServerExportedDocument* _tmp22_;
	Document** _tmp23_;
	gint _tmp23__length1;
	gint _tmp24_;
	DBusServerExportedDocument* _tmp25_;
	Document* _tmp26_;
	Document* _tmp27_;
	Document* _tmp28_;
	GeeHashMap* _tmp29_;
	Document** retdocs;
	DBusServerApp* _tmp30_;
	Service* _tmp31_;
	DBusServerExportedDocument* _tmp32_;
	Document* _tmp33_;
	Document** _tmp34_;
	gint _tmp34__length1;
	GHashTable* _tmp35_;
	gint _tmp36_;
	Document** _tmp37_;
	gint retdocs_length1;
	gint _retdocs_size_;
	RemoteDocument* ret;
	Document** _tmp38_;
	gint _tmp38__length1;
	RemoteDocument* _tmp39_;
	gint ret_length1;
	gint _ret_size_;
	gint _vala1_i;
	gboolean _tmp40_;
	gint _tmp41_;
	gint _tmp42_;
	Document** _tmp43_;
	gint _tmp43__length1;
	RemoteDocument* _tmp44_;
	gint _tmp44__length1;
	gint _tmp45_;
	Document** _tmp46_;
	gint _tmp46__length1;
	gint _tmp47_;
	Document* _tmp48_;
	const gchar* _tmp49_;
	const gchar* _tmp50_;
	gchar* _tmp51_;
	DBusServerApp* _tmp52_;
	Document** _tmp53_;
	gint _tmp53__length1;
	gint _tmp54_;
	Document* _tmp55_;
	char* _tmp56_;
	RemoteDocument _tmp57_;
	RemoteDocument _tmp58_;
	RemoteDocument* _tmp59_;
	gint _tmp59__length1;
	GError * _inner_error_;
};

struct _DBusServerParamSpecExportedDocument {
	GParamSpec parent_instance;
};

struct _DBusServerParamSpecApp {
	GParamSpec parent_instance;
};

struct _DBusParamSpecServer {
	GParamSpec parent_instance;
};

struct _DBusTransport {
	GTypeInstance parent_instance;
	volatile int ref_count;
	DBusTransportPrivate * priv;
};

struct _DBusTransportClass {
	GTypeClass parent_class;
	void (*finalize) (DBusTransport *self);
};

struct _DBusTransportPrivate {
	DBusServer* d_server;
	GMainLoop* d_main;
};

struct _DBusParamSpecTransport {
	GParamSpec parent_instance;
};


static gpointer dbus_document_iface_parent_class = NULL;
static gpointer dbus_diagnostics_iface_parent_class = NULL;
static gpointer dbus_service_iface_parent_class = NULL;
static gpointer dbus_project_iface_parent_class = NULL;
static gpointer dbus_server_parent_class = NULL;
static gpointer dbus_server_exported_document_parent_class = NULL;
static gpointer dbus_server_app_parent_class = NULL;
static gpointer dbus_transport_parent_class = NULL;

GType dbus_document_iface_get_type (void) G_GNUC_CONST;
guint dbus_document_iface_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
gpointer document_ref (gpointer instance);
void document_unref (gpointer instance);
GParamSpec* param_spec_document (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_document (GValue* value, gpointer v_object);
void value_take_document (GValue* value, gpointer v_object);
gpointer value_get_document (const GValue* value);
GType document_get_type (void) G_GNUC_CONST;
#define DBUS_DOCUMENT_IFACE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TYPE_DOCUMENT_IFACE, DBusDocumentIfacePrivate))
enum  {
	DBUS_DOCUMENT_IFACE_DUMMY_PROPERTY
};
DBusDocumentIface* dbus_document_iface_new (Document* document);
DBusDocumentIface* dbus_document_iface_construct (GType object_type, Document* document);
static void dbus_document_iface_finalize (GObject* obj);
static void dbus_document_iface_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* dbus_document_iface_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 dbus_document_iface_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 _dbus_document_iface_unregister_object (gpointer user_data);
GType dbus_diagnostics_iface_get_type (void) G_GNUC_CONST;
guint dbus_diagnostics_iface_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
#define DBUS_DIAGNOSTICS_IFACE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TYPE_DIAGNOSTICS_IFACE, DBusDiagnosticsIfacePrivate))
enum  {
	DBUS_DIAGNOSTICS_IFACE_DUMMY_PROPERTY
};
DBusDiagnosticsIface* dbus_diagnostics_iface_new (Document* document);
DBusDiagnosticsIface* dbus_diagnostics_iface_construct (GType object_type, Document* document);
Diagnostic* dbus_diagnostics_iface_diagnostics (DBusDiagnosticsIface* self, int* result_length1);
Diagnostic* document_get_diagnostics (Document* self, int* result_length1);
static Diagnostic* _vala_array_dup1 (Diagnostic* self, int length);
static void dbus_diagnostics_iface_finalize (GObject* obj);
static void _vala_Diagnostic_array_free (Diagnostic* array, gint array_length);
static void _dbus_dbus_diagnostics_iface_diagnostics (DBusDiagnosticsIface* self, GVariant* _parameters_, GDBusMethodInvocation* invocation);
static void dbus_diagnostics_iface_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* dbus_diagnostics_iface_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 dbus_diagnostics_iface_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 _dbus_diagnostics_iface_unregister_object (gpointer user_data);
GType dbus_freedesktop_dbus_get_type (void) G_GNUC_CONST;
GType dbus_freedesktop_dbus_proxy_get_type (void) G_GNUC_CONST;
guint dbus_freedesktop_dbus_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
static void g_cclosure_user_marshal_VOID__STRING_STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
static void dbus_freedesktop_dbus_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static void _dbus_handle_dbus_freedesktop_dbus_name_owner_changed (DBusFreedesktopDBus* self, GVariant* parameters);
static void dbus_freedesktop_dbus_proxy_dbus_freedesktop_dbus_interface_init (DBusFreedesktopDBusIface* iface);
static void dbus_freedesktop_dbus_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* dbus_freedesktop_dbus_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 dbus_freedesktop_dbus_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 _dbus_dbus_freedesktop_dbus_name_owner_changed (GObject* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer* _data);
static void _dbus_freedesktop_dbus_unregister_object (gpointer user_data);
GType dbus_service_iface_get_type (void) G_GNUC_CONST;
guint dbus_service_iface_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
gpointer dbus_server_ref (gpointer instance);
void dbus_server_unref (gpointer instance);
GParamSpec* dbus_param_spec_server (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void dbus_value_set_server (GValue* value, gpointer v_object);
void dbus_value_take_server (GValue* value, gpointer v_object);
gpointer dbus_value_get_server (const GValue* value);
GType dbus_server_get_type (void) G_GNUC_CONST;
#define DBUS_SERVICE_IFACE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TYPE_SERVICE_IFACE, DBusServiceIfacePrivate))
enum  {
	DBUS_SERVICE_IFACE_DUMMY_PROPERTY
};
DBusServiceIface* dbus_service_iface_new (DBusServer* server);
DBusServiceIface* dbus_service_iface_construct (GType object_type, DBusServer* server);
static void dbus_service_iface_parse_data_free (gpointer _data);
void dbus_service_iface_parse (DBusServiceIface* self, const gchar* path, const gchar* data_path, SourceLocation* cursor, GHashTable* options, const char* sender, GAsyncReadyCallback _callback_, gpointer _user_data_);
char* dbus_service_iface_parse_finish (DBusServiceIface* self, GAsyncResult* _res_, GError** error);
static gboolean dbus_service_iface_parse_co (DbusServiceIfaceParseData* _data_);
void dbus_server_parse (DBusServer* self, const gchar* path, const gchar* data_path, SourceLocation* cursor, GHashTable* options, const char* sender, GAsyncReadyCallback _callback_, gpointer _user_data_);
char* dbus_server_parse_finish (DBusServer* self, GAsyncResult* _res_, GError** error);
static void dbus_service_iface_parse_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
void dbus_service_iface_dispose (DBusServiceIface* self, const gchar* path, const char* sender);
void dbus_server_dispose (DBusServer* self, const gchar* path, const char* sender);
static void dbus_service_iface_finalize (GObject* obj);
static void _dbus_dbus_service_iface_parse (DBusServiceIface* self, GVariant* _parameters_, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_iface_parse_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_iface_dispose (DBusServiceIface* self, GVariant* _parameters_, GDBusMethodInvocation* invocation);
static void dbus_service_iface_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* dbus_service_iface_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 dbus_service_iface_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 _dbus_service_iface_unregister_object (gpointer user_data);
GType dbus_project_iface_get_type (void) G_GNUC_CONST;
guint dbus_project_iface_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
#define DBUS_PROJECT_IFACE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TYPE_PROJECT_IFACE, DBusProjectIfacePrivate))
enum  {
	DBUS_PROJECT_IFACE_DUMMY_PROPERTY
};
DBusProjectIface* dbus_project_iface_new (DBusServer* server);
DBusProjectIface* dbus_project_iface_construct (GType object_type, DBusServer* server);
static void _vala_RemoteDocument_array_free (RemoteDocument* array, gint array_length);
static void dbus_project_iface_parse_all_data_free (gpointer _data);
void dbus_project_iface_parse_all (DBusProjectIface* self, const gchar* path, OpenDocument* documents, int documents_length1, SourceLocation* cursor, GHashTable* options, const char* sender, GAsyncReadyCallback _callback_, gpointer _user_data_);
RemoteDocument* dbus_project_iface_parse_all_finish (DBusProjectIface* self, GAsyncResult* _res_, int* result_length1, GError** error);
static gboolean dbus_project_iface_parse_all_co (DbusProjectIfaceParseAllData* _data_);
void dbus_server_parse_all (DBusServer* self, const gchar* path, OpenDocument* documents, int documents_length1, SourceLocation* cursor, GHashTable* options, const char* sender, GAsyncReadyCallback _callback_, gpointer _user_data_);
RemoteDocument* dbus_server_parse_all_finish (DBusServer* self, GAsyncResult* _res_, int* result_length1, GError** error);
static void dbus_project_iface_parse_all_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_project_iface_finalize (GObject* obj);
static void _vala_OpenDocument_array_free (OpenDocument* array, gint array_length);
static void _dbus_dbus_project_iface_parse_all (DBusProjectIface* self, GVariant* _parameters_, GDBusMethodInvocation* invocation);
static void _dbus_dbus_project_iface_parse_all_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void dbus_project_iface_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* dbus_project_iface_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 dbus_project_iface_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 _dbus_project_iface_unregister_object (gpointer user_data);
static gpointer dbus_server_app_ref (gpointer instance);
static void dbus_server_app_unref (gpointer instance);
static GParamSpec* dbus_server_param_spec_app (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) G_GNUC_UNUSED;
static void dbus_server_value_set_app (GValue* value, gpointer v_object) G_GNUC_UNUSED;
static void dbus_server_value_take_app (GValue* value, gpointer v_object) G_GNUC_UNUSED;
static gpointer dbus_server_value_get_app (const GValue* value) G_GNUC_UNUSED;
static GType dbus_server_app_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
#define DBUS_SERVER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TYPE_SERVER, DBusServerPrivate))
enum  {
	DBUS_SERVER_DUMMY_PROPERTY
};
DBusServer* dbus_server_new (GMainLoop* mloop, GDBusConnection* conn);
DBusServer* dbus_server_construct (GType object_type, GMainLoop* mloop, GDBusConnection* conn);
static void __lambda8_ (DBusServer* self, GObject* obj, GAsyncResult* res);
static void dbus_server_on_name_owner_changed (DBusServer* self, const gchar* name, const gchar* oldowner, const gchar* newowner);
static void _dbus_server_on_name_owner_changed_dbus_freedesktop_dbus_name_owner_changed (DBusFreedesktopDBus* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer self);
static void ___lambda8__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void dbus_server_dispose_app (DBusServer* self, DBusServerApp* app);
static DBusServerApp* dbus_server_make_app (DBusServer* self, const gchar* name);
static DBusServerApp* dbus_server_app_new (guint id, const gchar* name);
static DBusServerApp* dbus_server_app_construct (GType object_type, guint id, const gchar* name);
static DBusServerApp* dbus_server_ensure_app (DBusServer* self, const gchar* name);
static gchar* dbus_server_clean_path (DBusServer* self, const gchar* path);
static gpointer dbus_server_exported_document_ref (gpointer instance);
static void dbus_server_exported_document_unref (gpointer instance);
static GParamSpec* dbus_server_param_spec_exported_document (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) G_GNUC_UNUSED;
static void dbus_server_value_set_exported_document (GValue* value, gpointer v_object) G_GNUC_UNUSED;
static void dbus_server_value_take_exported_document (GValue* value, gpointer v_object) G_GNUC_UNUSED;
static gpointer dbus_server_value_get_exported_document (const GValue* value) G_GNUC_UNUSED;
static GType dbus_server_exported_document_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
static DBusServerExportedDocument* dbus_server_make_document (DBusServer* self, DBusServerApp* app, const gchar* path, const gchar* client_path);
gpointer service_ref (gpointer instance);
void service_unref (gpointer instance);
GParamSpec* param_spec_service (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_service (GValue* value, gpointer v_object);
void value_take_service (GValue* value, gpointer v_object);
gpointer value_get_service (const GValue* value);
GType service_get_type (void) G_GNUC_CONST;
Document* document_new (guint id, const gchar* path);
Document* document_construct (GType object_type, guint id, const gchar* path);
void document_set_client_path (Document* self, const gchar* value);
static DBusServerExportedDocument* dbus_server_exported_document_new (Document* document);
static DBusServerExportedDocument* dbus_server_exported_document_construct (GType object_type, Document* document);
static char* dbus_server_remote_document_path (DBusServer* self, DBusServerApp* app, Document* doc);
static DBusServerExportedDocument* dbus_server_ensure_document (DBusServer* self, DBusServerApp* app, const gchar* path, const gchar* data_path, SourceLocation* cursor);
void document_set_data_path (Document* self, const gchar* value);
const gchar* document_get_path (Document* self);
void document_set_cursor (Document* self, SourceLocation* value);
static void dbus_server_dispose_document (DBusServer* self, DBusServerApp* a, DBusServerExportedDocument* ddoc);
void service_dispose (Service* self, Document* document);
guint document_get_id (Document* self);
static void dbus_server_parse_data_free (gpointer _data);
static gboolean dbus_server_parse_co (DbusServerParseData* _data_);
void service_parse (Service* self, Document* doc, GHashTable* options, GAsyncReadyCallback _callback_, gpointer _user_data_);
void service_parse_finish (Service* self, GAsyncResult* _res_);
static void dbus_server_parse_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_server_parse_all_data_free (gpointer _data);
static gboolean dbus_server_parse_all_co (DbusServerParseAllData* _data_);
void service_parse_all (Service* self, Document* doc, Document** documents, int documents_length1, GHashTable* options, GAsyncReadyCallback _callback_, gpointer _user_data_);
Document** service_parse_all_finish (Service* self, GAsyncResult* _res_, int* result_length1);
static void dbus_server_parse_all_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
const gchar* document_get_client_path (Document* self);
enum  {
	DBUS_SERVER_EXPORTED_DOCUMENT_DUMMY_PROPERTY
};
static void dbus_server_exported_document_finalize (DBusServerExportedDocument* obj);
enum  {
	DBUS_SERVER_APP_DUMMY_PROPERTY
};
Service* service_new (void);
Service* service_construct (GType object_type);
static void dbus_server_app_finalize (DBusServerApp* obj);
static void dbus_server_finalize (DBusServer* obj);
gpointer dbus_transport_ref (gpointer instance);
void dbus_transport_unref (gpointer instance);
GParamSpec* dbus_param_spec_transport (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void dbus_value_set_transport (GValue* value, gpointer v_object);
void dbus_value_take_transport (GValue* value, gpointer v_object);
gpointer dbus_value_get_transport (const GValue* value);
GType dbus_transport_get_type (void) G_GNUC_CONST;
#define DBUS_TRANSPORT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TYPE_TRANSPORT, DBusTransportPrivate))
enum  {
	DBUS_TRANSPORT_DUMMY_PROPERTY
};
DBusTransport* dbus_transport_new (void);
DBusTransport* dbus_transport_construct (GType object_type);
static void dbus_transport_on_bus_aquired (DBusTransport* self, GDBusConnection* conn);
static void dbus_transport_on_name_acquired (DBusTransport* self, GDBusConnection* conn, const gchar* name);
static void dbus_transport_on_name_lost (DBusTransport* self, GDBusConnection* conn, const gchar* name);
void dbus_transport_run (DBusTransport* self);
static void _dbus_transport_on_bus_aquired_gbus_acquired_callback (GDBusConnection* connection, const gchar* name, gpointer self);
static void _dbus_transport_on_name_acquired_gbus_name_acquired_callback (GDBusConnection* connection, const gchar* name, gpointer self);
static void _dbus_transport_on_name_lost_gbus_name_lost_callback (GDBusConnection* connection, const gchar* name, gpointer self);
static void dbus_transport_finalize (DBusTransport* obj);
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 GDBusMethodInfo * const _dbus_document_iface_dbus_method_info[] = {NULL};
static const GDBusSignalInfo * const _dbus_document_iface_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _dbus_document_iface_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_document_iface_dbus_interface_info = {-1, "org.gnome.CodeAssist.v1.Document", (GDBusMethodInfo **) (&_dbus_document_iface_dbus_method_info), (GDBusSignalInfo **) (&_dbus_document_iface_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_document_iface_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_document_iface_dbus_interface_vtable = {dbus_document_iface_dbus_interface_method_call, dbus_document_iface_dbus_interface_get_property, dbus_document_iface_dbus_interface_set_property};
static const GDBusArgInfo _dbus_diagnostics_iface_dbus_arg_info_diagnostics_result = {-1, "result", "a(ua((x(xx)(xx))s)a(x(xx)(xx))s)"};
static const GDBusArgInfo * const _dbus_diagnostics_iface_dbus_arg_info_diagnostics_in[] = {NULL};
static const GDBusArgInfo * const _dbus_diagnostics_iface_dbus_arg_info_diagnostics_out[] = {&_dbus_diagnostics_iface_dbus_arg_info_diagnostics_result, NULL};
static const GDBusMethodInfo _dbus_diagnostics_iface_dbus_method_info_diagnostics = {-1, "Diagnostics", (GDBusArgInfo **) (&_dbus_diagnostics_iface_dbus_arg_info_diagnostics_in), (GDBusArgInfo **) (&_dbus_diagnostics_iface_dbus_arg_info_diagnostics_out)};
static const GDBusMethodInfo * const _dbus_diagnostics_iface_dbus_method_info[] = {&_dbus_diagnostics_iface_dbus_method_info_diagnostics, NULL};
static const GDBusSignalInfo * const _dbus_diagnostics_iface_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _dbus_diagnostics_iface_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_diagnostics_iface_dbus_interface_info = {-1, "org.gnome.CodeAssist.v1.Diagnostics", (GDBusMethodInfo **) (&_dbus_diagnostics_iface_dbus_method_info), (GDBusSignalInfo **) (&_dbus_diagnostics_iface_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_diagnostics_iface_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_diagnostics_iface_dbus_interface_vtable = {dbus_diagnostics_iface_dbus_interface_method_call, dbus_diagnostics_iface_dbus_interface_get_property, dbus_diagnostics_iface_dbus_interface_set_property};
static const GDBusMethodInfo * const _dbus_freedesktop_dbus_dbus_method_info[] = {NULL};
static const GDBusArgInfo _dbus_freedesktop_dbus_dbus_arg_info_name_owner_changed_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_freedesktop_dbus_dbus_arg_info_name_owner_changed_oldowner = {-1, "oldowner", "s"};
static const GDBusArgInfo _dbus_freedesktop_dbus_dbus_arg_info_name_owner_changed_newowner = {-1, "newowner", "s"};
static const GDBusArgInfo * const _dbus_freedesktop_dbus_dbus_arg_info_name_owner_changed[] = {&_dbus_freedesktop_dbus_dbus_arg_info_name_owner_changed_name, &_dbus_freedesktop_dbus_dbus_arg_info_name_owner_changed_oldowner, &_dbus_freedesktop_dbus_dbus_arg_info_name_owner_changed_newowner, NULL};
static const GDBusSignalInfo _dbus_freedesktop_dbus_dbus_signal_info_name_owner_changed = {-1, "NameOwnerChanged", (GDBusArgInfo **) (&_dbus_freedesktop_dbus_dbus_arg_info_name_owner_changed)};
static const GDBusSignalInfo * const _dbus_freedesktop_dbus_dbus_signal_info[] = {&_dbus_freedesktop_dbus_dbus_signal_info_name_owner_changed, NULL};
static const GDBusPropertyInfo * const _dbus_freedesktop_dbus_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_freedesktop_dbus_dbus_interface_info = {-1, "org.freedesktop.DBus", (GDBusMethodInfo **) (&_dbus_freedesktop_dbus_dbus_method_info), (GDBusSignalInfo **) (&_dbus_freedesktop_dbus_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_freedesktop_dbus_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_freedesktop_dbus_dbus_interface_vtable = {dbus_freedesktop_dbus_dbus_interface_method_call, dbus_freedesktop_dbus_dbus_interface_get_property, dbus_freedesktop_dbus_dbus_interface_set_property};
static const GDBusArgInfo _dbus_service_iface_dbus_arg_info_parse_path = {-1, "path", "s"};
static const GDBusArgInfo _dbus_service_iface_dbus_arg_info_parse_data_path = {-1, "data_path", "s"};
static const GDBusArgInfo _dbus_service_iface_dbus_arg_info_parse_cursor = {-1, "cursor", "(xx)"};
static const GDBusArgInfo _dbus_service_iface_dbus_arg_info_parse_options = {-1, "options", "a{sv}"};
static const GDBusArgInfo _dbus_service_iface_dbus_arg_info_parse_result = {-1, "result", "o"};
static const GDBusArgInfo * const _dbus_service_iface_dbus_arg_info_parse_in[] = {&_dbus_service_iface_dbus_arg_info_parse_path, &_dbus_service_iface_dbus_arg_info_parse_data_path, &_dbus_service_iface_dbus_arg_info_parse_cursor, &_dbus_service_iface_dbus_arg_info_parse_options, NULL};
static const GDBusArgInfo * const _dbus_service_iface_dbus_arg_info_parse_out[] = {&_dbus_service_iface_dbus_arg_info_parse_result, NULL};
static const GDBusMethodInfo _dbus_service_iface_dbus_method_info_parse = {-1, "Parse", (GDBusArgInfo **) (&_dbus_service_iface_dbus_arg_info_parse_in), (GDBusArgInfo **) (&_dbus_service_iface_dbus_arg_info_parse_out)};
static const GDBusArgInfo _dbus_service_iface_dbus_arg_info_dispose_path = {-1, "path", "s"};
static const GDBusArgInfo * const _dbus_service_iface_dbus_arg_info_dispose_in[] = {&_dbus_service_iface_dbus_arg_info_dispose_path, NULL};
static const GDBusArgInfo * const _dbus_service_iface_dbus_arg_info_dispose_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_iface_dbus_method_info_dispose = {-1, "Dispose", (GDBusArgInfo **) (&_dbus_service_iface_dbus_arg_info_dispose_in), (GDBusArgInfo **) (&_dbus_service_iface_dbus_arg_info_dispose_out)};
static const GDBusMethodInfo * const _dbus_service_iface_dbus_method_info[] = {&_dbus_service_iface_dbus_method_info_parse, &_dbus_service_iface_dbus_method_info_dispose, NULL};
static const GDBusSignalInfo * const _dbus_service_iface_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _dbus_service_iface_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_service_iface_dbus_interface_info = {-1, "org.gnome.CodeAssist.v1.Service", (GDBusMethodInfo **) (&_dbus_service_iface_dbus_method_info), (GDBusSignalInfo **) (&_dbus_service_iface_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_service_iface_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_service_iface_dbus_interface_vtable = {dbus_service_iface_dbus_interface_method_call, dbus_service_iface_dbus_interface_get_property, dbus_service_iface_dbus_interface_set_property};
static const GDBusArgInfo _dbus_project_iface_dbus_arg_info_parse_all_path = {-1, "path", "s"};
static const GDBusArgInfo _dbus_project_iface_dbus_arg_info_parse_all_documents = {-1, "documents", "a(ss)"};
static const GDBusArgInfo _dbus_project_iface_dbus_arg_info_parse_all_cursor = {-1, "cursor", "(xx)"};
static const GDBusArgInfo _dbus_project_iface_dbus_arg_info_parse_all_options = {-1, "options", "a{sv}"};
static const GDBusArgInfo _dbus_project_iface_dbus_arg_info_parse_all_result = {-1, "result", "a(so)"};
static const GDBusArgInfo * const _dbus_project_iface_dbus_arg_info_parse_all_in[] = {&_dbus_project_iface_dbus_arg_info_parse_all_path, &_dbus_project_iface_dbus_arg_info_parse_all_documents, &_dbus_project_iface_dbus_arg_info_parse_all_cursor, &_dbus_project_iface_dbus_arg_info_parse_all_options, NULL};
static const GDBusArgInfo * const _dbus_project_iface_dbus_arg_info_parse_all_out[] = {&_dbus_project_iface_dbus_arg_info_parse_all_result, NULL};
static const GDBusMethodInfo _dbus_project_iface_dbus_method_info_parse_all = {-1, "ParseAll", (GDBusArgInfo **) (&_dbus_project_iface_dbus_arg_info_parse_all_in), (GDBusArgInfo **) (&_dbus_project_iface_dbus_arg_info_parse_all_out)};
static const GDBusMethodInfo * const _dbus_project_iface_dbus_method_info[] = {&_dbus_project_iface_dbus_method_info_parse_all, NULL};
static const GDBusSignalInfo * const _dbus_project_iface_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _dbus_project_iface_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_project_iface_dbus_interface_info = {-1, "org.gnome.CodeAssist.v1.Project", (GDBusMethodInfo **) (&_dbus_project_iface_dbus_method_info), (GDBusSignalInfo **) (&_dbus_project_iface_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_project_iface_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_project_iface_dbus_interface_vtable = {dbus_project_iface_dbus_interface_method_call, dbus_project_iface_dbus_interface_get_property, dbus_project_iface_dbus_interface_set_property};

static gpointer _document_ref0 (gpointer self) {
	return self ? document_ref (self) : NULL;
}


DBusDocumentIface* dbus_document_iface_construct (GType object_type, Document* document) {
	DBusDocumentIface * self = NULL;
	Document* _tmp0_ = NULL;
	Document* _tmp1_ = NULL;
	self = (DBusDocumentIface*) g_object_new (object_type, NULL);
	_tmp0_ = document;
	_tmp1_ = _document_ref0 (_tmp0_);
	_document_unref0 (self->priv->d_document);
	self->priv->d_document = _tmp1_;
	return self;
}


DBusDocumentIface* dbus_document_iface_new (Document* document) {
	return dbus_document_iface_construct (DBUS_TYPE_DOCUMENT_IFACE, document);
}


static void dbus_document_iface_class_init (DBusDocumentIfaceClass * klass) {
	dbus_document_iface_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (DBusDocumentIfacePrivate));
	G_OBJECT_CLASS (klass)->finalize = dbus_document_iface_finalize;
}


static void dbus_document_iface_instance_init (DBusDocumentIface * self) {
	self->priv = DBUS_DOCUMENT_IFACE_GET_PRIVATE (self);
}


static void dbus_document_iface_finalize (GObject* obj) {
	DBusDocumentIface * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, DBUS_TYPE_DOCUMENT_IFACE, DBusDocumentIface);
	_document_unref0 (self->priv->d_document);
	G_OBJECT_CLASS (dbus_document_iface_parent_class)->finalize (obj);
}


GType dbus_document_iface_get_type (void) {
	static volatile gsize dbus_document_iface_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_document_iface_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusDocumentIfaceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_document_iface_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusDocumentIface), 0, (GInstanceInitFunc) dbus_document_iface_instance_init, NULL };
		GType dbus_document_iface_type_id;
		dbus_document_iface_type_id = g_type_register_static (G_TYPE_OBJECT, "DBusDocumentIface", &g_define_type_info, 0);
		g_type_set_qdata (dbus_document_iface_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_document_iface_register_object);
		g_once_init_leave (&dbus_document_iface_type_id__volatile, dbus_document_iface_type_id);
	}
	return dbus_document_iface_type_id__volatile;
}


static void dbus_document_iface_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];
	g_object_unref (invocation);
}


static GVariant* dbus_document_iface_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 dbus_document_iface_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 dbus_document_iface_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, (GDBusInterfaceInfo *) (&_dbus_document_iface_dbus_interface_info), &_dbus_document_iface_dbus_interface_vtable, data, _dbus_document_iface_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _dbus_document_iface_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);
}


DBusDiagnosticsIface* dbus_diagnostics_iface_construct (GType object_type, Document* document) {
	DBusDiagnosticsIface * self = NULL;
	Document* _tmp0_ = NULL;
	Document* _tmp1_ = NULL;
	self = (DBusDiagnosticsIface*) g_object_new (object_type, NULL);
	_tmp0_ = document;
	_tmp1_ = _document_ref0 (_tmp0_);
	_document_unref0 (self->priv->d_document);
	self->priv->d_document = _tmp1_;
	return self;
}


DBusDiagnosticsIface* dbus_diagnostics_iface_new (Document* document) {
	return dbus_diagnostics_iface_construct (DBUS_TYPE_DIAGNOSTICS_IFACE, document);
}


static Diagnostic* _vala_array_dup1 (Diagnostic* self, int length) {
	Diagnostic* result;
	int i;
	result = g_new0 (Diagnostic, length);
	for (i = 0; i < length; i++) {
		Diagnostic _tmp0_ = {0};
		diagnostic_copy (&self[i], &_tmp0_);
		result[i] = _tmp0_;
	}
	return result;
}


Diagnostic* dbus_diagnostics_iface_diagnostics (DBusDiagnosticsIface* self, int* result_length1) {
	Diagnostic* result = NULL;
	Document* _tmp0_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->d_document;
	if (_tmp0_ != NULL) {
		Document* _tmp1_ = NULL;
		Diagnostic* _tmp2_ = NULL;
		gint _tmp2__length1 = 0;
		Diagnostic* _tmp3_ = NULL;
		gint _tmp3__length1 = 0;
		Diagnostic* _tmp4_ = NULL;
		gint _tmp4__length1 = 0;
		Diagnostic* _tmp5_ = NULL;
		gint _tmp5__length1 = 0;
		_tmp1_ = self->priv->d_document;
		_tmp2_ = document_get_diagnostics (_tmp1_, &_tmp2__length1);
		_tmp3_ = _tmp2_;
		_tmp3__length1 = _tmp2__length1;
		_tmp4_ = (_tmp3_ != NULL) ? _vala_array_dup1 (_tmp3_, _tmp3__length1) : ((gpointer) _tmp3_);
		_tmp4__length1 = _tmp3__length1;
		_tmp5_ = _tmp4_;
		_tmp5__length1 = _tmp4__length1;
		if (result_length1) {
			*result_length1 = _tmp5__length1;
		}
		result = _tmp5_;
		return result;
	} else {
		Diagnostic* _tmp6_ = NULL;
		Diagnostic* _tmp7_ = NULL;
		gint _tmp7__length1 = 0;
		_tmp6_ = g_new0 (Diagnostic, 0);
		_tmp7_ = _tmp6_;
		_tmp7__length1 = 0;
		if (result_length1) {
			*result_length1 = _tmp7__length1;
		}
		result = _tmp7_;
		return result;
	}
}


static void dbus_diagnostics_iface_class_init (DBusDiagnosticsIfaceClass * klass) {
	dbus_diagnostics_iface_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (DBusDiagnosticsIfacePrivate));
	G_OBJECT_CLASS (klass)->finalize = dbus_diagnostics_iface_finalize;
}


static void dbus_diagnostics_iface_instance_init (DBusDiagnosticsIface * self) {
	self->priv = DBUS_DIAGNOSTICS_IFACE_GET_PRIVATE (self);
}


static void dbus_diagnostics_iface_finalize (GObject* obj) {
	DBusDiagnosticsIface * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, DBUS_TYPE_DIAGNOSTICS_IFACE, DBusDiagnosticsIface);
	_document_unref0 (self->priv->d_document);
	G_OBJECT_CLASS (dbus_diagnostics_iface_parent_class)->finalize (obj);
}


GType dbus_diagnostics_iface_get_type (void) {
	static volatile gsize dbus_diagnostics_iface_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_diagnostics_iface_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusDiagnosticsIfaceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_diagnostics_iface_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusDiagnosticsIface), 0, (GInstanceInitFunc) dbus_diagnostics_iface_instance_init, NULL };
		GType dbus_diagnostics_iface_type_id;
		dbus_diagnostics_iface_type_id = g_type_register_static (G_TYPE_OBJECT, "DBusDiagnosticsIface", &g_define_type_info, 0);
		g_type_set_qdata (dbus_diagnostics_iface_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_diagnostics_iface_register_object);
		g_once_init_leave (&dbus_diagnostics_iface_type_id__volatile, dbus_diagnostics_iface_type_id);
	}
	return dbus_diagnostics_iface_type_id__volatile;
}


static void _vala_Diagnostic_array_free (Diagnostic* array, gint array_length) {
	if (array != NULL) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			diagnostic_destroy (&array[i]);
		}
	}
	g_free (array);
}


static void _dbus_dbus_diagnostics_iface_diagnostics (DBusDiagnosticsIface* self, GVariant* _parameters_, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	Diagnostic* result;
	int result_length1 = 0;
	Diagnostic* _tmp0_;
	GVariantBuilder _tmp1_;
	int _tmp2_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	result = dbus_diagnostics_iface_diagnostics (self, &result_length1);
	_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);
	_tmp0_ = result;
	g_variant_builder_init (&_tmp1_, G_VARIANT_TYPE ("a(ua((x(xx)(xx))s)a(x(xx)(xx))s)"));
	for (_tmp2_ = 0; _tmp2_ < result_length1; _tmp2_++) {
		GVariantBuilder _tmp3_;
		Fixit* _tmp4_;
		GVariantBuilder _tmp5_;
		int _tmp6_;
		SourceRange* _tmp11_;
		GVariantBuilder _tmp12_;
		int _tmp13_;
		g_variant_builder_init (&_tmp3_, G_VARIANT_TYPE_TUPLE);
		g_variant_builder_add_value (&_tmp3_, g_variant_new_uint32 ((*_tmp0_).severity));
		_tmp4_ = (*_tmp0_).fixits;
		g_variant_builder_init (&_tmp5_, G_VARIANT_TYPE ("a((x(xx)(xx))s)"));
		for (_tmp6_ = 0; _tmp6_ < (*_tmp0_).fixits_length1; _tmp6_++) {
			GVariantBuilder _tmp7_;
			GVariantBuilder _tmp8_;
			GVariantBuilder _tmp9_;
			GVariantBuilder _tmp10_;
			g_variant_builder_init (&_tmp7_, G_VARIANT_TYPE_TUPLE);
			g_variant_builder_init (&_tmp8_, G_VARIANT_TYPE_TUPLE);
			g_variant_builder_add_value (&_tmp8_, g_variant_new_int64 ((*_tmp4_).location.file));
			g_variant_builder_init (&_tmp9_, G_VARIANT_TYPE_TUPLE);
			g_variant_builder_add_value (&_tmp9_, g_variant_new_int64 ((*_tmp4_).location.start.line));
			g_variant_builder_add_value (&_tmp9_, g_variant_new_int64 ((*_tmp4_).location.start.column));
			g_variant_builder_add_value (&_tmp8_, g_variant_builder_end (&_tmp9_));
			g_variant_builder_init (&_tmp10_, G_VARIANT_TYPE_TUPLE);
			g_variant_builder_add_value (&_tmp10_, g_variant_new_int64 ((*_tmp4_).location.end.line));
			g_variant_builder_add_value (&_tmp10_, g_variant_new_int64 ((*_tmp4_).location.end.column));
			g_variant_builder_add_value (&_tmp8_, g_variant_builder_end (&_tmp10_));
			g_variant_builder_add_value (&_tmp7_, g_variant_builder_end (&_tmp8_));
			g_variant_builder_add_value (&_tmp7_, g_variant_new_string ((*_tmp4_).replacement));
			g_variant_builder_add_value (&_tmp5_, g_variant_builder_end (&_tmp7_));
			_tmp4_++;
		}
		g_variant_builder_add_value (&_tmp3_, g_variant_builder_end (&_tmp5_));
		_tmp11_ = (*_tmp0_).locations;
		g_variant_builder_init (&_tmp12_, G_VARIANT_TYPE ("a(x(xx)(xx))"));
		for (_tmp13_ = 0; _tmp13_ < (*_tmp0_).locations_length1; _tmp13_++) {
			GVariantBuilder _tmp14_;
			GVariantBuilder _tmp15_;
			GVariantBuilder _tmp16_;
			g_variant_builder_init (&_tmp14_, G_VARIANT_TYPE_TUPLE);
			g_variant_builder_add_value (&_tmp14_, g_variant_new_int64 ((*_tmp11_).file));
			g_variant_builder_init (&_tmp15_, G_VARIANT_TYPE_TUPLE);
			g_variant_builder_add_value (&_tmp15_, g_variant_new_int64 ((*_tmp11_).start.line));
			g_variant_builder_add_value (&_tmp15_, g_variant_new_int64 ((*_tmp11_).start.column));
			g_variant_builder_add_value (&_tmp14_, g_variant_builder_end (&_tmp15_));
			g_variant_builder_init (&_tmp16_, G_VARIANT_TYPE_TUPLE);
			g_variant_builder_add_value (&_tmp16_, g_variant_new_int64 ((*_tmp11_).end.line));
			g_variant_builder_add_value (&_tmp16_, g_variant_new_int64 ((*_tmp11_).end.column));
			g_variant_builder_add_value (&_tmp14_, g_variant_builder_end (&_tmp16_));
			g_variant_builder_add_value (&_tmp12_, g_variant_builder_end (&_tmp14_));
			_tmp11_++;
		}
		g_variant_builder_add_value (&_tmp3_, g_variant_builder_end (&_tmp12_));
		g_variant_builder_add_value (&_tmp3_, g_variant_new_string ((*_tmp0_).message));
		g_variant_builder_add_value (&_tmp1_, g_variant_builder_end (&_tmp3_));
		_tmp0_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp1_));
	result = (_vala_Diagnostic_array_free (result, result_length1), 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 dbus_diagnostics_iface_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, "Diagnostics") == 0) {
		_dbus_dbus_diagnostics_iface_diagnostics (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* dbus_diagnostics_iface_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 dbus_diagnostics_iface_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 dbus_diagnostics_iface_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, (GDBusInterfaceInfo *) (&_dbus_diagnostics_iface_dbus_interface_info), &_dbus_diagnostics_iface_dbus_interface_vtable, data, _dbus_diagnostics_iface_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _dbus_diagnostics_iface_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);
}


static void g_cclosure_user_marshal_VOID__STRING_STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
	typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer data1, const char* arg_1, const char* arg_2, const char* arg_3, gpointer data2);
	register GMarshalFunc_VOID__STRING_STRING_STRING callback;
	register GCClosure * cc;
	register gpointer data1;
	register gpointer data2;
	cc = (GCClosure *) closure;
	g_return_if_fail (n_param_values == 4);
	if (G_CCLOSURE_SWAP_DATA (closure)) {
		data1 = closure->data;
		data2 = param_values->data[0].v_pointer;
	} else {
		data1 = param_values->data[0].v_pointer;
		data2 = closure->data;
	}
	callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
	callback (data1, g_value_get_string (param_values + 1), g_value_get_string (param_values + 2), g_value_get_string (param_values + 3), data2);
}


static void dbus_freedesktop_dbus_base_init (DBusFreedesktopDBusIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
		g_signal_new ("name_owner_changed", DBUS_TYPE_FREEDESKTOP_DBUS, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING_STRING, G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
	}
}


GType dbus_freedesktop_dbus_get_type (void) {
	static volatile gsize dbus_freedesktop_dbus_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_freedesktop_dbus_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusFreedesktopDBusIface), (GBaseInitFunc) dbus_freedesktop_dbus_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType dbus_freedesktop_dbus_type_id;
		dbus_freedesktop_dbus_type_id = g_type_register_static (G_TYPE_INTERFACE, "DBusFreedesktopDBus", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (dbus_freedesktop_dbus_type_id, G_TYPE_OBJECT);
		g_type_set_qdata (dbus_freedesktop_dbus_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) dbus_freedesktop_dbus_proxy_get_type);
		g_type_set_qdata (dbus_freedesktop_dbus_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.freedesktop.DBus");
		g_type_set_qdata (dbus_freedesktop_dbus_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_dbus_freedesktop_dbus_dbus_interface_info));
		g_type_set_qdata (dbus_freedesktop_dbus_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_freedesktop_dbus_register_object);
		g_once_init_leave (&dbus_freedesktop_dbus_type_id__volatile, dbus_freedesktop_dbus_type_id);
	}
	return dbus_freedesktop_dbus_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (DBusFreedesktopDBusProxy, dbus_freedesktop_dbus_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (DBUS_TYPE_FREEDESKTOP_DBUS, dbus_freedesktop_dbus_proxy_dbus_freedesktop_dbus_interface_init) )
static void dbus_freedesktop_dbus_proxy_class_init (DBusFreedesktopDBusProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = dbus_freedesktop_dbus_proxy_g_signal;
}


static void _dbus_handle_dbus_freedesktop_dbus_name_owner_changed (DBusFreedesktopDBus* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp17_;
	gchar* oldowner = NULL;
	GVariant* _tmp18_;
	gchar* newowner = NULL;
	GVariant* _tmp19_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp17_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp17_, NULL);
	g_variant_unref (_tmp17_);
	_tmp18_ = g_variant_iter_next_value (&_arguments_iter);
	oldowner = g_variant_dup_string (_tmp18_, NULL);
	g_variant_unref (_tmp18_);
	_tmp19_ = g_variant_iter_next_value (&_arguments_iter);
	newowner = g_variant_dup_string (_tmp19_, NULL);
	g_variant_unref (_tmp19_);
	g_signal_emit_by_name (self, "name-owner-changed", name, oldowner, newowner);
	_g_free0 (name);
	_g_free0 (oldowner);
	_g_free0 (newowner);
}


static void dbus_freedesktop_dbus_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
	if (strcmp (signal_name, "NameOwnerChanged") == 0) {
		_dbus_handle_dbus_freedesktop_dbus_name_owner_changed ((DBusFreedesktopDBus*) proxy, parameters);
	}
}


static void dbus_freedesktop_dbus_proxy_init (DBusFreedesktopDBusProxy* self) {
}


static void dbus_freedesktop_dbus_proxy_dbus_freedesktop_dbus_interface_init (DBusFreedesktopDBusIface* iface) {
}


static void dbus_freedesktop_dbus_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];
	g_object_unref (invocation);
}


static GVariant* dbus_freedesktop_dbus_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 dbus_freedesktop_dbus_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;
}


static void _dbus_dbus_freedesktop_dbus_name_owner_changed (GObject* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (oldowner));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (newowner));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameOwnerChanged", _arguments, NULL);
}


guint dbus_freedesktop_dbus_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, (GDBusInterfaceInfo *) (&_dbus_freedesktop_dbus_dbus_interface_info), &_dbus_freedesktop_dbus_dbus_interface_vtable, data, _dbus_freedesktop_dbus_unregister_object, error);
	if (!result) {
		return 0;
	}
	g_signal_connect (object, "name-owner-changed", (GCallback) _dbus_dbus_freedesktop_dbus_name_owner_changed, data);
	return result;
}


static void _dbus_freedesktop_dbus_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_freedesktop_dbus_name_owner_changed, data);
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


static gpointer _dbus_server_ref0 (gpointer self) {
	return self ? dbus_server_ref (self) : NULL;
}


DBusServiceIface* dbus_service_iface_construct (GType object_type, DBusServer* server) {
	DBusServiceIface * self = NULL;
	DBusServer* _tmp0_ = NULL;
	DBusServer* _tmp1_ = NULL;
	g_return_val_if_fail (server != NULL, NULL);
	self = (DBusServiceIface*) g_object_new (object_type, NULL);
	_tmp0_ = server;
	_tmp1_ = _dbus_server_ref0 (_tmp0_);
	_dbus_server_unref0 (self->priv->d_server);
	self->priv->d_server = _tmp1_;
	return self;
}


DBusServiceIface* dbus_service_iface_new (DBusServer* server) {
	return dbus_service_iface_construct (DBUS_TYPE_SERVICE_IFACE, server);
}


static void dbus_service_iface_parse_data_free (gpointer _data) {
	DbusServiceIfaceParseData* _data_;
	_data_ = _data;
	_g_free0 (_data_->path);
	_g_free0 (_data_->data_path);
	_g_hash_table_unref0 (_data_->options);
	_g_free0 (_data_->sender);
	_g_free0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceIfaceParseData, _data_);
}


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


static gpointer _g_hash_table_ref0 (gpointer self) {
	return self ? g_hash_table_ref (self) : NULL;
}


void dbus_service_iface_parse (DBusServiceIface* self, const gchar* path, const gchar* data_path, SourceLocation* cursor, GHashTable* options, const char* sender, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DbusServiceIfaceParseData* _data_;
	DBusServiceIface* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	const gchar* _tmp3_ = NULL;
	gchar* _tmp4_ = NULL;
	SourceLocation _tmp5_ = {0};
	GHashTable* _tmp6_ = NULL;
	GHashTable* _tmp7_ = NULL;
	const char* _tmp8_ = NULL;
	char* _tmp9_ = NULL;
	_data_ = g_slice_new0 (DbusServiceIfaceParseData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_iface_parse);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_iface_parse_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = path;
	_tmp2_ = g_strdup (_tmp1_);
	_g_free0 (_data_->path);
	_data_->path = _tmp2_;
	_tmp3_ = data_path;
	_tmp4_ = g_strdup (_tmp3_);
	_g_free0 (_data_->data_path);
	_data_->data_path = _tmp4_;
	_tmp5_ = *cursor;
	_data_->cursor = _tmp5_;
	_tmp6_ = options;
	_tmp7_ = _g_hash_table_ref0 (_tmp6_);
	_g_hash_table_unref0 (_data_->options);
	_data_->options = _tmp7_;
	_tmp8_ = sender;
	_tmp9_ = g_strdup (_tmp8_);
	_g_free0 (_data_->sender);
	_data_->sender = _tmp9_;
	dbus_service_iface_parse_co (_data_);
}


char* dbus_service_iface_parse_finish (DBusServiceIface* self, GAsyncResult* _res_, GError** error) {
	char* result;
	DbusServiceIfaceParseData* _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 dbus_service_iface_parse_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceIfaceParseData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_iface_parse_co (_data_);
}


static gboolean dbus_service_iface_parse_co (DbusServiceIfaceParseData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = _data_->self->priv->d_server;
	_data_->_tmp2_ = NULL;
	_data_->_tmp2_ = _data_->path;
	_data_->_tmp3_ = NULL;
	_data_->_tmp3_ = _data_->data_path;
	memset (&_data_->_tmp4_, 0, sizeof (SourceLocation));
	_data_->_tmp4_ = _data_->cursor;
	_data_->_tmp5_ = NULL;
	_data_->_tmp5_ = _data_->options;
	_data_->_tmp6_ = NULL;
	_data_->_tmp6_ = _data_->sender;
	_data_->_state_ = 1;
	dbus_server_parse (_data_->_tmp1_, _data_->_tmp2_, _data_->_tmp3_, &_data_->_tmp4_, _data_->_tmp5_, _data_->_tmp6_, dbus_service_iface_parse_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp7_ = NULL;
	_data_->_tmp7_ = dbus_server_parse_finish (_data_->_tmp1_, _data_->_res_, &_data_->_inner_error_);
	_data_->_tmp0_ = _data_->_tmp7_;
	if (G_UNLIKELY (_data_->_inner_error_ != NULL)) {
		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;
	}
	_data_->_tmp8_ = NULL;
	_data_->_tmp8_ = _data_->_tmp0_;
	_data_->_tmp0_ = NULL;
	_data_->result = _data_->_tmp8_;
	_g_free0 (_data_->_tmp0_);
	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_->_tmp0_);
	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;
}


void dbus_service_iface_dispose (DBusServiceIface* self, const gchar* path, const char* sender) {
	DBusServer* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	const char* _tmp2_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (path != NULL);
	g_return_if_fail (sender != NULL);
	_tmp0_ = self->priv->d_server;
	_tmp1_ = path;
	_tmp2_ = sender;
	dbus_server_dispose (_tmp0_, _tmp1_, _tmp2_);
}


static void dbus_service_iface_class_init (DBusServiceIfaceClass * klass) {
	dbus_service_iface_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (DBusServiceIfacePrivate));
	G_OBJECT_CLASS (klass)->finalize = dbus_service_iface_finalize;
}


static void dbus_service_iface_instance_init (DBusServiceIface * self) {
	self->priv = DBUS_SERVICE_IFACE_GET_PRIVATE (self);
}


static void dbus_service_iface_finalize (GObject* obj) {
	DBusServiceIface * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, DBUS_TYPE_SERVICE_IFACE, DBusServiceIface);
	_dbus_server_unref0 (self->priv->d_server);
	G_OBJECT_CLASS (dbus_service_iface_parent_class)->finalize (obj);
}


GType dbus_service_iface_get_type (void) {
	static volatile gsize dbus_service_iface_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_service_iface_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusServiceIfaceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_service_iface_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusServiceIface), 0, (GInstanceInitFunc) dbus_service_iface_instance_init, NULL };
		GType dbus_service_iface_type_id;
		dbus_service_iface_type_id = g_type_register_static (G_TYPE_OBJECT, "DBusServiceIface", &g_define_type_info, 0);
		g_type_set_qdata (dbus_service_iface_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_service_iface_register_object);
		g_once_init_leave (&dbus_service_iface_type_id__volatile, dbus_service_iface_type_id);
	}
	return dbus_service_iface_type_id__volatile;
}


static void _dbus_dbus_service_iface_parse (DBusServiceIface* self, GVariant* _parameters_, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* path = NULL;
	GVariant* _tmp20_;
	gchar* data_path = NULL;
	GVariant* _tmp21_;
	SourceLocation cursor = {0};
	GVariant* _tmp22_;
	SourceLocation _tmp23_;
	GVariantIter _tmp24_;
	GVariant* _tmp25_;
	GVariant* _tmp26_;
	GHashTable* options = NULL;
	GVariant* _tmp27_;
	GHashTable* _tmp28_;
	GVariantIter _tmp29_;
	GVariant* _tmp30_;
	GVariant* _tmp31_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_tmp20_ = g_variant_iter_next_value (&_arguments_iter);
	path = g_variant_dup_string (_tmp20_, NULL);
	g_variant_unref (_tmp20_);
	_tmp21_ = g_variant_iter_next_value (&_arguments_iter);
	data_path = g_variant_dup_string (_tmp21_, NULL);
	g_variant_unref (_tmp21_);
	_tmp22_ = g_variant_iter_next_value (&_arguments_iter);
	g_variant_iter_init (&_tmp24_, _tmp22_);
	_tmp25_ = g_variant_iter_next_value (&_tmp24_);
	_tmp23_.line = g_variant_get_int64 (_tmp25_);
	g_variant_unref (_tmp25_);
	_tmp26_ = g_variant_iter_next_value (&_tmp24_);
	_tmp23_.column = g_variant_get_int64 (_tmp26_);
	g_variant_unref (_tmp26_);
	cursor = _tmp23_;
	g_variant_unref (_tmp22_);
	_tmp27_ = g_variant_iter_next_value (&_arguments_iter);
	_tmp28_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
	g_variant_iter_init (&_tmp29_, _tmp27_);
	while (g_variant_iter_loop (&_tmp29_, "{?*}", &_tmp30_, &_tmp31_)) {
		g_hash_table_insert (_tmp28_, g_variant_dup_string (_tmp30_, NULL), g_variant_get_variant (_tmp31_));
	}
	options = _tmp28_;
	g_variant_unref (_tmp27_);
	dbus_service_iface_parse (self, path, data_path, &cursor, options, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_dbus_service_iface_parse_ready, invocation);
	_g_free0 (path);
	_g_free0 (data_path);
	_g_hash_table_unref0 (options);
}


static void _dbus_dbus_service_iface_parse_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	char* result;
	invocation = _user_data_;
	result = dbus_service_iface_parse_finish ((DBusServiceIface*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (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);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_object_path (result));
	_g_free0 (result);
	_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 _dbus_dbus_service_iface_dispose (DBusServiceIface* self, GVariant* _parameters_, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* path = NULL;
	GVariant* _tmp32_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_tmp32_ = g_variant_iter_next_value (&_arguments_iter);
	path = g_variant_dup_string (_tmp32_, NULL);
	g_variant_unref (_tmp32_);
	dbus_service_iface_dispose (self, path, g_dbus_method_invocation_get_sender (invocation));
	_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 (path);
	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_service_iface_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, "Parse") == 0) {
		_dbus_dbus_service_iface_parse (object, parameters, invocation);
	} else if (strcmp (method_name, "Dispose") == 0) {
		_dbus_dbus_service_iface_dispose (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* dbus_service_iface_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 dbus_service_iface_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 dbus_service_iface_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, (GDBusInterfaceInfo *) (&_dbus_service_iface_dbus_interface_info), &_dbus_service_iface_dbus_interface_vtable, data, _dbus_service_iface_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _dbus_service_iface_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);
}


DBusProjectIface* dbus_project_iface_construct (GType object_type, DBusServer* server) {
	DBusProjectIface * self = NULL;
	DBusServer* _tmp0_ = NULL;
	DBusServer* _tmp1_ = NULL;
	g_return_val_if_fail (server != NULL, NULL);
	self = (DBusProjectIface*) g_object_new (object_type, NULL);
	_tmp0_ = server;
	_tmp1_ = _dbus_server_ref0 (_tmp0_);
	_dbus_server_unref0 (self->priv->d_server);
	self->priv->d_server = _tmp1_;
	return self;
}


DBusProjectIface* dbus_project_iface_new (DBusServer* server) {
	return dbus_project_iface_construct (DBUS_TYPE_PROJECT_IFACE, server);
}


static void _vala_RemoteDocument_array_free (RemoteDocument* array, gint array_length) {
	if (array != NULL) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			remote_document_destroy (&array[i]);
		}
	}
	g_free (array);
}


static void dbus_project_iface_parse_all_data_free (gpointer _data) {
	DbusProjectIfaceParseAllData* _data_;
	_data_ = _data;
	_g_free0 (_data_->path);
	_g_hash_table_unref0 (_data_->options);
	_g_free0 (_data_->sender);
	_data_->result = (_vala_RemoteDocument_array_free (_data_->result, _data_->result_length1), NULL);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusProjectIfaceParseAllData, _data_);
}


void dbus_project_iface_parse_all (DBusProjectIface* self, const gchar* path, OpenDocument* documents, int documents_length1, SourceLocation* cursor, GHashTable* options, const char* sender, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DbusProjectIfaceParseAllData* _data_;
	DBusProjectIface* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	OpenDocument* _tmp3_ = NULL;
	gint _tmp3__length1 = 0;
	SourceLocation _tmp4_ = {0};
	GHashTable* _tmp5_ = NULL;
	GHashTable* _tmp6_ = NULL;
	const char* _tmp7_ = NULL;
	char* _tmp8_ = NULL;
	_data_ = g_slice_new0 (DbusProjectIfaceParseAllData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_project_iface_parse_all);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_project_iface_parse_all_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = path;
	_tmp2_ = g_strdup (_tmp1_);
	_g_free0 (_data_->path);
	_data_->path = _tmp2_;
	_tmp3_ = documents;
	_tmp3__length1 = documents_length1;
	_data_->documents = _tmp3_;
	_data_->documents_length1 = _tmp3__length1;
	_tmp4_ = *cursor;
	_data_->cursor = _tmp4_;
	_tmp5_ = options;
	_tmp6_ = _g_hash_table_ref0 (_tmp5_);
	_g_hash_table_unref0 (_data_->options);
	_data_->options = _tmp6_;
	_tmp7_ = sender;
	_tmp8_ = g_strdup (_tmp7_);
	_g_free0 (_data_->sender);
	_data_->sender = _tmp8_;
	dbus_project_iface_parse_all_co (_data_);
}


RemoteDocument* dbus_project_iface_parse_all_finish (DBusProjectIface* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	RemoteDocument* result;
	DbusProjectIfaceParseAllData* _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;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static void dbus_project_iface_parse_all_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusProjectIfaceParseAllData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_project_iface_parse_all_co (_data_);
}


static gboolean dbus_project_iface_parse_all_co (DbusProjectIfaceParseAllData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = _data_->self->priv->d_server;
	_data_->_tmp2_ = NULL;
	_data_->_tmp2_ = _data_->path;
	_data_->_tmp3_ = NULL;
	_data_->_tmp3__length1 = 0;
	_data_->_tmp3_ = _data_->documents;
	_data_->_tmp3__length1 = _data_->documents_length1;
	memset (&_data_->_tmp4_, 0, sizeof (SourceLocation));
	_data_->_tmp4_ = _data_->cursor;
	_data_->_tmp5_ = NULL;
	_data_->_tmp5_ = _data_->options;
	_data_->_tmp6_ = NULL;
	_data_->_tmp6_ = _data_->sender;
	_data_->_tmp7_ = 0;
	_data_->_state_ = 1;
	dbus_server_parse_all (_data_->_tmp1_, _data_->_tmp2_, _data_->_tmp3_, _data_->_tmp3__length1, &_data_->_tmp4_, _data_->_tmp5_, _data_->_tmp6_, dbus_project_iface_parse_all_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp8_ = NULL;
	_data_->_tmp8_ = dbus_server_parse_all_finish (_data_->_tmp1_, _data_->_res_, &_data_->_tmp7_, &_data_->_inner_error_);
	_data_->_tmp0__length1 = 0;
	_data_->__tmp0__size_ = 0;
	_data_->_tmp0_ = _data_->_tmp8_;
	_data_->_tmp0__length1 = _data_->_tmp7_;
	_data_->__tmp0__size_ = _data_->_tmp0__length1;
	if (G_UNLIKELY (_data_->_inner_error_ != NULL)) {
		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;
	}
	_data_->_tmp9_ = NULL;
	_data_->_tmp9__length1 = 0;
	_data_->_tmp9_ = _data_->_tmp0_;
	_data_->_tmp9__length1 = _data_->_tmp0__length1;
	_data_->_tmp0_ = NULL;
	_data_->_tmp0__length1 = 0;
	_data_->_tmp10_ = NULL;
	_data_->_tmp10__length1 = 0;
	_data_->_tmp10_ = _data_->_tmp9_;
	_data_->_tmp10__length1 = _data_->_tmp9__length1;
	_data_->result_length1 = _data_->_tmp10__length1;
	_data_->result = _data_->_tmp10_;
	_data_->_tmp0_ = (_vala_RemoteDocument_array_free (_data_->_tmp0_, _data_->_tmp0__length1), 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_->_tmp0_ = (_vala_RemoteDocument_array_free (_data_->_tmp0_, _data_->_tmp0__length1), 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 dbus_project_iface_class_init (DBusProjectIfaceClass * klass) {
	dbus_project_iface_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (DBusProjectIfacePrivate));
	G_OBJECT_CLASS (klass)->finalize = dbus_project_iface_finalize;
}


static void dbus_project_iface_instance_init (DBusProjectIface * self) {
	self->priv = DBUS_PROJECT_IFACE_GET_PRIVATE (self);
}


static void dbus_project_iface_finalize (GObject* obj) {
	DBusProjectIface * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, DBUS_TYPE_PROJECT_IFACE, DBusProjectIface);
	_dbus_server_unref0 (self->priv->d_server);
	G_OBJECT_CLASS (dbus_project_iface_parent_class)->finalize (obj);
}


GType dbus_project_iface_get_type (void) {
	static volatile gsize dbus_project_iface_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_project_iface_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusProjectIfaceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_project_iface_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusProjectIface), 0, (GInstanceInitFunc) dbus_project_iface_instance_init, NULL };
		GType dbus_project_iface_type_id;
		dbus_project_iface_type_id = g_type_register_static (G_TYPE_OBJECT, "DBusProjectIface", &g_define_type_info, 0);
		g_type_set_qdata (dbus_project_iface_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_project_iface_register_object);
		g_once_init_leave (&dbus_project_iface_type_id__volatile, dbus_project_iface_type_id);
	}
	return dbus_project_iface_type_id__volatile;
}


static void _vala_OpenDocument_array_free (OpenDocument* array, gint array_length) {
	if (array != NULL) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			open_document_destroy (&array[i]);
		}
	}
	g_free (array);
}


static void _dbus_dbus_project_iface_parse_all (DBusProjectIface* self, GVariant* _parameters_, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* path = NULL;
	GVariant* _tmp33_;
	OpenDocument* documents = NULL;
	int documents_length1 = 0;
	GVariant* _tmp34_;
	OpenDocument* _tmp35_;
	int _tmp35__length;
	int _tmp35__size;
	int _tmp35__length1;
	GVariantIter _tmp36_;
	GVariant* _tmp37_;
	SourceLocation cursor = {0};
	GVariant* _tmp42_;
	SourceLocation _tmp43_;
	GVariantIter _tmp44_;
	GVariant* _tmp45_;
	GVariant* _tmp46_;
	GHashTable* options = NULL;
	GVariant* _tmp47_;
	GHashTable* _tmp48_;
	GVariantIter _tmp49_;
	GVariant* _tmp50_;
	GVariant* _tmp51_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_tmp33_ = g_variant_iter_next_value (&_arguments_iter);
	path = g_variant_dup_string (_tmp33_, NULL);
	g_variant_unref (_tmp33_);
	_tmp34_ = g_variant_iter_next_value (&_arguments_iter);
	_tmp35_ = g_new (OpenDocument, 5);
	_tmp35__length = 0;
	_tmp35__size = 4;
	_tmp35__length1 = 0;
	g_variant_iter_init (&_tmp36_, _tmp34_);
	for (; (_tmp37_ = g_variant_iter_next_value (&_tmp36_)) != NULL; _tmp35__length1++) {
		OpenDocument _tmp38_;
		GVariantIter _tmp39_;
		GVariant* _tmp40_;
		GVariant* _tmp41_;
		if (_tmp35__size == _tmp35__length) {
			_tmp35__size = 2 * _tmp35__size;
			_tmp35_ = g_renew (OpenDocument, _tmp35_, _tmp35__size + 1);
		}
		g_variant_iter_init (&_tmp39_, _tmp37_);
		_tmp40_ = g_variant_iter_next_value (&_tmp39_);
		_tmp38_.path = g_variant_dup_string (_tmp40_, NULL);
		g_variant_unref (_tmp40_);
		_tmp41_ = g_variant_iter_next_value (&_tmp39_);
		_tmp38_.data_path = g_variant_dup_string (_tmp41_, NULL);
		g_variant_unref (_tmp41_);
		_tmp35_[_tmp35__length++] = _tmp38_;
		g_variant_unref (_tmp37_);
	}
	documents_length1 = _tmp35__length1;
	documents = _tmp35_;
	g_variant_unref (_tmp34_);
	_tmp42_ = g_variant_iter_next_value (&_arguments_iter);
	g_variant_iter_init (&_tmp44_, _tmp42_);
	_tmp45_ = g_variant_iter_next_value (&_tmp44_);
	_tmp43_.line = g_variant_get_int64 (_tmp45_);
	g_variant_unref (_tmp45_);
	_tmp46_ = g_variant_iter_next_value (&_tmp44_);
	_tmp43_.column = g_variant_get_int64 (_tmp46_);
	g_variant_unref (_tmp46_);
	cursor = _tmp43_;
	g_variant_unref (_tmp42_);
	_tmp47_ = g_variant_iter_next_value (&_arguments_iter);
	_tmp48_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
	g_variant_iter_init (&_tmp49_, _tmp47_);
	while (g_variant_iter_loop (&_tmp49_, "{?*}", &_tmp50_, &_tmp51_)) {
		g_hash_table_insert (_tmp48_, g_variant_dup_string (_tmp50_, NULL), g_variant_get_variant (_tmp51_));
	}
	options = _tmp48_;
	g_variant_unref (_tmp47_);
	dbus_project_iface_parse_all (self, path, documents, documents_length1, &cursor, options, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_dbus_project_iface_parse_all_ready, invocation);
	_g_free0 (path);
	documents = (_vala_OpenDocument_array_free (documents, documents_length1), NULL);
	_g_hash_table_unref0 (options);
}


static void _dbus_dbus_project_iface_parse_all_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	RemoteDocument* result;
	int result_length1 = 0;
	RemoteDocument* _tmp52_;
	GVariantBuilder _tmp53_;
	int _tmp54_;
	invocation = _user_data_;
	result = dbus_project_iface_parse_all_finish ((DBusProjectIface*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (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);
	_tmp52_ = result;
	g_variant_builder_init (&_tmp53_, G_VARIANT_TYPE ("a(so)"));
	for (_tmp54_ = 0; _tmp54_ < result_length1; _tmp54_++) {
		GVariantBuilder _tmp55_;
		g_variant_builder_init (&_tmp55_, G_VARIANT_TYPE_TUPLE);
		g_variant_builder_add_value (&_tmp55_, g_variant_new_string ((*_tmp52_).path));
		g_variant_builder_add_value (&_tmp55_, g_variant_new_object_path ((*_tmp52_).remote_path));
		g_variant_builder_add_value (&_tmp53_, g_variant_builder_end (&_tmp55_));
		_tmp52_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp53_));
	result = (_vala_RemoteDocument_array_free (result, result_length1), 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 dbus_project_iface_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, "ParseAll") == 0) {
		_dbus_dbus_project_iface_parse_all (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* dbus_project_iface_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 dbus_project_iface_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 dbus_project_iface_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, (GDBusInterfaceInfo *) (&_dbus_project_iface_dbus_interface_info), &_dbus_project_iface_dbus_interface_vtable, data, _dbus_project_iface_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _dbus_project_iface_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);
}


static gpointer _g_main_loop_ref0 (gpointer self) {
	return self ? g_main_loop_ref (self) : NULL;
}


static void _dbus_server_on_name_owner_changed_dbus_freedesktop_dbus_name_owner_changed (DBusFreedesktopDBus* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer self) {
	dbus_server_on_name_owner_changed ((DBusServer*) self, name, oldowner, newowner);
}


static void __lambda8_ (DBusServer* self, GObject* obj, GAsyncResult* res) {
	GError * _inner_error_ = NULL;
	g_return_if_fail (res != NULL);
	{
		DBusFreedesktopDBus* _tmp0_ = NULL;
		GAsyncResult* _tmp1_ = NULL;
		DBusFreedesktopDBus* _tmp2_ = NULL;
		DBusFreedesktopDBus* _tmp3_ = NULL;
		DBusFreedesktopDBus* _tmp4_ = NULL;
		DBusFreedesktopDBus* _tmp5_ = NULL;
		_tmp1_ = res;
		_tmp2_ = g_async_result_get_source_object (_tmp1_);
		_tmp3_ = g_async_initable_new_finish (_tmp2_, _tmp1_, &_inner_error_);
		g_object_unref (_tmp2_);
		_tmp0_ = (DBusFreedesktopDBus*) _tmp3_;
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			goto __catch1_g_error;
		}
		_tmp4_ = _tmp0_;
		_tmp0_ = NULL;
		_g_object_unref0 (self->priv->d_proxy);
		self->priv->d_proxy = _tmp4_;
		_tmp5_ = self->priv->d_proxy;
		g_signal_connect (_tmp5_, "name-owner-changed", (GCallback) _dbus_server_on_name_owner_changed_dbus_freedesktop_dbus_name_owner_changed, self);
		_g_object_unref0 (_tmp0_);
	}
	goto __finally1;
	__catch1_g_error:
	{
		g_clear_error (&_inner_error_);
		_inner_error_ = NULL;
		return;
	}
	__finally1:
	if (G_UNLIKELY (_inner_error_ != NULL)) {
		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 ___lambda8__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	__lambda8_ ((DBusServer*) self, source_object, res);
	dbus_server_unref (self);
}


DBusServer* dbus_server_construct (GType object_type, GMainLoop* mloop, GDBusConnection* conn) {
	DBusServer* self = NULL;
	GMainLoop* _tmp0_ = NULL;
	GMainLoop* _tmp1_ = NULL;
	GDBusConnection* _tmp2_ = NULL;
	GDBusConnection* _tmp3_ = NULL;
	GeeHashMap* _tmp4_ = NULL;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (mloop != NULL, NULL);
	g_return_val_if_fail (conn != NULL, NULL);
	self = (DBusServer*) g_type_create_instance (object_type);
	_tmp0_ = mloop;
	_tmp1_ = _g_main_loop_ref0 (_tmp0_);
	_g_main_loop_unref0 (self->priv->d_main);
	self->priv->d_main = _tmp1_;
	_tmp2_ = conn;
	_tmp3_ = _g_object_ref0 (_tmp2_);
	_g_object_unref0 (self->priv->d_conn);
	self->priv->d_conn = _tmp3_;
	_tmp4_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, DBUS_SERVER_TYPE_APP, (GBoxedCopyFunc) dbus_server_app_ref, dbus_server_app_unref, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	_g_object_unref0 (self->priv->d_apps);
	self->priv->d_apps = _tmp4_;
	self->priv->d_nextid = (guint) 0;
	g_async_initable_new_async (DBUS_TYPE_FREEDESKTOP_DBUS_PROXY, 0, NULL, ___lambda8__gasync_ready_callback, dbus_server_ref (self), "g-flags", 0, "g-name", "org.freedesktop.DBus", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/freedesktop/DBus", "g-interface-name", "org.freedesktop.DBus", "g-interface-info", g_type_get_qdata (DBUS_TYPE_FREEDESKTOP_DBUS, g_quark_from_static_string ("vala-dbus-interface-info")), NULL);
	return self;
}


DBusServer* dbus_server_new (GMainLoop* mloop, GDBusConnection* conn) {
	return dbus_server_construct (DBUS_TYPE_SERVER, mloop, conn);
}


static void dbus_server_on_name_owner_changed (DBusServer* self, const gchar* name, const gchar* oldowner, const gchar* newowner) {
	gboolean _tmp0_ = FALSE;
	const gchar* _tmp1_ = NULL;
	GError * _inner_error_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (name != NULL);
	g_return_if_fail (oldowner != NULL);
	g_return_if_fail (newowner != NULL);
	_tmp1_ = newowner;
	if (g_strcmp0 (_tmp1_, "") == 0) {
		GeeHashMap* _tmp2_ = NULL;
		const gchar* _tmp3_ = NULL;
		gboolean _tmp4_ = FALSE;
		_tmp2_ = self->priv->d_apps;
		_tmp3_ = oldowner;
		_tmp4_ = gee_abstract_map_has_key ((GeeAbstractMap*) _tmp2_, _tmp3_);
		_tmp0_ = _tmp4_;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		{
			GeeHashMap* _tmp5_ = NULL;
			_tmp5_ = self->priv->d_apps;
			g_rec_mutex_lock (&self->priv->__lock_d_apps);
			{
				GeeHashMap* _tmp6_ = NULL;
				const gchar* _tmp7_ = NULL;
				gpointer _tmp8_ = NULL;
				DBusServerApp* _tmp9_ = NULL;
				_tmp6_ = self->priv->d_apps;
				_tmp7_ = oldowner;
				_tmp8_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp6_, _tmp7_);
				_tmp9_ = (DBusServerApp*) _tmp8_;
				dbus_server_dispose_app (self, _tmp9_);
				_dbus_server_app_unref0 (_tmp9_);
			}
			__finally2:
			{
				GeeHashMap* _tmp10_ = NULL;
				_tmp10_ = self->priv->d_apps;
				g_rec_mutex_unlock (&self->priv->__lock_d_apps);
			}
			if (G_UNLIKELY (_inner_error_ != NULL)) {
				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 DBusServerApp* dbus_server_make_app (DBusServer* self, const gchar* name) {
	DBusServerApp* result = NULL;
	DBusServerApp* app = NULL;
	guint _tmp0_ = 0U;
	const gchar* _tmp1_ = NULL;
	DBusServerApp* _tmp2_ = NULL;
	guint _tmp3_ = 0U;
	GeeHashMap* _tmp4_ = NULL;
	const gchar* _tmp5_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (name != NULL, NULL);
	_tmp0_ = self->priv->d_nextid;
	_tmp1_ = name;
	_tmp2_ = dbus_server_app_new (_tmp0_, _tmp1_);
	app = _tmp2_;
	_tmp3_ = self->priv->d_nextid;
	self->priv->d_nextid = _tmp3_ + 1;
	_tmp4_ = self->priv->d_apps;
	_tmp5_ = name;
	gee_abstract_map_set ((GeeAbstractMap*) _tmp4_, _tmp5_, app);
	result = app;
	return result;
}


static DBusServerApp* dbus_server_ensure_app (DBusServer* self, const gchar* name) {
	DBusServerApp* result = NULL;
	GeeHashMap* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	gboolean _tmp2_ = FALSE;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (name != NULL, NULL);
	_tmp0_ = self->priv->d_apps;
	_tmp1_ = name;
	_tmp2_ = gee_abstract_map_has_key ((GeeAbstractMap*) _tmp0_, _tmp1_);
	if (_tmp2_) {
		GeeHashMap* _tmp3_ = NULL;
		const gchar* _tmp4_ = NULL;
		gpointer _tmp5_ = NULL;
		_tmp3_ = self->priv->d_apps;
		_tmp4_ = name;
		_tmp5_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp3_, _tmp4_);
		result = (DBusServerApp*) _tmp5_;
		return result;
	} else {
		const gchar* _tmp6_ = NULL;
		DBusServerApp* _tmp7_ = NULL;
		_tmp6_ = name;
		_tmp7_ = dbus_server_make_app (self, _tmp6_);
		result = _tmp7_;
		return result;
	}
}


static gchar* dbus_server_clean_path (DBusServer* self, const gchar* path) {
	gchar* result = NULL;
	const gchar* _tmp0_ = NULL;
	gint _tmp1_ = 0;
	gint _tmp2_ = 0;
	const gchar* _tmp5_ = NULL;
	GFile* _tmp6_ = NULL;
	GFile* _tmp7_ = NULL;
	gchar* _tmp8_ = NULL;
	gchar* _tmp9_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (path != NULL, NULL);
	_tmp0_ = path;
	_tmp1_ = strlen (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ == 0) {
		const gchar* _tmp3_ = NULL;
		gchar* _tmp4_ = NULL;
		_tmp3_ = path;
		_tmp4_ = g_strdup (_tmp3_);
		result = _tmp4_;
		return result;
	}
	_tmp5_ = path;
	_tmp6_ = g_file_new_for_path (_tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = g_file_get_path (_tmp7_);
	_tmp9_ = _tmp8_;
	_g_object_unref0 (_tmp7_);
	result = _tmp9_;
	return result;
}


static DBusServerExportedDocument* dbus_server_make_document (DBusServer* self, DBusServerApp* app, const gchar* path, const gchar* client_path) {
	DBusServerExportedDocument* result = NULL;
	Document* ndoc = NULL;
	DBusServerApp* _tmp0_ = NULL;
	guint _tmp1_ = 0U;
	const gchar* _tmp2_ = NULL;
	Document* _tmp3_ = NULL;
	Document* _tmp4_ = NULL;
	const gchar* _tmp5_ = NULL;
	DBusServerExportedDocument* doc = NULL;
	Document* _tmp6_ = NULL;
	DBusServerExportedDocument* _tmp7_ = NULL;
	char* rpath = NULL;
	DBusServerApp* _tmp8_ = NULL;
	Document* _tmp9_ = NULL;
	char* _tmp10_ = NULL;
	DBusServerApp* _tmp28_ = NULL;
	GeeHashMap* _tmp29_ = NULL;
	const gchar* _tmp30_ = NULL;
	DBusServerExportedDocument* _tmp31_ = NULL;
	DBusServerApp* _tmp32_ = NULL;
	guint _tmp33_ = 0U;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (app != NULL, NULL);
	g_return_val_if_fail (path != NULL, NULL);
	g_return_val_if_fail (client_path != NULL, NULL);
	_tmp0_ = app;
	_tmp1_ = _tmp0_->nextid;
	_tmp2_ = path;
	_tmp3_ = document_new (_tmp1_, _tmp2_);
	ndoc = _tmp3_;
	_tmp4_ = ndoc;
	_tmp5_ = client_path;
	document_set_client_path (_tmp4_, _tmp5_);
	_tmp6_ = ndoc;
	_tmp7_ = dbus_server_exported_document_new (_tmp6_);
	doc = _tmp7_;
	_tmp8_ = app;
	_tmp9_ = ndoc;
	_tmp10_ = dbus_server_remote_document_path (self, _tmp8_, _tmp9_);
	rpath = _tmp10_;
	{
		guint _tmp11_ = 0U;
		GDBusConnection* _tmp12_ = NULL;
		const char* _tmp13_ = NULL;
		DBusServerExportedDocument* _tmp14_ = NULL;
		DBusDocumentIface* _tmp15_ = NULL;
		guint _tmp16_ = 0U;
		DBusServerExportedDocument* _tmp17_ = NULL;
		guint _tmp18_ = 0U;
		GDBusConnection* _tmp19_ = NULL;
		const char* _tmp20_ = NULL;
		DBusServerExportedDocument* _tmp21_ = NULL;
		DBusDiagnosticsIface* _tmp22_ = NULL;
		guint _tmp23_ = 0U;
		DBusServerExportedDocument* _tmp24_ = NULL;
		_tmp12_ = self->priv->d_conn;
		_tmp13_ = rpath;
		_tmp14_ = doc;
		_tmp15_ = _tmp14_->ddocument;
		_tmp16_ = dbus_document_iface_register_object (_tmp15_, _tmp12_, (const gchar*) _tmp13_, &_inner_error_);
		_tmp11_ = _tmp16_;
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			if (_inner_error_->domain == G_IO_ERROR) {
				goto __catch3_g_io_error;
			}
			_g_free0 (rpath);
			_dbus_server_exported_document_unref0 (doc);
			_document_unref0 (ndoc);
			g_critical ("file %s: line %d: unexpected 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;
		}
		_tmp17_ = doc;
		_tmp17_->ddocument_regid = _tmp11_;
		_tmp19_ = self->priv->d_conn;
		_tmp20_ = rpath;
		_tmp21_ = doc;
		_tmp22_ = _tmp21_->ddiagnostics;
		_tmp23_ = dbus_diagnostics_iface_register_object (_tmp22_, _tmp19_, (const gchar*) _tmp20_, &_inner_error_);
		_tmp18_ = _tmp23_;
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			if (_inner_error_->domain == G_IO_ERROR) {
				goto __catch3_g_io_error;
			}
			_g_free0 (rpath);
			_dbus_server_exported_document_unref0 (doc);
			_document_unref0 (ndoc);
			g_critical ("file %s: line %d: unexpected 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;
		}
		_tmp24_ = doc;
		_tmp24_->ddiagnostics_regid = _tmp18_;
	}
	goto __finally3;
	__catch3_g_io_error:
	{
		GError* e = NULL;
		FILE* _tmp25_ = NULL;
		GError* _tmp26_ = NULL;
		const gchar* _tmp27_ = NULL;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp25_ = stderr;
		_tmp26_ = e;
		_tmp27_ = _tmp26_->message;
		fprintf (_tmp25_, "Failed to register document: %s\n", _tmp27_);
		_g_error_free0 (e);
	}
	__finally3:
	if (G_UNLIKELY (_inner_error_ != NULL)) {
		_g_free0 (rpath);
		_dbus_server_exported_document_unref0 (doc);
		_document_unref0 (ndoc);
		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;
	}
	_tmp28_ = app;
	_tmp29_ = _tmp28_->docs;
	_tmp30_ = path;
	_tmp31_ = doc;
	gee_abstract_map_set ((GeeAbstractMap*) _tmp29_, _tmp30_, _tmp31_);
	_tmp32_ = app;
	_tmp33_ = _tmp32_->nextid;
	_tmp32_->nextid = _tmp33_ + 1;
	result = doc;
	_g_free0 (rpath);
	_document_unref0 (ndoc);
	return result;
}


static DBusServerExportedDocument* dbus_server_ensure_document (DBusServer* self, DBusServerApp* app, const gchar* path, const gchar* data_path, SourceLocation* cursor) {
	DBusServerExportedDocument* result = NULL;
	gchar* cpath = NULL;
	const gchar* _tmp0_ = NULL;
	gchar* _tmp1_ = NULL;
	DBusServerExportedDocument* doc = NULL;
	DBusServerApp* _tmp2_ = NULL;
	GeeHashMap* _tmp3_ = NULL;
	const gchar* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	gboolean _tmp14_ = FALSE;
	const gchar* _tmp15_ = NULL;
	SourceLocation* _tmp26_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (app != NULL, NULL);
	g_return_val_if_fail (path != NULL, NULL);
	g_return_val_if_fail (data_path != NULL, NULL);
	_tmp0_ = path;
	_tmp1_ = dbus_server_clean_path (self, _tmp0_);
	cpath = _tmp1_;
	_tmp2_ = app;
	_tmp3_ = _tmp2_->docs;
	_tmp4_ = cpath;
	_tmp5_ = gee_abstract_map_has_key ((GeeAbstractMap*) _tmp3_, _tmp4_);
	if (_tmp5_) {
		DBusServerApp* _tmp6_ = NULL;
		GeeHashMap* _tmp7_ = NULL;
		const gchar* _tmp8_ = NULL;
		gpointer _tmp9_ = NULL;
		_tmp6_ = app;
		_tmp7_ = _tmp6_->docs;
		_tmp8_ = cpath;
		_tmp9_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp7_, _tmp8_);
		_dbus_server_exported_document_unref0 (doc);
		doc = (DBusServerExportedDocument*) _tmp9_;
	} else {
		DBusServerApp* _tmp10_ = NULL;
		const gchar* _tmp11_ = NULL;
		const gchar* _tmp12_ = NULL;
		DBusServerExportedDocument* _tmp13_ = NULL;
		_tmp10_ = app;
		_tmp11_ = cpath;
		_tmp12_ = path;
		_tmp13_ = dbus_server_make_document (self, _tmp10_, _tmp11_, _tmp12_);
		_dbus_server_exported_document_unref0 (doc);
		doc = _tmp13_;
	}
	_tmp15_ = data_path;
	if (_tmp15_ != NULL) {
		const gchar* _tmp16_ = NULL;
		_tmp16_ = data_path;
		_tmp14_ = g_strcmp0 (_tmp16_, "") != 0;
	} else {
		_tmp14_ = FALSE;
	}
	if (_tmp14_) {
		DBusServerExportedDocument* _tmp17_ = NULL;
		Document* _tmp18_ = NULL;
		const gchar* _tmp19_ = NULL;
		_tmp17_ = doc;
		_tmp18_ = _tmp17_->document;
		_tmp19_ = data_path;
		document_set_data_path (_tmp18_, _tmp19_);
	} else {
		DBusServerExportedDocument* _tmp20_ = NULL;
		Document* _tmp21_ = NULL;
		DBusServerExportedDocument* _tmp22_ = NULL;
		Document* _tmp23_ = NULL;
		const gchar* _tmp24_ = NULL;
		const gchar* _tmp25_ = NULL;
		_tmp20_ = doc;
		_tmp21_ = _tmp20_->document;
		_tmp22_ = doc;
		_tmp23_ = _tmp22_->document;
		_tmp24_ = document_get_path (_tmp23_);
		_tmp25_ = _tmp24_;
		document_set_data_path (_tmp21_, _tmp25_);
	}
	_tmp26_ = cursor;
	if (_tmp26_ == NULL) {
		DBusServerExportedDocument* _tmp27_ = NULL;
		Document* _tmp28_ = NULL;
		SourceLocation _tmp29_ = {0};
		_tmp27_ = doc;
		_tmp28_ = _tmp27_->document;
		memset (&_tmp29_, 0, sizeof (SourceLocation));
		_tmp29_.line = (gint64) 0;
		_tmp29_.column = (gint64) 0;
		document_set_cursor (_tmp28_, &_tmp29_);
	} else {
		DBusServerExportedDocument* _tmp30_ = NULL;
		Document* _tmp31_ = NULL;
		SourceLocation* _tmp32_ = NULL;
		_tmp30_ = doc;
		_tmp31_ = _tmp30_->document;
		_tmp32_ = cursor;
		document_set_cursor (_tmp31_, _tmp32_);
	}
	result = doc;
	_g_free0 (cpath);
	return result;
}


static void dbus_server_dispose_document (DBusServer* self, DBusServerApp* a, DBusServerExportedDocument* ddoc) {
	DBusServerApp* _tmp0_ = NULL;
	Service* _tmp1_ = NULL;
	DBusServerExportedDocument* _tmp2_ = NULL;
	Document* _tmp3_ = NULL;
	DBusServerExportedDocument* _tmp4_ = NULL;
	guint _tmp5_ = 0U;
	DBusServerExportedDocument* _tmp9_ = NULL;
	guint _tmp10_ = 0U;
	g_return_if_fail (self != NULL);
	g_return_if_fail (a != NULL);
	g_return_if_fail (ddoc != NULL);
	_tmp0_ = a;
	_tmp1_ = _tmp0_->service;
	_tmp2_ = ddoc;
	_tmp3_ = _tmp2_->document;
	service_dispose (_tmp1_, _tmp3_);
	_tmp4_ = ddoc;
	_tmp5_ = _tmp4_->ddocument_regid;
	if (_tmp5_ != ((guint) 0)) {
		GDBusConnection* _tmp6_ = NULL;
		DBusServerExportedDocument* _tmp7_ = NULL;
		guint _tmp8_ = 0U;
		_tmp6_ = self->priv->d_conn;
		_tmp7_ = ddoc;
		_tmp8_ = _tmp7_->ddocument_regid;
		g_dbus_connection_unregister_object (_tmp6_, _tmp8_);
	}
	_tmp9_ = ddoc;
	_tmp10_ = _tmp9_->ddiagnostics_regid;
	if (_tmp10_ != ((guint) 0)) {
		GDBusConnection* _tmp11_ = NULL;
		DBusServerExportedDocument* _tmp12_ = NULL;
		guint _tmp13_ = 0U;
		_tmp11_ = self->priv->d_conn;
		_tmp12_ = ddoc;
		_tmp13_ = _tmp12_->ddiagnostics_regid;
		g_dbus_connection_unregister_object (_tmp11_, _tmp13_);
	}
}


static void dbus_server_dispose_app (DBusServer* self, DBusServerApp* app) {
	DBusServerApp* _tmp13_ = NULL;
	GeeHashMap* _tmp14_ = NULL;
	GeeHashMap* _tmp15_ = NULL;
	DBusServerApp* _tmp16_ = NULL;
	const gchar* _tmp17_ = NULL;
	GeeHashMap* _tmp18_ = NULL;
	gint _tmp19_ = 0;
	gint _tmp20_ = 0;
	g_return_if_fail (self != NULL);
	g_return_if_fail (app != NULL);
	{
		GeeIterator* _ddoc_it = NULL;
		DBusServerApp* _tmp0_ = NULL;
		GeeHashMap* _tmp1_ = NULL;
		GeeCollection* _tmp2_ = NULL;
		GeeCollection* _tmp3_ = NULL;
		GeeCollection* _tmp4_ = NULL;
		GeeIterator* _tmp5_ = NULL;
		GeeIterator* _tmp6_ = NULL;
		_tmp0_ = app;
		_tmp1_ = _tmp0_->docs;
		_tmp2_ = gee_abstract_map_get_values ((GeeMap*) _tmp1_);
		_tmp3_ = _tmp2_;
		_tmp4_ = _tmp3_;
		_tmp5_ = gee_iterable_iterator ((GeeIterable*) _tmp4_);
		_tmp6_ = _tmp5_;
		_g_object_unref0 (_tmp4_);
		_ddoc_it = _tmp6_;
		while (TRUE) {
			GeeIterator* _tmp7_ = NULL;
			gboolean _tmp8_ = FALSE;
			DBusServerExportedDocument* ddoc = NULL;
			GeeIterator* _tmp9_ = NULL;
			gpointer _tmp10_ = NULL;
			DBusServerApp* _tmp11_ = NULL;
			DBusServerExportedDocument* _tmp12_ = NULL;
			_tmp7_ = _ddoc_it;
			_tmp8_ = gee_iterator_next (_tmp7_);
			if (!_tmp8_) {
				break;
			}
			_tmp9_ = _ddoc_it;
			_tmp10_ = gee_iterator_get (_tmp9_);
			ddoc = (DBusServerExportedDocument*) _tmp10_;
			_tmp11_ = app;
			_tmp12_ = ddoc;
			dbus_server_dispose_document (self, _tmp11_, _tmp12_);
			_dbus_server_exported_document_unref0 (ddoc);
		}
		_g_object_unref0 (_ddoc_it);
	}
	_tmp13_ = app;
	_tmp14_ = _tmp13_->docs;
	gee_abstract_map_clear ((GeeAbstractMap*) _tmp14_);
	_tmp15_ = self->priv->d_apps;
	_tmp16_ = app;
	_tmp17_ = _tmp16_->name;
	gee_abstract_map_unset ((GeeAbstractMap*) _tmp15_, _tmp17_, NULL);
	_tmp18_ = self->priv->d_apps;
	_tmp19_ = gee_abstract_map_get_size ((GeeMap*) _tmp18_);
	_tmp20_ = _tmp19_;
	if (_tmp20_ == 0) {
		GMainLoop* _tmp21_ = NULL;
		_tmp21_ = self->priv->d_main;
		g_main_loop_quit (_tmp21_);
	}
}


static char* dbus_server_remote_document_path (DBusServer* self, DBusServerApp* app, Document* doc) {
	char* result = NULL;
	DBusServerApp* _tmp0_ = NULL;
	guint _tmp1_ = 0U;
	Document* _tmp2_ = NULL;
	guint _tmp3_ = 0U;
	guint _tmp4_ = 0U;
	gchar* _tmp5_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (app != NULL, NULL);
	g_return_val_if_fail (doc != NULL, NULL);
	_tmp0_ = app;
	_tmp1_ = _tmp0_->id;
	_tmp2_ = doc;
	_tmp3_ = document_get_id (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup_printf ("/org/gnome/CodeAssist/v1/vala/%u/documents/%u", _tmp1_, _tmp4_);
	result = (char*) _tmp5_;
	return result;
}


static void dbus_server_parse_data_free (gpointer _data) {
	DbusServerParseData* _data_;
	_data_ = _data;
	_g_free0 (_data_->path);
	_g_free0 (_data_->data_path);
	_g_hash_table_unref0 (_data_->options);
	_g_free0 (_data_->sender);
	_g_free0 (_data_->result);
	_dbus_server_unref0 (_data_->self);
	g_slice_free (DbusServerParseData, _data_);
}


void dbus_server_parse (DBusServer* self, const gchar* path, const gchar* data_path, SourceLocation* cursor, GHashTable* options, const char* sender, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DbusServerParseData* _data_;
	DBusServer* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	const gchar* _tmp3_ = NULL;
	gchar* _tmp4_ = NULL;
	SourceLocation _tmp5_ = {0};
	GHashTable* _tmp6_ = NULL;
	GHashTable* _tmp7_ = NULL;
	const char* _tmp8_ = NULL;
	char* _tmp9_ = NULL;
	_data_ = g_slice_new0 (DbusServerParseData);
	_data_->_async_result = g_simple_async_result_new (NULL, _callback_, _user_data_, dbus_server_parse);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_server_parse_data_free);
	_tmp0_ = _dbus_server_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = path;
	_tmp2_ = g_strdup (_tmp1_);
	_g_free0 (_data_->path);
	_data_->path = _tmp2_;
	_tmp3_ = data_path;
	_tmp4_ = g_strdup (_tmp3_);
	_g_free0 (_data_->data_path);
	_data_->data_path = _tmp4_;
	_tmp5_ = *cursor;
	_data_->cursor = _tmp5_;
	_tmp6_ = options;
	_tmp7_ = _g_hash_table_ref0 (_tmp6_);
	_g_hash_table_unref0 (_data_->options);
	_data_->options = _tmp7_;
	_tmp8_ = sender;
	_tmp9_ = g_strdup (_tmp8_);
	_g_free0 (_data_->sender);
	_data_->sender = _tmp9_;
	dbus_server_parse_co (_data_);
}


char* dbus_server_parse_finish (DBusServer* self, GAsyncResult* _res_, GError** error) {
	char* result;
	DbusServerParseData* _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 dbus_server_parse_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServerParseData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_server_parse_co (_data_);
}


static gboolean dbus_server_parse_co (DbusServerParseData* _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_ = _data_->self->priv->d_apps;
		g_rec_mutex_lock (&_data_->self->priv->__lock_d_apps);
		{
			_data_->_tmp1_ = NULL;
			_data_->_tmp1_ = _data_->sender;
			_data_->_tmp2_ = NULL;
			_data_->_tmp2_ = dbus_server_ensure_app (_data_->self, (const gchar*) _data_->_tmp1_);
			_dbus_server_app_unref0 (_data_->app);
			_data_->app = _data_->_tmp2_;
			_data_->_tmp3_ = NULL;
			_data_->_tmp3_ = _data_->path;
			_data_->_tmp4_ = NULL;
			_data_->_tmp4_ = _data_->data_path;
			memset (&_data_->_tmp5_, 0, sizeof (SourceLocation));
			_data_->_tmp5_ = _data_->cursor;
			_data_->_tmp6_ = NULL;
			_data_->_tmp6_ = dbus_server_ensure_document (_data_->self, _data_->app, _data_->_tmp3_, _data_->_tmp4_, &_data_->_tmp5_);
			_dbus_server_exported_document_unref0 (_data_->doc);
			_data_->doc = _data_->_tmp6_;
		}
		__finally4:
		{
			_data_->_tmp7_ = NULL;
			_data_->_tmp7_ = _data_->self->priv->d_apps;
			g_rec_mutex_unlock (&_data_->self->priv->__lock_d_apps);
		}
		if (G_UNLIKELY (_data_->_inner_error_ != NULL)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_dbus_server_exported_document_unref0 (_data_->doc);
			_dbus_server_app_unref0 (_data_->app);
			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_->_tmp8_ = NULL;
	_data_->_tmp8_ = _data_->app->service;
	_data_->_tmp9_ = NULL;
	_data_->_tmp9_ = _data_->doc->document;
	_data_->_tmp10_ = NULL;
	_data_->_tmp10_ = _data_->options;
	_data_->_state_ = 1;
	service_parse (_data_->_tmp8_, _data_->_tmp9_, _data_->_tmp10_, dbus_server_parse_ready, _data_);
	return FALSE;
	_state_1:
	service_parse_finish (_data_->_tmp8_, _data_->_res_);
	_data_->_tmp11_ = NULL;
	_data_->_tmp11_ = _data_->doc->document;
	_data_->_tmp12_ = NULL;
	_data_->_tmp12_ = dbus_server_remote_document_path (_data_->self, _data_->app, _data_->_tmp11_);
	_data_->result = _data_->_tmp12_;
	_dbus_server_exported_document_unref0 (_data_->doc);
	_dbus_server_app_unref0 (_data_->app);
	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;
	_dbus_server_exported_document_unref0 (_data_->doc);
	_dbus_server_app_unref0 (_data_->app);
	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;
}


void dbus_server_dispose (DBusServer* self, const gchar* path, const char* sender) {
	GError * _inner_error_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (path != NULL);
	g_return_if_fail (sender != NULL);
	{
		GeeHashMap* _tmp0_ = NULL;
		_tmp0_ = self->priv->d_apps;
		g_rec_mutex_lock (&self->priv->__lock_d_apps);
		{
			GeeHashMap* _tmp1_ = NULL;
			const char* _tmp2_ = NULL;
			gboolean _tmp3_ = FALSE;
			_tmp1_ = self->priv->d_apps;
			_tmp2_ = sender;
			_tmp3_ = gee_abstract_map_has_key ((GeeAbstractMap*) _tmp1_, (const gchar*) _tmp2_);
			if (_tmp3_) {
				DBusServerApp* app = NULL;
				GeeHashMap* _tmp4_ = NULL;
				const char* _tmp5_ = NULL;
				gpointer _tmp6_ = NULL;
				gchar* cpath = NULL;
				const gchar* _tmp7_ = NULL;
				gchar* _tmp8_ = NULL;
				DBusServerApp* _tmp9_ = NULL;
				GeeHashMap* _tmp10_ = NULL;
				const gchar* _tmp11_ = NULL;
				gboolean _tmp12_ = FALSE;
				_tmp4_ = self->priv->d_apps;
				_tmp5_ = sender;
				_tmp6_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp4_, (const gchar*) _tmp5_);
				app = (DBusServerApp*) _tmp6_;
				_tmp7_ = path;
				_tmp8_ = dbus_server_clean_path (self, _tmp7_);
				cpath = _tmp8_;
				_tmp9_ = app;
				_tmp10_ = _tmp9_->docs;
				_tmp11_ = cpath;
				_tmp12_ = gee_abstract_map_has_key ((GeeAbstractMap*) _tmp10_, _tmp11_);
				if (_tmp12_) {
					DBusServerApp* _tmp13_ = NULL;
					DBusServerApp* _tmp14_ = NULL;
					GeeHashMap* _tmp15_ = NULL;
					const gchar* _tmp16_ = NULL;
					gpointer _tmp17_ = NULL;
					DBusServerExportedDocument* _tmp18_ = NULL;
					DBusServerApp* _tmp19_ = NULL;
					GeeHashMap* _tmp20_ = NULL;
					const gchar* _tmp21_ = NULL;
					DBusServerApp* _tmp22_ = NULL;
					GeeHashMap* _tmp23_ = NULL;
					gint _tmp24_ = 0;
					gint _tmp25_ = 0;
					_tmp13_ = app;
					_tmp14_ = app;
					_tmp15_ = _tmp14_->docs;
					_tmp16_ = cpath;
					_tmp17_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp15_, _tmp16_);
					_tmp18_ = (DBusServerExportedDocument*) _tmp17_;
					dbus_server_dispose_document (self, _tmp13_, _tmp18_);
					_dbus_server_exported_document_unref0 (_tmp18_);
					_tmp19_ = app;
					_tmp20_ = _tmp19_->docs;
					_tmp21_ = cpath;
					gee_abstract_map_unset ((GeeAbstractMap*) _tmp20_, _tmp21_, NULL);
					_tmp22_ = app;
					_tmp23_ = _tmp22_->docs;
					_tmp24_ = gee_abstract_map_get_size ((GeeMap*) _tmp23_);
					_tmp25_ = _tmp24_;
					if (_tmp25_ == 0) {
						DBusServerApp* _tmp26_ = NULL;
						_tmp26_ = app;
						dbus_server_dispose_app (self, _tmp26_);
					}
				}
				_g_free0 (cpath);
				_dbus_server_app_unref0 (app);
			}
		}
		__finally5:
		{
			GeeHashMap* _tmp27_ = NULL;
			_tmp27_ = self->priv->d_apps;
			g_rec_mutex_unlock (&self->priv->__lock_d_apps);
		}
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			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 dbus_server_parse_all_data_free (gpointer _data) {
	DbusServerParseAllData* _data_;
	_data_ = _data;
	_g_free0 (_data_->path);
	_g_hash_table_unref0 (_data_->options);
	_g_free0 (_data_->sender);
	_data_->result = (_vala_RemoteDocument_array_free (_data_->result, _data_->result_length1), NULL);
	_dbus_server_unref0 (_data_->self);
	g_slice_free (DbusServerParseAllData, _data_);
}


void dbus_server_parse_all (DBusServer* self, const gchar* path, OpenDocument* documents, int documents_length1, SourceLocation* cursor, GHashTable* options, const char* sender, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DbusServerParseAllData* _data_;
	DBusServer* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	OpenDocument* _tmp3_ = NULL;
	gint _tmp3__length1 = 0;
	SourceLocation _tmp4_ = {0};
	GHashTable* _tmp5_ = NULL;
	GHashTable* _tmp6_ = NULL;
	const char* _tmp7_ = NULL;
	char* _tmp8_ = NULL;
	_data_ = g_slice_new0 (DbusServerParseAllData);
	_data_->_async_result = g_simple_async_result_new (NULL, _callback_, _user_data_, dbus_server_parse_all);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_server_parse_all_data_free);
	_tmp0_ = _dbus_server_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = path;
	_tmp2_ = g_strdup (_tmp1_);
	_g_free0 (_data_->path);
	_data_->path = _tmp2_;
	_tmp3_ = documents;
	_tmp3__length1 = documents_length1;
	_data_->documents = _tmp3_;
	_data_->documents_length1 = _tmp3__length1;
	_tmp4_ = *cursor;
	_data_->cursor = _tmp4_;
	_tmp5_ = options;
	_tmp6_ = _g_hash_table_ref0 (_tmp5_);
	_g_hash_table_unref0 (_data_->options);
	_data_->options = _tmp6_;
	_tmp7_ = sender;
	_tmp8_ = g_strdup (_tmp7_);
	_g_free0 (_data_->sender);
	_data_->sender = _tmp8_;
	dbus_server_parse_all_co (_data_);
}


RemoteDocument* dbus_server_parse_all_finish (DBusServer* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	RemoteDocument* result;
	DbusServerParseAllData* _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;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static void dbus_server_parse_all_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServerParseAllData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_server_parse_all_co (_data_);
}


static gboolean dbus_server_parse_all_co (DbusServerParseAllData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->opendocs_length1 = 0;
	_data_->_opendocs_size_ = 0;
	{
		_data_->_tmp0_ = NULL;
		_data_->_tmp0_ = _data_->self->priv->d_apps;
		g_rec_mutex_lock (&_data_->self->priv->__lock_d_apps);
		{
			_data_->_tmp1_ = NULL;
			_data_->_tmp1_ = _data_->sender;
			_data_->_tmp2_ = NULL;
			_data_->_tmp2_ = dbus_server_ensure_app (_data_->self, (const gchar*) _data_->_tmp1_);
			_dbus_server_app_unref0 (_data_->app);
			_data_->app = _data_->_tmp2_;
			_data_->_tmp3_ = NULL;
			_data_->_tmp3_ = _data_->app;
			_data_->_tmp4_ = NULL;
			_data_->_tmp4_ = _data_->path;
			memset (&_data_->_tmp5_, 0, sizeof (SourceLocation));
			_data_->_tmp5_ = _data_->cursor;
			_data_->_tmp6_ = NULL;
			_data_->_tmp6_ = dbus_server_ensure_document (_data_->self, _data_->_tmp3_, _data_->_tmp4_, "", &_data_->_tmp5_);
			_dbus_server_exported_document_unref0 (_data_->doc);
			_data_->doc = _data_->_tmp6_;
			_data_->_tmp7_ = NULL;
			_data_->_tmp7__length1 = 0;
			_data_->_tmp7_ = _data_->documents;
			_data_->_tmp7__length1 = _data_->documents_length1;
			_data_->_tmp8_ = NULL;
			_data_->_tmp8_ = g_new0 (Document*, _data_->_tmp7__length1 + 1);
			_data_->opendocs = (_vala_array_free (_data_->opendocs, _data_->opendocs_length1, (GDestroyNotify) document_unref), NULL);
			_data_->opendocs = _data_->_tmp8_;
			_data_->opendocs_length1 = _data_->_tmp7__length1;
			_data_->_opendocs_size_ = _data_->opendocs_length1;
			{
				_data_->i = 0;
				{
					_data_->_tmp9_ = TRUE;
					while (TRUE) {
						if (!_data_->_tmp9_) {
							_data_->_tmp10_ = 0;
							_data_->_tmp10_ = _data_->i;
							_data_->i = _data_->_tmp10_ + 1;
						}
						_data_->_tmp9_ = FALSE;
						_data_->_tmp11_ = 0;
						_data_->_tmp11_ = _data_->i;
						_data_->_tmp12_ = NULL;
						_data_->_tmp12__length1 = 0;
						_data_->_tmp12_ = _data_->documents;
						_data_->_tmp12__length1 = _data_->documents_length1;
						if (!(_data_->_tmp11_ < _data_->_tmp12__length1)) {
							break;
						}
						_data_->_tmp13_ = NULL;
						_data_->_tmp13_ = _data_->app;
						_data_->_tmp14_ = NULL;
						_data_->_tmp14__length1 = 0;
						_data_->_tmp14_ = _data_->documents;
						_data_->_tmp14__length1 = _data_->documents_length1;
						_data_->_tmp15_ = 0;
						_data_->_tmp15_ = _data_->i;
						memset (&_data_->_tmp16_, 0, sizeof (OpenDocument));
						_data_->_tmp16_ = _data_->_tmp14_[_data_->_tmp15_];
						_data_->_tmp17_ = NULL;
						_data_->_tmp17_ = _data_->_tmp16_.path;
						_data_->_tmp18_ = NULL;
						_data_->_tmp18__length1 = 0;
						_data_->_tmp18_ = _data_->documents;
						_data_->_tmp18__length1 = _data_->documents_length1;
						_data_->_tmp19_ = 0;
						_data_->_tmp19_ = _data_->i;
						memset (&_data_->_tmp20_, 0, sizeof (OpenDocument));
						_data_->_tmp20_ = _data_->_tmp18_[_data_->_tmp19_];
						_data_->_tmp21_ = NULL;
						_data_->_tmp21_ = _data_->_tmp20_.data_path;
						_data_->_tmp22_ = NULL;
						_data_->_tmp22_ = dbus_server_ensure_document (_data_->self, _data_->_tmp13_, _data_->_tmp17_, _data_->_tmp21_, NULL);
						_data_->rdoc = _data_->_tmp22_;
						_data_->_tmp23_ = NULL;
						_data_->_tmp23__length1 = 0;
						_data_->_tmp23_ = _data_->opendocs;
						_data_->_tmp23__length1 = _data_->opendocs_length1;
						_data_->_tmp24_ = 0;
						_data_->_tmp24_ = _data_->i;
						_data_->_tmp25_ = NULL;
						_data_->_tmp25_ = _data_->rdoc;
						_data_->_tmp26_ = NULL;
						_data_->_tmp26_ = _data_->_tmp25_->document;
						_data_->_tmp27_ = NULL;
						_data_->_tmp27_ = _document_ref0 (_data_->_tmp26_);
						_document_unref0 (_data_->_tmp23_[_data_->_tmp24_]);
						_data_->_tmp23_[_data_->_tmp24_] = _data_->_tmp27_;
						_data_->_tmp28_ = NULL;
						_data_->_tmp28_ = _data_->_tmp23_[_data_->_tmp24_];
						_dbus_server_exported_document_unref0 (_data_->rdoc);
					}
				}
			}
		}
		__finally6:
		{
			_data_->_tmp29_ = NULL;
			_data_->_tmp29_ = _data_->self->priv->d_apps;
			g_rec_mutex_unlock (&_data_->self->priv->__lock_d_apps);
		}
		if (G_UNLIKELY (_data_->_inner_error_ != NULL)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_data_->opendocs = (_vala_array_free (_data_->opendocs, _data_->opendocs_length1, (GDestroyNotify) document_unref), NULL);
			_dbus_server_exported_document_unref0 (_data_->doc);
			_dbus_server_app_unref0 (_data_->app);
			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_->_tmp30_ = NULL;
	_data_->_tmp30_ = _data_->app;
	_data_->_tmp31_ = NULL;
	_data_->_tmp31_ = _data_->_tmp30_->service;
	_data_->_tmp32_ = NULL;
	_data_->_tmp32_ = _data_->doc;
	_data_->_tmp33_ = NULL;
	_data_->_tmp33_ = _data_->_tmp32_->document;
	_data_->_tmp34_ = NULL;
	_data_->_tmp34__length1 = 0;
	_data_->_tmp34_ = _data_->opendocs;
	_data_->_tmp34__length1 = _data_->opendocs_length1;
	_data_->_tmp35_ = NULL;
	_data_->_tmp35_ = _data_->options;
	_data_->_tmp36_ = 0;
	_data_->_state_ = 1;
	service_parse_all (_data_->_tmp31_, _data_->_tmp33_, _data_->_tmp34_, _data_->_tmp34__length1, _data_->_tmp35_, dbus_server_parse_all_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp37_ = NULL;
	_data_->_tmp37_ = service_parse_all_finish (_data_->_tmp31_, _data_->_res_, &_data_->_tmp36_);
	_data_->retdocs_length1 = 0;
	_data_->_retdocs_size_ = 0;
	_data_->retdocs = _data_->_tmp37_;
	_data_->retdocs_length1 = _data_->_tmp36_;
	_data_->_retdocs_size_ = _data_->retdocs_length1;
	_data_->_tmp38_ = NULL;
	_data_->_tmp38__length1 = 0;
	_data_->_tmp38_ = _data_->retdocs;
	_data_->_tmp38__length1 = _data_->retdocs_length1;
	_data_->_tmp39_ = NULL;
	_data_->_tmp39_ = g_new0 (RemoteDocument, _data_->_tmp38__length1);
	_data_->ret_length1 = 0;
	_data_->_ret_size_ = 0;
	_data_->ret = _data_->_tmp39_;
	_data_->ret_length1 = _data_->_tmp38__length1;
	_data_->_ret_size_ = _data_->ret_length1;
	{
		_data_->_vala1_i = 0;
		{
			_data_->_tmp40_ = TRUE;
			while (TRUE) {
				if (!_data_->_tmp40_) {
					_data_->_tmp41_ = 0;
					_data_->_tmp41_ = _data_->_vala1_i;
					_data_->_vala1_i = _data_->_tmp41_ + 1;
				}
				_data_->_tmp40_ = FALSE;
				_data_->_tmp42_ = 0;
				_data_->_tmp42_ = _data_->_vala1_i;
				_data_->_tmp43_ = NULL;
				_data_->_tmp43__length1 = 0;
				_data_->_tmp43_ = _data_->retdocs;
				_data_->_tmp43__length1 = _data_->retdocs_length1;
				if (!(_data_->_tmp42_ < _data_->_tmp43__length1)) {
					break;
				}
				_data_->_tmp44_ = NULL;
				_data_->_tmp44__length1 = 0;
				_data_->_tmp44_ = _data_->ret;
				_data_->_tmp44__length1 = _data_->ret_length1;
				_data_->_tmp45_ = 0;
				_data_->_tmp45_ = _data_->_vala1_i;
				_data_->_tmp46_ = NULL;
				_data_->_tmp46__length1 = 0;
				_data_->_tmp46_ = _data_->retdocs;
				_data_->_tmp46__length1 = _data_->retdocs_length1;
				_data_->_tmp47_ = 0;
				_data_->_tmp47_ = _data_->_vala1_i;
				_data_->_tmp48_ = NULL;
				_data_->_tmp48_ = _data_->_tmp46_[_data_->_tmp47_];
				_data_->_tmp49_ = NULL;
				_data_->_tmp49_ = document_get_client_path (_data_->_tmp48_);
				_data_->_tmp50_ = NULL;
				_data_->_tmp50_ = _data_->_tmp49_;
				_data_->_tmp51_ = NULL;
				_data_->_tmp51_ = g_strdup (_data_->_tmp50_);
				_data_->_tmp52_ = NULL;
				_data_->_tmp52_ = _data_->app;
				_data_->_tmp53_ = NULL;
				_data_->_tmp53__length1 = 0;
				_data_->_tmp53_ = _data_->retdocs;
				_data_->_tmp53__length1 = _data_->retdocs_length1;
				_data_->_tmp54_ = 0;
				_data_->_tmp54_ = _data_->_vala1_i;
				_data_->_tmp55_ = NULL;
				_data_->_tmp55_ = _data_->_tmp53_[_data_->_tmp54_];
				_data_->_tmp56_ = NULL;
				_data_->_tmp56_ = dbus_server_remote_document_path (_data_->self, _data_->_tmp52_, _data_->_tmp55_);
				memset (&_data_->_tmp57_, 0, sizeof (RemoteDocument));
				memset (&_data_->_tmp57_, 0, sizeof (RemoteDocument));
				_g_free0 (_data_->_tmp57_.path);
				_data_->_tmp57_.path = _data_->_tmp51_;
				_g_free0 (_data_->_tmp57_.remote_path);
				_data_->_tmp57_.remote_path = _data_->_tmp56_;
				remote_document_destroy (&_data_->_tmp44_[_data_->_tmp45_]);
				_data_->_tmp44_[_data_->_tmp45_] = _data_->_tmp57_;
				memset (&_data_->_tmp58_, 0, sizeof (RemoteDocument));
				_data_->_tmp58_ = _data_->_tmp44_[_data_->_tmp45_];
			}
		}
	}
	_data_->_tmp59_ = NULL;
	_data_->_tmp59__length1 = 0;
	_data_->_tmp59_ = _data_->ret;
	_data_->_tmp59__length1 = _data_->ret_length1;
	_data_->result_length1 = _data_->_tmp59__length1;
	_data_->result = _data_->_tmp59_;
	_data_->retdocs = (_vala_array_free (_data_->retdocs, _data_->retdocs_length1, (GDestroyNotify) document_unref), NULL);
	_data_->opendocs = (_vala_array_free (_data_->opendocs, _data_->opendocs_length1, (GDestroyNotify) document_unref), NULL);
	_dbus_server_exported_document_unref0 (_data_->doc);
	_dbus_server_app_unref0 (_data_->app);
	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_->ret = (_vala_RemoteDocument_array_free (_data_->ret, _data_->ret_length1), NULL);
	_data_->retdocs = (_vala_array_free (_data_->retdocs, _data_->retdocs_length1, (GDestroyNotify) document_unref), NULL);
	_data_->opendocs = (_vala_array_free (_data_->opendocs, _data_->opendocs_length1, (GDestroyNotify) document_unref), NULL);
	_dbus_server_exported_document_unref0 (_data_->doc);
	_dbus_server_app_unref0 (_data_->app);
	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 DBusServerExportedDocument* dbus_server_exported_document_construct (GType object_type, Document* document) {
	DBusServerExportedDocument* self = NULL;
	Document* _tmp0_ = NULL;
	Document* _tmp1_ = NULL;
	Document* _tmp2_ = NULL;
	DBusDocumentIface* _tmp3_ = NULL;
	Document* _tmp4_ = NULL;
	DBusDiagnosticsIface* _tmp5_ = NULL;
	g_return_val_if_fail (document != NULL, NULL);
	self = (DBusServerExportedDocument*) g_type_create_instance (object_type);
	_tmp0_ = document;
	_tmp1_ = _document_ref0 (_tmp0_);
	_document_unref0 (self->document);
	self->document = _tmp1_;
	_tmp2_ = document;
	_tmp3_ = dbus_document_iface_new (_tmp2_);
	_g_object_unref0 (self->ddocument);
	self->ddocument = _tmp3_;
	self->ddiagnostics_regid = (guint) 0;
	_tmp4_ = document;
	_tmp5_ = dbus_diagnostics_iface_new (_tmp4_);
	_g_object_unref0 (self->ddiagnostics);
	self->ddiagnostics = _tmp5_;
	self->ddiagnostics_regid = (guint) 0;
	return self;
}


static DBusServerExportedDocument* dbus_server_exported_document_new (Document* document) {
	return dbus_server_exported_document_construct (DBUS_SERVER_TYPE_EXPORTED_DOCUMENT, document);
}


static void dbus_server_value_exported_document_init (GValue* value) {
	value->data[0].v_pointer = NULL;
}


static void dbus_server_value_exported_document_free_value (GValue* value) {
	if (value->data[0].v_pointer) {
		dbus_server_exported_document_unref (value->data[0].v_pointer);
	}
}


static void dbus_server_value_exported_document_copy_value (const GValue* src_value, GValue* dest_value) {
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = dbus_server_exported_document_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}


static gpointer dbus_server_value_exported_document_peek_pointer (const GValue* value) {
	return value->data[0].v_pointer;
}


static gchar* dbus_server_value_exported_document_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	if (collect_values[0].v_pointer) {
		DBusServerExportedDocument* object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = dbus_server_exported_document_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}


static gchar* dbus_server_value_exported_document_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	DBusServerExportedDocument** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = dbus_server_exported_document_ref (value->data[0].v_pointer);
	}
	return NULL;
}


static GParamSpec* dbus_server_param_spec_exported_document (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
	DBusServerParamSpecExportedDocument* spec;
	g_return_val_if_fail (g_type_is_a (object_type, DBUS_SERVER_TYPE_EXPORTED_DOCUMENT), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}


static gpointer dbus_server_value_get_exported_document (const GValue* value) {
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_SERVER_TYPE_EXPORTED_DOCUMENT), NULL);
	return value->data[0].v_pointer;
}


static void dbus_server_value_set_exported_document (GValue* value, gpointer v_object) {
	DBusServerExportedDocument* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_SERVER_TYPE_EXPORTED_DOCUMENT));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, DBUS_SERVER_TYPE_EXPORTED_DOCUMENT));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		dbus_server_exported_document_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		dbus_server_exported_document_unref (old);
	}
}


static void dbus_server_value_take_exported_document (GValue* value, gpointer v_object) {
	DBusServerExportedDocument* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_SERVER_TYPE_EXPORTED_DOCUMENT));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, DBUS_SERVER_TYPE_EXPORTED_DOCUMENT));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		dbus_server_exported_document_unref (old);
	}
}


static void dbus_server_exported_document_class_init (DBusServerExportedDocumentClass * klass) {
	dbus_server_exported_document_parent_class = g_type_class_peek_parent (klass);
	((DBusServerExportedDocumentClass *) klass)->finalize = dbus_server_exported_document_finalize;
}


static void dbus_server_exported_document_instance_init (DBusServerExportedDocument * self) {
	self->ref_count = 1;
}


static void dbus_server_exported_document_finalize (DBusServerExportedDocument* obj) {
	DBusServerExportedDocument * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, DBUS_SERVER_TYPE_EXPORTED_DOCUMENT, DBusServerExportedDocument);
	g_signal_handlers_destroy (self);
	_document_unref0 (self->document);
	_g_object_unref0 (self->ddocument);
	_g_object_unref0 (self->ddiagnostics);
}


static GType dbus_server_exported_document_get_type (void) {
	static volatile gsize dbus_server_exported_document_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_server_exported_document_type_id__volatile)) {
		static const GTypeValueTable g_define_type_value_table = { dbus_server_value_exported_document_init, dbus_server_value_exported_document_free_value, dbus_server_value_exported_document_copy_value, dbus_server_value_exported_document_peek_pointer, "p", dbus_server_value_exported_document_collect_value, "p", dbus_server_value_exported_document_lcopy_value };
		static const GTypeInfo g_define_type_info = { sizeof (DBusServerExportedDocumentClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_server_exported_document_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusServerExportedDocument), 0, (GInstanceInitFunc) dbus_server_exported_document_instance_init, &g_define_type_value_table };
		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
		GType dbus_server_exported_document_type_id;
		dbus_server_exported_document_type_id = g_type_register_fundamental (g_type_fundamental_next (), "DBusServerExportedDocument", &g_define_type_info, &g_define_type_fundamental_info, 0);
		g_once_init_leave (&dbus_server_exported_document_type_id__volatile, dbus_server_exported_document_type_id);
	}
	return dbus_server_exported_document_type_id__volatile;
}


static gpointer dbus_server_exported_document_ref (gpointer instance) {
	DBusServerExportedDocument* self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}


static void dbus_server_exported_document_unref (gpointer instance) {
	DBusServerExportedDocument* self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		DBUS_SERVER_EXPORTED_DOCUMENT_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}


static DBusServerApp* dbus_server_app_construct (GType object_type, guint id, const gchar* name) {
	DBusServerApp* self = NULL;
	guint _tmp0_ = 0U;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	Service* _tmp3_ = NULL;
	GeeHashMap* _tmp4_ = NULL;
	g_return_val_if_fail (name != NULL, NULL);
	self = (DBusServerApp*) g_type_create_instance (object_type);
	_tmp0_ = id;
	self->id = _tmp0_;
	_tmp1_ = name;
	_tmp2_ = g_strdup (_tmp1_);
	_g_free0 (self->name);
	self->name = _tmp2_;
	_tmp3_ = service_new ();
	_service_unref0 (self->service);
	self->service = _tmp3_;
	_tmp4_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, DBUS_SERVER_TYPE_EXPORTED_DOCUMENT, (GBoxedCopyFunc) dbus_server_exported_document_ref, dbus_server_exported_document_unref, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	_g_object_unref0 (self->docs);
	self->docs = _tmp4_;
	self->nextid = (guint) 0;
	return self;
}


static DBusServerApp* dbus_server_app_new (guint id, const gchar* name) {
	return dbus_server_app_construct (DBUS_SERVER_TYPE_APP, id, name);
}


static void dbus_server_value_app_init (GValue* value) {
	value->data[0].v_pointer = NULL;
}


static void dbus_server_value_app_free_value (GValue* value) {
	if (value->data[0].v_pointer) {
		dbus_server_app_unref (value->data[0].v_pointer);
	}
}


static void dbus_server_value_app_copy_value (const GValue* src_value, GValue* dest_value) {
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = dbus_server_app_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}


static gpointer dbus_server_value_app_peek_pointer (const GValue* value) {
	return value->data[0].v_pointer;
}


static gchar* dbus_server_value_app_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	if (collect_values[0].v_pointer) {
		DBusServerApp* object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = dbus_server_app_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}


static gchar* dbus_server_value_app_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	DBusServerApp** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = dbus_server_app_ref (value->data[0].v_pointer);
	}
	return NULL;
}


static GParamSpec* dbus_server_param_spec_app (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
	DBusServerParamSpecApp* spec;
	g_return_val_if_fail (g_type_is_a (object_type, DBUS_SERVER_TYPE_APP), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}


static gpointer dbus_server_value_get_app (const GValue* value) {
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_SERVER_TYPE_APP), NULL);
	return value->data[0].v_pointer;
}


static void dbus_server_value_set_app (GValue* value, gpointer v_object) {
	DBusServerApp* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_SERVER_TYPE_APP));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, DBUS_SERVER_TYPE_APP));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		dbus_server_app_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		dbus_server_app_unref (old);
	}
}


static void dbus_server_value_take_app (GValue* value, gpointer v_object) {
	DBusServerApp* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_SERVER_TYPE_APP));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, DBUS_SERVER_TYPE_APP));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		dbus_server_app_unref (old);
	}
}


static void dbus_server_app_class_init (DBusServerAppClass * klass) {
	dbus_server_app_parent_class = g_type_class_peek_parent (klass);
	((DBusServerAppClass *) klass)->finalize = dbus_server_app_finalize;
}


static void dbus_server_app_instance_init (DBusServerApp * self) {
	self->ref_count = 1;
}


static void dbus_server_app_finalize (DBusServerApp* obj) {
	DBusServerApp * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, DBUS_SERVER_TYPE_APP, DBusServerApp);
	g_signal_handlers_destroy (self);
	_g_free0 (self->name);
	_service_unref0 (self->service);
	_g_object_unref0 (self->docs);
}


static GType dbus_server_app_get_type (void) {
	static volatile gsize dbus_server_app_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_server_app_type_id__volatile)) {
		static const GTypeValueTable g_define_type_value_table = { dbus_server_value_app_init, dbus_server_value_app_free_value, dbus_server_value_app_copy_value, dbus_server_value_app_peek_pointer, "p", dbus_server_value_app_collect_value, "p", dbus_server_value_app_lcopy_value };
		static const GTypeInfo g_define_type_info = { sizeof (DBusServerAppClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_server_app_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusServerApp), 0, (GInstanceInitFunc) dbus_server_app_instance_init, &g_define_type_value_table };
		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
		GType dbus_server_app_type_id;
		dbus_server_app_type_id = g_type_register_fundamental (g_type_fundamental_next (), "DBusServerApp", &g_define_type_info, &g_define_type_fundamental_info, 0);
		g_once_init_leave (&dbus_server_app_type_id__volatile, dbus_server_app_type_id);
	}
	return dbus_server_app_type_id__volatile;
}


static gpointer dbus_server_app_ref (gpointer instance) {
	DBusServerApp* self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}


static void dbus_server_app_unref (gpointer instance) {
	DBusServerApp* self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		DBUS_SERVER_APP_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}


static void dbus_value_server_init (GValue* value) {
	value->data[0].v_pointer = NULL;
}


static void dbus_value_server_free_value (GValue* value) {
	if (value->data[0].v_pointer) {
		dbus_server_unref (value->data[0].v_pointer);
	}
}


static void dbus_value_server_copy_value (const GValue* src_value, GValue* dest_value) {
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = dbus_server_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}


static gpointer dbus_value_server_peek_pointer (const GValue* value) {
	return value->data[0].v_pointer;
}


static gchar* dbus_value_server_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	if (collect_values[0].v_pointer) {
		DBusServer* object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = dbus_server_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}


static gchar* dbus_value_server_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	DBusServer** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = dbus_server_ref (value->data[0].v_pointer);
	}
	return NULL;
}


GParamSpec* dbus_param_spec_server (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
	DBusParamSpecServer* spec;
	g_return_val_if_fail (g_type_is_a (object_type, DBUS_TYPE_SERVER), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}


gpointer dbus_value_get_server (const GValue* value) {
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_TYPE_SERVER), NULL);
	return value->data[0].v_pointer;
}


void dbus_value_set_server (GValue* value, gpointer v_object) {
	DBusServer* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_TYPE_SERVER));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, DBUS_TYPE_SERVER));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		dbus_server_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		dbus_server_unref (old);
	}
}


void dbus_value_take_server (GValue* value, gpointer v_object) {
	DBusServer* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_TYPE_SERVER));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, DBUS_TYPE_SERVER));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		dbus_server_unref (old);
	}
}


static void dbus_server_class_init (DBusServerClass * klass) {
	dbus_server_parent_class = g_type_class_peek_parent (klass);
	((DBusServerClass *) klass)->finalize = dbus_server_finalize;
	g_type_class_add_private (klass, sizeof (DBusServerPrivate));
}


static void dbus_server_instance_init (DBusServer * self) {
	self->priv = DBUS_SERVER_GET_PRIVATE (self);
	g_rec_mutex_init (&self->priv->__lock_d_apps);
	self->ref_count = 1;
}


static void dbus_server_finalize (DBusServer* obj) {
	DBusServer * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, DBUS_TYPE_SERVER, DBusServer);
	g_signal_handlers_destroy (self);
	_g_main_loop_unref0 (self->priv->d_main);
	_g_object_unref0 (self->priv->d_conn);
	g_rec_mutex_clear (&self->priv->__lock_d_apps);
	_g_object_unref0 (self->priv->d_apps);
	_g_object_unref0 (self->priv->d_proxy);
}


GType dbus_server_get_type (void) {
	static volatile gsize dbus_server_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_server_type_id__volatile)) {
		static const GTypeValueTable g_define_type_value_table = { dbus_value_server_init, dbus_value_server_free_value, dbus_value_server_copy_value, dbus_value_server_peek_pointer, "p", dbus_value_server_collect_value, "p", dbus_value_server_lcopy_value };
		static const GTypeInfo g_define_type_info = { sizeof (DBusServerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_server_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusServer), 0, (GInstanceInitFunc) dbus_server_instance_init, &g_define_type_value_table };
		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
		GType dbus_server_type_id;
		dbus_server_type_id = g_type_register_fundamental (g_type_fundamental_next (), "DBusServer", &g_define_type_info, &g_define_type_fundamental_info, 0);
		g_once_init_leave (&dbus_server_type_id__volatile, dbus_server_type_id);
	}
	return dbus_server_type_id__volatile;
}


gpointer dbus_server_ref (gpointer instance) {
	DBusServer* self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}


void dbus_server_unref (gpointer instance) {
	DBusServer* self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		DBUS_SERVER_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}


DBusTransport* dbus_transport_construct (GType object_type) {
	DBusTransport* self = NULL;
	GMainLoop* _tmp0_ = NULL;
	self = (DBusTransport*) g_type_create_instance (object_type);
	_tmp0_ = g_main_loop_new (NULL, FALSE);
	_g_main_loop_unref0 (self->priv->d_main);
	self->priv->d_main = _tmp0_;
	return self;
}


DBusTransport* dbus_transport_new (void) {
	return dbus_transport_construct (DBUS_TYPE_TRANSPORT);
}


static void dbus_transport_on_bus_aquired (DBusTransport* self, GDBusConnection* conn) {
	GMainLoop* _tmp0_ = NULL;
	GDBusConnection* _tmp1_ = NULL;
	DBusServer* _tmp2_ = NULL;
	GError * _inner_error_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (conn != NULL);
	_tmp0_ = self->priv->d_main;
	_tmp1_ = conn;
	_tmp2_ = dbus_server_new (_tmp0_, _tmp1_);
	_dbus_server_unref0 (self->priv->d_server);
	self->priv->d_server = _tmp2_;
	{
		GDBusConnection* _tmp3_ = NULL;
		DBusServer* _tmp4_ = NULL;
		DBusServiceIface* _tmp5_ = NULL;
		DBusServiceIface* _tmp6_ = NULL;
		GDBusConnection* _tmp7_ = NULL;
		DBusServer* _tmp8_ = NULL;
		DBusProjectIface* _tmp9_ = NULL;
		DBusProjectIface* _tmp10_ = NULL;
		GDBusConnection* _tmp11_ = NULL;
		DBusDocumentIface* _tmp12_ = NULL;
		DBusDocumentIface* _tmp13_ = NULL;
		GDBusConnection* _tmp14_ = NULL;
		DBusDiagnosticsIface* _tmp15_ = NULL;
		DBusDiagnosticsIface* _tmp16_ = NULL;
		_tmp3_ = conn;
		_tmp4_ = self->priv->d_server;
		_tmp5_ = dbus_service_iface_new (_tmp4_);
		_tmp6_ = _tmp5_;
		dbus_service_iface_register_object (_tmp6_, _tmp3_, "/org/gnome/CodeAssist/v1/vala", &_inner_error_);
		_g_object_unref0 (_tmp6_);
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			goto __catch7_g_error;
		}
		_tmp7_ = conn;
		_tmp8_ = self->priv->d_server;
		_tmp9_ = dbus_project_iface_new (_tmp8_);
		_tmp10_ = _tmp9_;
		dbus_project_iface_register_object (_tmp10_, _tmp7_, "/org/gnome/CodeAssist/v1/vala", &_inner_error_);
		_g_object_unref0 (_tmp10_);
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			goto __catch7_g_error;
		}
		_tmp11_ = conn;
		_tmp12_ = dbus_document_iface_new (NULL);
		_tmp13_ = _tmp12_;
		dbus_document_iface_register_object (_tmp13_, _tmp11_, "/org/gnome/CodeAssist/v1/vala/document", &_inner_error_);
		_g_object_unref0 (_tmp13_);
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			goto __catch7_g_error;
		}
		_tmp14_ = conn;
		_tmp15_ = dbus_diagnostics_iface_new (NULL);
		_tmp16_ = _tmp15_;
		dbus_diagnostics_iface_register_object (_tmp16_, _tmp14_, "/org/gnome/CodeAssist/v1/vala/document", &_inner_error_);
		_g_object_unref0 (_tmp16_);
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			goto __catch7_g_error;
		}
	}
	goto __finally7;
	__catch7_g_error:
	{
		GError* e = NULL;
		FILE* _tmp17_ = NULL;
		GError* _tmp18_ = NULL;
		const gchar* _tmp19_ = NULL;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp17_ = stderr;
		_tmp18_ = e;
		_tmp19_ = _tmp18_->message;
		fprintf (_tmp17_, "Failed to register service: %s\n", _tmp19_);
		_g_error_free0 (e);
	}
	__finally7:
	if (G_UNLIKELY (_inner_error_ != NULL)) {
		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 dbus_transport_on_name_acquired (DBusTransport* self, GDBusConnection* conn, const gchar* name) {
	g_return_if_fail (self != NULL);
	g_return_if_fail (conn != NULL);
	g_return_if_fail (name != NULL);
}


static void dbus_transport_on_name_lost (DBusTransport* self, GDBusConnection* conn, const gchar* name) {
	GMainLoop* _tmp0_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (conn != NULL);
	g_return_if_fail (name != NULL);
	_tmp0_ = self->priv->d_main;
	g_main_loop_quit (_tmp0_);
}


static void _dbus_transport_on_bus_aquired_gbus_acquired_callback (GDBusConnection* connection, const gchar* name, gpointer self) {
	dbus_transport_on_bus_aquired ((DBusTransport*) self, connection);
}


static void _dbus_transport_on_name_acquired_gbus_name_acquired_callback (GDBusConnection* connection, const gchar* name, gpointer self) {
	dbus_transport_on_name_acquired ((DBusTransport*) self, connection, name);
}


static void _dbus_transport_on_name_lost_gbus_name_lost_callback (GDBusConnection* connection, const gchar* name, gpointer self) {
	dbus_transport_on_name_lost ((DBusTransport*) self, connection, name);
}


void dbus_transport_run (DBusTransport* self) {
	GMainLoop* _tmp0_ = NULL;
	g_return_if_fail (self != NULL);
	g_bus_own_name_with_closures (G_BUS_TYPE_SESSION, "org.gnome.CodeAssist.v1.vala", G_BUS_NAME_OWNER_FLAGS_NONE, (GClosure*) ((_dbus_transport_on_bus_aquired_gbus_acquired_callback == NULL) ? NULL : g_cclosure_new ((GCallback) _dbus_transport_on_bus_aquired_gbus_acquired_callback, dbus_transport_ref (self), dbus_transport_unref)), (GClosure*) ((_dbus_transport_on_name_acquired_gbus_name_acquired_callback == NULL) ? NULL : g_cclosure_new ((GCallback) _dbus_transport_on_name_acquired_gbus_name_acquired_callback, dbus_transport_ref (self), dbus_transport_unref)), (GClosure*) ((_dbus_transport_on_name_lost_gbus_name_lost_callback == NULL) ? NULL : g_cclosure_new ((GCallback) _dbus_transport_on_name_lost_gbus_name_lost_callback, dbus_transport_ref (self), dbus_transport_unref)));
	_tmp0_ = self->priv->d_main;
	g_main_loop_run (_tmp0_);
}


static void dbus_value_transport_init (GValue* value) {
	value->data[0].v_pointer = NULL;
}


static void dbus_value_transport_free_value (GValue* value) {
	if (value->data[0].v_pointer) {
		dbus_transport_unref (value->data[0].v_pointer);
	}
}


static void dbus_value_transport_copy_value (const GValue* src_value, GValue* dest_value) {
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = dbus_transport_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}


static gpointer dbus_value_transport_peek_pointer (const GValue* value) {
	return value->data[0].v_pointer;
}


static gchar* dbus_value_transport_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	if (collect_values[0].v_pointer) {
		DBusTransport* object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = dbus_transport_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}


static gchar* dbus_value_transport_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	DBusTransport** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = dbus_transport_ref (value->data[0].v_pointer);
	}
	return NULL;
}


GParamSpec* dbus_param_spec_transport (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
	DBusParamSpecTransport* spec;
	g_return_val_if_fail (g_type_is_a (object_type, DBUS_TYPE_TRANSPORT), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}


gpointer dbus_value_get_transport (const GValue* value) {
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_TYPE_TRANSPORT), NULL);
	return value->data[0].v_pointer;
}


void dbus_value_set_transport (GValue* value, gpointer v_object) {
	DBusTransport* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_TYPE_TRANSPORT));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, DBUS_TYPE_TRANSPORT));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		dbus_transport_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		dbus_transport_unref (old);
	}
}


void dbus_value_take_transport (GValue* value, gpointer v_object) {
	DBusTransport* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, DBUS_TYPE_TRANSPORT));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, DBUS_TYPE_TRANSPORT));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		dbus_transport_unref (old);
	}
}


static void dbus_transport_class_init (DBusTransportClass * klass) {
	dbus_transport_parent_class = g_type_class_peek_parent (klass);
	((DBusTransportClass *) klass)->finalize = dbus_transport_finalize;
	g_type_class_add_private (klass, sizeof (DBusTransportPrivate));
}


static void dbus_transport_instance_init (DBusTransport * self) {
	self->priv = DBUS_TRANSPORT_GET_PRIVATE (self);
	self->ref_count = 1;
}


static void dbus_transport_finalize (DBusTransport* obj) {
	DBusTransport * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, DBUS_TYPE_TRANSPORT, DBusTransport);
	g_signal_handlers_destroy (self);
	_dbus_server_unref0 (self->priv->d_server);
	_g_main_loop_unref0 (self->priv->d_main);
}


GType dbus_transport_get_type (void) {
	static volatile gsize dbus_transport_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_transport_type_id__volatile)) {
		static const GTypeValueTable g_define_type_value_table = { dbus_value_transport_init, dbus_value_transport_free_value, dbus_value_transport_copy_value, dbus_value_transport_peek_pointer, "p", dbus_value_transport_collect_value, "p", dbus_value_transport_lcopy_value };
		static const GTypeInfo g_define_type_info = { sizeof (DBusTransportClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_transport_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusTransport), 0, (GInstanceInitFunc) dbus_transport_instance_init, &g_define_type_value_table };
		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
		GType dbus_transport_type_id;
		dbus_transport_type_id = g_type_register_fundamental (g_type_fundamental_next (), "DBusTransport", &g_define_type_info, &g_define_type_fundamental_info, 0);
		g_once_init_leave (&dbus_transport_type_id__volatile, dbus_transport_type_id);
	}
	return dbus_transport_type_id__volatile;
}


gpointer dbus_transport_ref (gpointer instance) {
	DBusTransport* self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}


void dbus_transport_unref (gpointer instance) {
	DBusTransport* self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		DBUS_TRANSPORT_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}


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);
}



