expr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, expr);
}
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.Cancellable") {
- cancellable = expr;
- continue;
- }
-
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.BusName") {
- // ignore BusName sender parameters
- continue;
+ if (param.variable_type is ObjectType) {
+ var full_name = param.variable_type.type_symbol.get_full_name ();
+ switch (full_name) {
+ case "GLib.Cancellable":
+ cancellable = expr;
+ continue;
+ case "GLib.BusName":
+ case "GLib.DBusConnection":
+ case "GLib.DBusMethodInvocation":
+ // Ignore.
+ continue;
+ }
}
send_dbus_value (param.variable_type, new CCodeIdentifier ("_arguments_builder"), expr, param);
var out_args_info = new CCodeInitializerList ();
foreach (Parameter param in m.get_parameters ()) {
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.Cancellable") {
- continue;
- }
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.BusName") {
- continue;
+ if (param.variable_type is ObjectType) {
+ var full_name = param.variable_type.type_symbol.get_full_name ();
+ switch (full_name) {
+ case "GLib.Cancellable":
+ case "GLib.BusName":
+ case "GLib.DBusConnection":
+ case "GLib.DBusMethodInvocation":
+ continue;
+ }
}
var info = new CCodeInitializerList ();
continue;
}
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.Cancellable") {
- continue;
- }
-
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.BusName") {
- // ignore BusName sender parameters
- continue;
+ // Skip special parameters.
+ if (param.variable_type is ObjectType) {
+ var full_name = param.variable_type.type_symbol.get_full_name ();
+ switch (full_name) {
+ case "GLib.Cancellable":
+ case "GLib.BusName":
+ case "GLib.DBusConnection":
+ case "GLib.DBusMethodInvocation":
+ continue;
+ }
}
CCodeExpression param_expr;
}
if (param.direction == ParameterDirection.IN && !ready) {
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.Cancellable") {
- ccall.add_argument (new CCodeConstant ("NULL"));
- continue;
- }
-
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.BusName") {
- // ignore BusName sender parameters
- var sender = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_method_invocation_get_sender"));
- sender.add_argument (new CCodeIdentifier ("invocation"));
- ccall.add_argument (sender);
- continue;
+ // Handle special params.
+ if (param.variable_type is ObjectType) {
+ var full_name = param.variable_type.type_symbol.get_full_name ();
+ switch (full_name) {
+ case "GLib.Cancellable":
+ // No cancellable on the server side.
+ if (!param.variable_type.nullable) {
+ Report.warning (param.variable_type.source_reference, "D-Bus cancellable parameters should be nullable");
+ }
+ ccall.add_argument (new CCodeConstant ("NULL"));
+ continue;
+ case "GLib.BusName":
+ var sender = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_method_invocation_get_sender"));
+ sender.add_argument (new CCodeIdentifier ("invocation"));
+ if (param.variable_type.value_owned) {
+ var cdup = new CCodeFunctionCall (new CCodeIdentifier ("g_strdup"));
+ cdup.add_argument (sender);
+ sender = (owned) cdup;
+ }
+ ccall.add_argument (sender);
+ continue;
+ case "GLib.DBusConnection":
+ var cconn = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_method_invocation_get_connection"));
+ cconn.add_argument (new CCodeIdentifier ("invocation"));
+ if (param.variable_type.value_owned) {
+ var cref = new CCodeFunctionCall (new CCodeIdentifier ("g_object_ref"));
+ cref.add_argument (cconn);
+ cconn = (owned) cref;
+ }
+ ccall.add_argument (cconn);
+ continue;
+ case "GLib.DBusMethodInvocation":
+ CCodeExpression cinvoc = new CCodeIdentifier ("invocation");
+ if (param.variable_type.value_owned) {
+ var cref = new CCodeFunctionCall (new CCodeIdentifier ("g_object_ref"));
+ cref.add_argument (cinvoc);
+ cinvoc = (owned) cref;
+ }
+ ccall.add_argument (cinvoc);
+ continue;
+ }
}
unowned Struct? st = param.variable_type.type_symbol as Struct;
foreach (Parameter param in m.get_parameters ()) {
if ((param.direction == ParameterDirection.IN && (ready_data_expr == null || ready)) ||
(param.direction == ParameterDirection.OUT && !no_reply && (!m.coroutine || ready))) {
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.Cancellable") {
- continue;
- }
- if (param.variable_type is ObjectType && param.variable_type.type_symbol.get_full_name () == "GLib.BusName") {
- // ignore BusName sender parameters
- continue;
+ if (param.variable_type is ObjectType) {
+ var full_name = param.variable_type.type_symbol.get_full_name ();
+ switch (full_name) {
+ case "GLib.Cancellable":
+ case "GLib.BusName":
+ case "GLib.DBusConnection":
+ case "GLib.DBusMethodInvocation":
+ continue;
+ }
}
var owned_type = param.variable_type.copy ();
dbus/generics.test \
dbus/no-reply.test \
dbus/signals.test \
+ dbus/special-parameters-1.vala \
+ dbus/special-parameters-2.test \
dbus/filedescriptor.test \
dbus/filedescriptor-async.test \
dbus/filedescriptor-errors.test \
--- /dev/null
+/* dbus_special_parameters_1.c generated by valac, the Vala compiler
+ * generated from dbus_special_parameters_1.vala, do not modify */
+
+#include <glib-object.h>
+#include <gio/gio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+
+#if !defined(VALA_STRICT_C)
+#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
+#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
+#elif defined(__clang__) && (__clang_major__ >= 16)
+#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
+#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
+#endif
+#endif
+#if !defined(VALA_EXTERN)
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define VALA_EXTERN __declspec(dllexport) extern
+#elif __GNUC__ >= 4
+#define VALA_EXTERN __attribute__((visibility("default"))) extern
+#else
+#define VALA_EXTERN extern
+#endif
+#endif
+
+#define TYPE_SERVER (server_get_type ())
+#define SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SERVER, Server))
+#define SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SERVER, ServerClass))
+#define IS_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SERVER))
+#define IS_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SERVER))
+#define SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SERVER, ServerClass))
+
+typedef struct _Server Server;
+typedef struct _ServerClass ServerClass;
+typedef struct _ServerPrivate ServerPrivate;
+enum {
+ SERVER_0_PROPERTY,
+ SERVER_NUM_PROPERTIES
+};
+static GParamSpec* server_properties[SERVER_NUM_PROPERTIES];
+#define _g_free0(var) (var = (g_free (var), NULL))
+#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
+typedef struct _ServerAsyncMethodData ServerAsyncMethodData;
+typedef struct _ServerAsyncMethodReadyData ServerAsyncMethodReadyData;
+
+#define TYPE_PROXY (proxy_get_type ())
+#define PROXY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PROXY, Proxy))
+#define IS_PROXY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PROXY))
+#define PROXY_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_PROXY, ProxyIface))
+
+typedef struct _Proxy Proxy;
+typedef struct _ProxyIface ProxyIface;
+
+#define TYPE_PROXY_PROXY (proxy_proxy_get_type ())
+typedef GDBusProxy ProxyProxy;
+typedef GDBusProxyClass ProxyProxyClass;
+typedef struct _ProxyAsyncMethodReadyData ProxyAsyncMethodReadyData;
+
+struct _Server {
+ GObject parent_instance;
+ ServerPrivate * priv;
+};
+
+struct _ServerClass {
+ GObjectClass parent_class;
+};
+
+struct _ServerAsyncMethodData {
+ int _state_;
+ GObject* _source_object_;
+ GAsyncResult* _res_;
+ GTask* _async_result;
+ Server* self;
+ char* sender;
+ GCancellable* cancellable;
+ GDBusConnection* conn;
+ GDBusMethodInvocation* inv;
+ gint arg;
+};
+
+struct _ServerAsyncMethodReadyData {
+ GDBusMethodInvocation* _invocation_;
+ gint arg;
+};
+
+struct _ProxyIface {
+ GTypeInterface parent_iface;
+ void (*sync_method) (Proxy* self, const char* sender, GCancellable* cancellable, GDBusConnection* conn, GDBusMethodInvocation* inv, gint arg, GError** error);
+ void (*async_method) (Proxy* self, const char* sender, GCancellable* cancellable, GDBusConnection* conn, GDBusMethodInvocation* inv, gint arg, GAsyncReadyCallback _callback_, gpointer _user_data_);
+ void (*async_method_finish) (Proxy* self, GAsyncResult* _res_, GError** error);
+};
+
+struct _ProxyAsyncMethodReadyData {
+ GDBusMethodInvocation* _invocation_;
+ gint arg;
+};
+
+static gpointer server_parent_class = NULL;
+
+VALA_EXTERN GType server_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Server, g_object_unref)
+VALA_EXTERN guint server_register_object (void* object,
+ GDBusConnection* connection,
+ const gchar* path,
+ GError** error);
+VALA_EXTERN void server_sync_method (Server* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GError** error);
+static void server_async_method_data_free (gpointer _data);
+VALA_EXTERN void server_async_method (Server* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GAsyncReadyCallback _callback_,
+ gpointer _user_data_);
+VALA_EXTERN void server_async_method_finish (Server* self,
+ GAsyncResult* _res_,
+ GError** error);
+static gboolean server_async_method_co (ServerAsyncMethodData* _data_);
+VALA_EXTERN Server* server_new (void);
+VALA_EXTERN Server* server_construct (GType object_type);
+static GType server_get_type_once (void);
+static void _dbus_server_sync_method (Server* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation);
+static void _dbus_server_async_method (Server* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation);
+static void _dbus_server_async_method_ready (GObject * source_object,
+ GAsyncResult * _res_,
+ gpointer _user_data_);
+static void server_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* server_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 server_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 _server_unregister_object (gpointer user_data);
+VALA_EXTERN GType proxy_proxy_get_type (void) G_GNUC_CONST ;
+VALA_EXTERN guint proxy_register_object (void* object,
+ GDBusConnection* connection,
+ const gchar* path,
+ GError** error);
+VALA_EXTERN GType proxy_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Proxy, g_object_unref)
+VALA_EXTERN void proxy_sync_method (Proxy* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GError** error);
+VALA_EXTERN void proxy_async_method (Proxy* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GAsyncReadyCallback _callback_,
+ gpointer _user_data_);
+VALA_EXTERN void proxy_async_method_finish (Proxy* self,
+ GAsyncResult* _res_,
+ GError** error);
+static GType proxy_get_type_once (void);
+static void proxy_proxy_g_signal (GDBusProxy* proxy,
+ const gchar* sender_name,
+ const gchar* signal_name,
+ GVariant* parameters);
+static void proxy_proxy_sync_method (Proxy* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GError** error);
+static void proxy_proxy_async_method_async (Proxy* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GAsyncReadyCallback _callback_,
+ gpointer _user_data_);
+static void proxy_proxy_async_method_finish (Proxy* self,
+ GAsyncResult* _res_,
+ GError** error);
+static void proxy_proxy_proxy_interface_init (ProxyIface* iface);
+static void _dbus_proxy_sync_method (Proxy* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation);
+static void _dbus_proxy_async_method (Proxy* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation);
+static void _dbus_proxy_async_method_ready (GObject * source_object,
+ GAsyncResult * _res_,
+ gpointer _user_data_);
+static void proxy_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* proxy_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 proxy_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 _proxy_unregister_object (gpointer user_data);
+static void _vala_main (void);
+
+static const GDBusArgInfo _server_dbus_arg_info_sync_method_arg = {-1, "arg", "i", NULL};
+static const GDBusArgInfo * const _server_dbus_arg_info_sync_method_in[] = {&_server_dbus_arg_info_sync_method_arg, NULL};
+static const GDBusArgInfo * const _server_dbus_arg_info_sync_method_out[] = {NULL};
+static const GDBusMethodInfo _server_dbus_method_info_sync_method = {-1, "SyncMethod", (GDBusArgInfo **) (&_server_dbus_arg_info_sync_method_in), (GDBusArgInfo **) (&_server_dbus_arg_info_sync_method_out), NULL};
+static const GDBusArgInfo _server_dbus_arg_info_async_method_arg = {-1, "arg", "i", NULL};
+static const GDBusArgInfo * const _server_dbus_arg_info_async_method_in[] = {&_server_dbus_arg_info_async_method_arg, NULL};
+static const GDBusArgInfo * const _server_dbus_arg_info_async_method_out[] = {NULL};
+static const GDBusMethodInfo _server_dbus_method_info_async_method = {-1, "AsyncMethod", (GDBusArgInfo **) (&_server_dbus_arg_info_async_method_in), (GDBusArgInfo **) (&_server_dbus_arg_info_async_method_out), NULL};
+static const GDBusMethodInfo * const _server_dbus_method_info[] = {&_server_dbus_method_info_sync_method, &_server_dbus_method_info_async_method, NULL};
+static const GDBusSignalInfo * const _server_dbus_signal_info[] = {NULL};
+static const GDBusPropertyInfo * const _server_dbus_property_info[] = {NULL};
+static const GDBusInterfaceInfo _server_dbus_interface_info = {-1, "org.example.Server", (GDBusMethodInfo **) (&_server_dbus_method_info), (GDBusSignalInfo **) (&_server_dbus_signal_info), (GDBusPropertyInfo **) (&_server_dbus_property_info), NULL};
+static const GDBusInterfaceVTable _server_dbus_interface_vtable = {server_dbus_interface_method_call, server_dbus_interface_get_property, server_dbus_interface_set_property};
+static const GDBusArgInfo _proxy_dbus_arg_info_sync_method_arg = {-1, "arg", "i", NULL};
+static const GDBusArgInfo * const _proxy_dbus_arg_info_sync_method_in[] = {&_proxy_dbus_arg_info_sync_method_arg, NULL};
+static const GDBusArgInfo * const _proxy_dbus_arg_info_sync_method_out[] = {NULL};
+static const GDBusMethodInfo _proxy_dbus_method_info_sync_method = {-1, "SyncMethod", (GDBusArgInfo **) (&_proxy_dbus_arg_info_sync_method_in), (GDBusArgInfo **) (&_proxy_dbus_arg_info_sync_method_out), NULL};
+static const GDBusArgInfo _proxy_dbus_arg_info_async_method_arg = {-1, "arg", "i", NULL};
+static const GDBusArgInfo * const _proxy_dbus_arg_info_async_method_in[] = {&_proxy_dbus_arg_info_async_method_arg, NULL};
+static const GDBusArgInfo * const _proxy_dbus_arg_info_async_method_out[] = {NULL};
+static const GDBusMethodInfo _proxy_dbus_method_info_async_method = {-1, "AsyncMethod", (GDBusArgInfo **) (&_proxy_dbus_arg_info_async_method_in), (GDBusArgInfo **) (&_proxy_dbus_arg_info_async_method_out), NULL};
+static const GDBusMethodInfo * const _proxy_dbus_method_info[] = {&_proxy_dbus_method_info_sync_method, &_proxy_dbus_method_info_async_method, NULL};
+static const GDBusSignalInfo * const _proxy_dbus_signal_info[] = {NULL};
+static const GDBusPropertyInfo * const _proxy_dbus_property_info[] = {NULL};
+static const GDBusInterfaceInfo _proxy_dbus_interface_info = {-1, "org.example.Server", (GDBusMethodInfo **) (&_proxy_dbus_method_info), (GDBusSignalInfo **) (&_proxy_dbus_signal_info), (GDBusPropertyInfo **) (&_proxy_dbus_property_info), NULL};
+static const GDBusInterfaceVTable _proxy_dbus_interface_vtable = {proxy_dbus_interface_method_call, proxy_dbus_interface_get_property, proxy_dbus_interface_set_property};
+
+void
+server_sync_method (Server* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GError** error)
+{
+ g_return_if_fail (IS_SERVER (self));
+ g_return_if_fail (sender != NULL);
+ g_return_if_fail ((cancellable == NULL) || G_TYPE_CHECK_INSTANCE_TYPE (cancellable, g_cancellable_get_type ()));
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (conn, g_dbus_connection_get_type ()));
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (inv, g_dbus_method_invocation_get_type ()));
+}
+
+static void
+server_async_method_data_free (gpointer _data)
+{
+ ServerAsyncMethodData* _data_;
+ _data_ = _data;
+ _g_free0 (_data_->sender);
+ _g_object_unref0 (_data_->cancellable);
+ _g_object_unref0 (_data_->conn);
+ _g_object_unref0 (_data_->inv);
+ _g_object_unref0 (_data_->self);
+ g_slice_free (ServerAsyncMethodData, _data_);
+}
+
+static gpointer
+_g_object_ref0 (gpointer self)
+{
+ return self ? g_object_ref (self) : NULL;
+}
+
+void
+server_async_method (Server* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GAsyncReadyCallback _callback_,
+ gpointer _user_data_)
+{
+ ServerAsyncMethodData* _data_;
+ Server* _tmp0_;
+ char* _tmp1_;
+ GCancellable* _tmp2_;
+ GDBusConnection* _tmp3_;
+ GDBusMethodInvocation* _tmp4_;
+ g_return_if_fail (IS_SERVER (self));
+ g_return_if_fail (sender != NULL);
+ g_return_if_fail ((cancellable == NULL) || G_TYPE_CHECK_INSTANCE_TYPE (cancellable, g_cancellable_get_type ()));
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (conn, g_dbus_connection_get_type ()));
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (inv, g_dbus_method_invocation_get_type ()));
+ _data_ = g_slice_new0 (ServerAsyncMethodData);
+ _data_->_async_result = g_task_new (G_OBJECT (self), cancellable, _callback_, _user_data_);
+ g_task_set_source_tag (_data_->_async_result, server_async_method);
+ g_task_set_task_data (_data_->_async_result, _data_, server_async_method_data_free);
+ _tmp0_ = _g_object_ref0 (self);
+ _data_->self = _tmp0_;
+ _tmp1_ = g_strdup (sender);
+ _g_free0 (_data_->sender);
+ _data_->sender = _tmp1_;
+ _tmp2_ = _g_object_ref0 (cancellable);
+ _g_object_unref0 (_data_->cancellable);
+ _data_->cancellable = _tmp2_;
+ _tmp3_ = _g_object_ref0 (conn);
+ _g_object_unref0 (_data_->conn);
+ _data_->conn = _tmp3_;
+ _tmp4_ = _g_object_ref0 (inv);
+ _g_object_unref0 (_data_->inv);
+ _data_->inv = _tmp4_;
+ _data_->arg = arg;
+ server_async_method_co (_data_);
+}
+
+void
+server_async_method_finish (Server* self,
+ GAsyncResult* _res_,
+ GError** error)
+{
+ ServerAsyncMethodData* _data_;
+ g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+ g_return_if_fail (g_async_result_is_tagged (_res_, server_async_method));
+ _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
+ if (NULL == _data_) {
+ return;
+ }
+}
+
+static gboolean
+server_async_method_co (ServerAsyncMethodData* _data_)
+{
+ switch (_data_->_state_) {
+ case 0:
+ goto _state_0;
+ default:
+ g_assert_not_reached ();
+ }
+ _state_0:
+ g_task_return_pointer (_data_->_async_result, _data_, NULL);
+ if (_data_->_state_ != 0) {
+ while (!g_task_get_completed (_data_->_async_result)) {
+ g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
+ }
+ }
+ g_object_unref (_data_->_async_result);
+ return FALSE;
+}
+
+Server*
+server_construct (GType object_type)
+{
+ Server * self = NULL;
+ self = (Server*) g_object_new (object_type, NULL);
+ return self;
+}
+
+Server*
+server_new (void)
+{
+ return server_construct (TYPE_SERVER);
+}
+
+static void
+server_class_init (ServerClass * klass,
+ gpointer klass_data)
+{
+ server_parent_class = g_type_class_peek_parent (klass);
+}
+
+static void
+server_instance_init (Server * self,
+ gpointer klass)
+{
+}
+
+static GType
+server_get_type_once (void)
+{
+ static const GTypeInfo g_define_type_info = { sizeof (ServerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) server_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Server), 0, (GInstanceInitFunc) server_instance_init, NULL };
+ GType server_type_id;
+ server_type_id = g_type_register_static (G_TYPE_OBJECT, "Server", &g_define_type_info, 0);
+ g_type_set_qdata (server_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) server_register_object);
+ return server_type_id;
+}
+
+GType
+server_get_type (void)
+{
+ static volatile gsize server_type_id__once = 0;
+ if (g_once_init_enter (&server_type_id__once)) {
+ GType server_type_id;
+ server_type_id = server_get_type_once ();
+ g_once_init_leave (&server_type_id__once, server_type_id);
+ }
+ return server_type_id__once;
+}
+
+static void
+_dbus_server_sync_method (Server* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation)
+{
+ GError* error = NULL;
+ GVariantIter _arguments_iter;
+ gint arg = 0;
+ GVariant* _tmp0_;
+ GDBusMessage* _reply_message = NULL;
+ GVariant* _reply;
+ GVariantBuilder _reply_builder;
+ g_variant_iter_init (&_arguments_iter, _parameters_);
+ _tmp0_ = g_variant_iter_next_value (&_arguments_iter);
+ arg = g_variant_get_int32 (_tmp0_);
+ g_variant_unref (_tmp0_);
+ server_sync_method (self, g_dbus_method_invocation_get_sender (invocation), NULL, g_dbus_method_invocation_get_connection (invocation), invocation, arg, &error);
+ if (error) {
+ g_dbus_method_invocation_take_error (invocation, error);
+ return;
+ }
+ _reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
+ g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
+ _reply = g_variant_builder_end (&_reply_builder);
+ g_dbus_message_set_body (_reply_message, _reply);
+ g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
+ g_object_unref (invocation);
+ g_object_unref (_reply_message);
+}
+
+static void
+_dbus_server_async_method (Server* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation)
+{
+ GVariantIter _arguments_iter;
+ ServerAsyncMethodReadyData* _ready_data;
+ GVariant* _tmp1_;
+ g_variant_iter_init (&_arguments_iter, _parameters_);
+ _ready_data = g_slice_new0 (ServerAsyncMethodReadyData);
+ _ready_data->_invocation_ = invocation;
+ _tmp1_ = g_variant_iter_next_value (&_arguments_iter);
+ _ready_data->arg = g_variant_get_int32 (_tmp1_);
+ g_variant_unref (_tmp1_);
+ server_async_method (self, g_dbus_method_invocation_get_sender (invocation), NULL, g_dbus_method_invocation_get_connection (invocation), invocation, _ready_data->arg, (GAsyncReadyCallback) _dbus_server_async_method_ready, _ready_data);
+}
+
+static void
+_dbus_server_async_method_ready (GObject * source_object,
+ GAsyncResult * _res_,
+ gpointer _user_data_)
+{
+ ServerAsyncMethodReadyData* _ready_data;
+ GDBusMethodInvocation* invocation;
+ GError* error = NULL;
+ GDBusMessage* _reply_message = NULL;
+ GVariant* _reply;
+ GVariantBuilder _reply_builder;
+ _ready_data = _user_data_;
+ invocation = _ready_data->_invocation_;
+ server_async_method_finish ((Server*) source_object, _res_, &error);
+ if (error) {
+ g_dbus_method_invocation_take_error (invocation, error);
+ goto _error;
+ }
+ _reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
+ g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
+ _reply = g_variant_builder_end (&_reply_builder);
+ g_dbus_message_set_body (_reply_message, _reply);
+ g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
+ g_object_unref (invocation);
+ g_object_unref (_reply_message);
+ _error:
+ g_slice_free (ServerAsyncMethodReadyData, _ready_data);
+}
+
+static void
+server_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, "SyncMethod") == 0) {
+ _dbus_server_sync_method (object, parameters, invocation);
+ } else if (strcmp (method_name, "AsyncMethod") == 0) {
+ _dbus_server_async_method (object, parameters, invocation);
+ } else {
+ g_object_unref (invocation);
+ }
+}
+
+static GVariant*
+server_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)
+{
+ return NULL;
+}
+
+static gboolean
+server_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)
+{
+ return FALSE;
+}
+
+guint
+server_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 *) (&_server_dbus_interface_info), &_server_dbus_interface_vtable, data, _server_unregister_object, error);
+ if (!result) {
+ return 0;
+ }
+ return result;
+}
+
+static void
+_server_unregister_object (gpointer user_data)
+{
+ gpointer* data;
+ data = user_data;
+ g_object_unref (data[0]);
+ g_object_unref (data[1]);
+ g_free (data[2]);
+ g_free (data);
+}
+
+void
+proxy_sync_method (Proxy* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GError** error)
+{
+ ProxyIface* _iface_;
+ g_return_if_fail (IS_PROXY (self));
+ _iface_ = PROXY_GET_INTERFACE (self);
+ if (_iface_->sync_method) {
+ _iface_->sync_method (self, sender, cancellable, conn, inv, arg, error);
+ }
+}
+
+void
+proxy_async_method (Proxy* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GAsyncReadyCallback _callback_,
+ gpointer _user_data_)
+{
+ ProxyIface* _iface_;
+ _iface_ = PROXY_GET_INTERFACE (self);
+ if (_iface_->async_method) {
+ _iface_->async_method (self, sender, cancellable, conn, inv, arg, _callback_, _user_data_);
+ }
+}
+
+void
+proxy_async_method_finish (Proxy* self,
+ GAsyncResult* _res_,
+ GError** error)
+{
+ ProxyIface* _iface_;
+ _iface_ = PROXY_GET_INTERFACE (self);
+ if (_iface_->async_method_finish) {
+ _iface_->async_method_finish (self, _res_, error);
+ }
+}
+
+static void
+proxy_default_init (ProxyIface * iface,
+ gpointer iface_data)
+{
+}
+
+static GType
+proxy_get_type_once (void)
+{
+ static const GTypeInfo g_define_type_info = { sizeof (ProxyIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proxy_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
+ GType proxy_type_id;
+ proxy_type_id = g_type_register_static (G_TYPE_INTERFACE, "Proxy", &g_define_type_info, 0);
+ g_type_interface_add_prerequisite (proxy_type_id, G_TYPE_OBJECT);
+ g_type_set_qdata (proxy_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) proxy_proxy_get_type);
+ g_type_set_qdata (proxy_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.example.Server");
+ g_type_set_qdata (proxy_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_proxy_dbus_interface_info));
+ g_type_set_qdata (proxy_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) proxy_register_object);
+ return proxy_type_id;
+}
+
+GType
+proxy_get_type (void)
+{
+ static volatile gsize proxy_type_id__once = 0;
+ if (g_once_init_enter (&proxy_type_id__once)) {
+ GType proxy_type_id;
+ proxy_type_id = proxy_get_type_once ();
+ g_once_init_leave (&proxy_type_id__once, proxy_type_id);
+ }
+ return proxy_type_id__once;
+}
+
+G_DEFINE_TYPE_EXTENDED (ProxyProxy, proxy_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (TYPE_PROXY, proxy_proxy_proxy_interface_init) )
+static void
+proxy_proxy_class_init (ProxyProxyClass* klass)
+{
+ G_DBUS_PROXY_CLASS (klass)->g_signal = proxy_proxy_g_signal;
+}
+
+static void
+proxy_proxy_g_signal (GDBusProxy* proxy,
+ const gchar* sender_name,
+ const gchar* signal_name,
+ GVariant* parameters)
+{
+}
+
+static void
+proxy_proxy_init (ProxyProxy* self)
+{
+ g_dbus_proxy_set_interface_info (G_DBUS_PROXY (self), (GDBusInterfaceInfo *) (&_proxy_dbus_interface_info));
+}
+
+static void
+proxy_proxy_sync_method (Proxy* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GError** error)
+{
+ GVariant *_reply;
+ GVariantBuilder _arguments_builder;
+ g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
+ g_variant_builder_add_value (&_arguments_builder, g_variant_new_int32 (arg));
+ _reply = g_dbus_proxy_call_sync ((GDBusProxy *) self, "SyncMethod", g_variant_builder_end (&_arguments_builder), G_DBUS_CALL_FLAGS_NONE, -1, cancellable, error);
+ if (!_reply) {
+ return;
+ }
+ g_variant_unref (_reply);
+}
+
+static void
+proxy_proxy_async_method_async (Proxy* self,
+ const char* sender,
+ GCancellable* cancellable,
+ GDBusConnection* conn,
+ GDBusMethodInvocation* inv,
+ gint arg,
+ GAsyncReadyCallback _callback_,
+ gpointer _user_data_)
+{
+ GVariantBuilder _arguments_builder;
+ g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
+ g_variant_builder_add_value (&_arguments_builder, g_variant_new_int32 (arg));
+ g_dbus_proxy_call ((GDBusProxy *) self, "AsyncMethod", g_variant_builder_end (&_arguments_builder), G_DBUS_CALL_FLAGS_NONE, -1, cancellable, _callback_, _user_data_);
+}
+
+static void
+proxy_proxy_async_method_finish (Proxy* self,
+ GAsyncResult* _res_,
+ GError** error)
+{
+ GVariant *_reply;
+ _reply = g_dbus_proxy_call_finish ((GDBusProxy *) self, _res_, error);
+ if (!_reply) {
+ return;
+ }
+ g_variant_unref (_reply);
+}
+
+static void
+proxy_proxy_proxy_interface_init (ProxyIface* iface)
+{
+ iface->sync_method = proxy_proxy_sync_method;
+ iface->async_method = proxy_proxy_async_method_async;
+ iface->async_method_finish = proxy_proxy_async_method_finish;
+}
+
+static void
+_dbus_proxy_sync_method (Proxy* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation)
+{
+ GError* error = NULL;
+ GVariantIter _arguments_iter;
+ gint arg = 0;
+ GVariant* _tmp2_;
+ GDBusMessage* _reply_message = NULL;
+ GVariant* _reply;
+ GVariantBuilder _reply_builder;
+ g_variant_iter_init (&_arguments_iter, _parameters_);
+ _tmp2_ = g_variant_iter_next_value (&_arguments_iter);
+ arg = g_variant_get_int32 (_tmp2_);
+ g_variant_unref (_tmp2_);
+ proxy_sync_method (self, g_dbus_method_invocation_get_sender (invocation), NULL, g_dbus_method_invocation_get_connection (invocation), invocation, arg, &error);
+ if (error) {
+ g_dbus_method_invocation_take_error (invocation, error);
+ return;
+ }
+ _reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
+ g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
+ _reply = g_variant_builder_end (&_reply_builder);
+ g_dbus_message_set_body (_reply_message, _reply);
+ g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
+ g_object_unref (invocation);
+ g_object_unref (_reply_message);
+}
+
+static void
+_dbus_proxy_async_method (Proxy* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation)
+{
+ GVariantIter _arguments_iter;
+ ProxyAsyncMethodReadyData* _ready_data;
+ GVariant* _tmp3_;
+ g_variant_iter_init (&_arguments_iter, _parameters_);
+ _ready_data = g_slice_new0 (ProxyAsyncMethodReadyData);
+ _ready_data->_invocation_ = invocation;
+ _tmp3_ = g_variant_iter_next_value (&_arguments_iter);
+ _ready_data->arg = g_variant_get_int32 (_tmp3_);
+ g_variant_unref (_tmp3_);
+ proxy_async_method (self, g_dbus_method_invocation_get_sender (invocation), NULL, g_dbus_method_invocation_get_connection (invocation), invocation, _ready_data->arg, (GAsyncReadyCallback) _dbus_proxy_async_method_ready, _ready_data);
+}
+
+static void
+_dbus_proxy_async_method_ready (GObject * source_object,
+ GAsyncResult * _res_,
+ gpointer _user_data_)
+{
+ ProxyAsyncMethodReadyData* _ready_data;
+ GDBusMethodInvocation* invocation;
+ GError* error = NULL;
+ GDBusMessage* _reply_message = NULL;
+ GVariant* _reply;
+ GVariantBuilder _reply_builder;
+ _ready_data = _user_data_;
+ invocation = _ready_data->_invocation_;
+ proxy_async_method_finish ((Proxy*) source_object, _res_, &error);
+ if (error) {
+ g_dbus_method_invocation_take_error (invocation, error);
+ goto _error;
+ }
+ _reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
+ g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
+ _reply = g_variant_builder_end (&_reply_builder);
+ g_dbus_message_set_body (_reply_message, _reply);
+ g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
+ g_object_unref (invocation);
+ g_object_unref (_reply_message);
+ _error:
+ g_slice_free (ProxyAsyncMethodReadyData, _ready_data);
+}
+
+static void
+proxy_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, "SyncMethod") == 0) {
+ _dbus_proxy_sync_method (object, parameters, invocation);
+ } else if (strcmp (method_name, "AsyncMethod") == 0) {
+ _dbus_proxy_async_method (object, parameters, invocation);
+ } else {
+ g_object_unref (invocation);
+ }
+}
+
+static GVariant*
+proxy_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)
+{
+ return NULL;
+}
+
+static gboolean
+proxy_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)
+{
+ return FALSE;
+}
+
+guint
+proxy_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 *) (&_proxy_dbus_interface_info), &_proxy_dbus_interface_vtable, data, _proxy_unregister_object, error);
+ if (!result) {
+ return 0;
+ }
+ return result;
+}
+
+static void
+_proxy_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
+_vala_main (void)
+{
+}
+
+int
+main (int argc,
+ char ** argv)
+{
+ _vala_main ();
+ return 0;
+}
+
--- /dev/null
+[DBus (name = "org.example.Server")]
+class Server : Object {
+ public void sync_method (BusName sender, Cancellable? cancellable, DBusConnection conn, DBusMethodInvocation inv, int arg) throws DBusError, IOError {
+ }
+
+ public async void async_method (BusName sender, Cancellable? cancellable, DBusConnection conn, DBusMethodInvocation inv, int arg) throws DBusError, IOError {
+ }
+}
+
+[DBus (name = "org.example.Server")]
+interface Proxy : Object {
+ public abstract void sync_method (BusName sender, Cancellable? cancellable, DBusConnection conn, DBusMethodInvocation inv, int arg) throws DBusError, IOError;
+ public abstract async void async_method (BusName sender, Cancellable? cancellable, DBusConnection conn, DBusMethodInvocation inv, int arg) throws DBusError, IOError;
+}
+
+void main () {
+}
--- /dev/null
+Packages: gio-2.0
+D-Bus
+
+Program: client
+
+[DBus (name = "org.example.Test.Manager")]
+interface Manager : Object {
+ public abstract ObjectPath get_unit (string name) throws Error;
+}
+
+[DBus (name = "org.example.Test.Unit")]
+interface Unit : Object {
+ public abstract string name { owned get; }
+}
+
+void main () {
+ // client
+ Manager manager = Bus.get_proxy_sync (SESSION, "org.example.Test", "/org/example/test/Manager");
+ var unit_path = manager.get_unit ("example.service");
+ assert (unit_path == "/org/example/test/Manager/0");
+ // Proxy for the same connection, same name.
+ unowned DBusProxy manager_proxy = (DBusProxy) manager;
+ Unit unit = manager_proxy.get_connection ().get_proxy_sync (manager_proxy.get_name_owner (), unit_path);
+ assert (unit.name == "example.service");
+}
+
+Program: server
+
+[DBus (name = "org.example.Test.Manager")]
+class Manager : Object {
+ private uint next_unit_id = 0;
+
+ public ObjectPath get_unit (string name, DBusConnection connection, DBusMethodInvocation invocation) {
+ // If exposed under different object paths (perhaps on different connections), we can
+ // know the one we're accessed htrough this time.
+ unowned string my_object_path = invocation.get_object_path ();
+ uint unit_id = next_unit_id++;
+ string unit_object_path = @"$my_object_path/$unit_id";
+ var unit = new Unit () { name = name };
+ // Register the unit object on the same connection that the request is made on.
+ connection.register_object (unit_object_path, unit);
+ return new ObjectPath (unit_object_path);
+ }
+}
+
+[DBus (name = "org.example.Test.Unit")]
+class Unit : Object {
+ public string name { get; construct set; }
+}
+
+MainLoop main_loop;
+
+void client_exit (Pid pid, int status) {
+ // client finished, terminate server
+ assert (status == 0);
+ main_loop.quit ();
+}
+
+void main () {
+ var conn = Bus.get_sync (SESSION);
+ conn.register_object ("/org/example/test/Manager", new Manager ());
+
+ // try to register service in session bus
+ var request_result = conn.call_sync ("org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "RequestName",
+ new Variant ("(su)", "org.example.Test", 0x4), null, 0, -1);
+ assert ((uint) request_result.get_child_value (0) == 1);
+
+ // server ready, spawn client
+ Pid client_pid;
+ Process.spawn_async (null, { "dbus_special_parameters_2_client" }, null, SpawnFlags.DO_NOT_REAP_CHILD, null, out client_pid);
+ ChildWatch.add (client_pid, client_exit);
+
+ main_loop = new MainLoop ();
+ main_loop.run ();
+}
--- /dev/null
+/* dbus_special_parameters_2_client.c generated by valac, the Vala compiler
+ * generated from dbus_special_parameters_2_client.vala, do not modify */
+
+#include <glib-object.h>
+#include <gio/gio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+
+#if !defined(VALA_STRICT_C)
+#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
+#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
+#elif defined(__clang__) && (__clang_major__ >= 16)
+#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
+#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
+#endif
+#endif
+#if !defined(VALA_EXTERN)
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define VALA_EXTERN __declspec(dllexport) extern
+#elif __GNUC__ >= 4
+#define VALA_EXTERN __attribute__((visibility("default"))) extern
+#else
+#define VALA_EXTERN extern
+#endif
+#endif
+
+#define TYPE_MANAGER (manager_get_type ())
+#define MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MANAGER, Manager))
+#define IS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MANAGER))
+#define MANAGER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_MANAGER, ManagerIface))
+
+typedef struct _Manager Manager;
+typedef struct _ManagerIface ManagerIface;
+
+#define TYPE_MANAGER_PROXY (manager_proxy_get_type ())
+typedef GDBusProxy ManagerProxy;
+typedef GDBusProxyClass ManagerProxyClass;
+#define _g_free0(var) (var = (g_free (var), NULL))
+
+#define TYPE_UNIT (unit_get_type ())
+#define UNIT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_UNIT, Unit))
+#define IS_UNIT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_UNIT))
+#define UNIT_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_UNIT, UnitIface))
+
+typedef struct _Unit Unit;
+typedef struct _UnitIface UnitIface;
+
+#define TYPE_UNIT_PROXY (unit_proxy_get_type ())
+typedef GDBusProxy UnitProxy;
+typedef GDBusProxyClass UnitProxyClass;
+#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
+#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
+#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
+#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+
+struct _ManagerIface {
+ GTypeInterface parent_iface;
+ char* (*get_unit) (Manager* self, const gchar* name, GError** error);
+};
+
+struct _UnitIface {
+ GTypeInterface parent_iface;
+ gchar* (*get_name) (Unit* self);
+};
+
+VALA_EXTERN GType manager_proxy_get_type (void) G_GNUC_CONST ;
+VALA_EXTERN guint manager_register_object (void* object,
+ GDBusConnection* connection,
+ const gchar* path,
+ GError** error);
+VALA_EXTERN GType manager_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Manager, g_object_unref)
+VALA_EXTERN char* manager_get_unit (Manager* self,
+ const gchar* name,
+ GError** error);
+static GType manager_get_type_once (void);
+static void manager_proxy_g_signal (GDBusProxy* proxy,
+ const gchar* sender_name,
+ const gchar* signal_name,
+ GVariant* parameters);
+static char* manager_proxy_get_unit (Manager* self,
+ const gchar* name,
+ GError** error);
+static void manager_proxy_manager_interface_init (ManagerIface* iface);
+static void _dbus_manager_get_unit (Manager* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation);
+static void manager_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* manager_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 manager_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 _manager_unregister_object (gpointer user_data);
+VALA_EXTERN GType unit_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Unit, g_object_unref)
+VALA_EXTERN GType unit_proxy_get_type (void) G_GNUC_CONST ;
+VALA_EXTERN guint unit_register_object (void* object,
+ GDBusConnection* connection,
+ const gchar* path,
+ GError** error);
+VALA_EXTERN gchar* unit_get_name (Unit* self);
+static GType unit_get_type_once (void);
+static void unit_proxy_g_signal (GDBusProxy* proxy,
+ const gchar* sender_name,
+ const gchar* signal_name,
+ GVariant* parameters);
+static gchar* unit_dbus_proxy_get_name (Unit* self);
+static void unit_proxy_unit_interface_init (UnitIface* iface);
+static void unit_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* unit_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 GVariant* _dbus_unit_get_name (Unit* self);
+static gboolean unit_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 _unit_unregister_object (gpointer user_data);
+static void _vala_main (void);
+
+static const GDBusArgInfo _manager_dbus_arg_info_get_unit_name = {-1, "name", "s", NULL};
+static const GDBusArgInfo _manager_dbus_arg_info_get_unit_result = {-1, "result", "o", NULL};
+static const GDBusArgInfo * const _manager_dbus_arg_info_get_unit_in[] = {&_manager_dbus_arg_info_get_unit_name, NULL};
+static const GDBusArgInfo * const _manager_dbus_arg_info_get_unit_out[] = {&_manager_dbus_arg_info_get_unit_result, NULL};
+static const GDBusMethodInfo _manager_dbus_method_info_get_unit = {-1, "GetUnit", (GDBusArgInfo **) (&_manager_dbus_arg_info_get_unit_in), (GDBusArgInfo **) (&_manager_dbus_arg_info_get_unit_out), NULL};
+static const GDBusMethodInfo * const _manager_dbus_method_info[] = {&_manager_dbus_method_info_get_unit, NULL};
+static const GDBusSignalInfo * const _manager_dbus_signal_info[] = {NULL};
+static const GDBusPropertyInfo * const _manager_dbus_property_info[] = {NULL};
+static const GDBusInterfaceInfo _manager_dbus_interface_info = {-1, "org.example.Test.Manager", (GDBusMethodInfo **) (&_manager_dbus_method_info), (GDBusSignalInfo **) (&_manager_dbus_signal_info), (GDBusPropertyInfo **) (&_manager_dbus_property_info), NULL};
+static const GDBusInterfaceVTable _manager_dbus_interface_vtable = {manager_dbus_interface_method_call, manager_dbus_interface_get_property, manager_dbus_interface_set_property};
+static const GDBusMethodInfo * const _unit_dbus_method_info[] = {NULL};
+static const GDBusSignalInfo * const _unit_dbus_signal_info[] = {NULL};
+static const GDBusPropertyInfo _unit_dbus_property_info_name = {-1, "Name", "s", G_DBUS_PROPERTY_INFO_FLAGS_READABLE, NULL};
+static const GDBusPropertyInfo * const _unit_dbus_property_info[] = {&_unit_dbus_property_info_name, NULL};
+static const GDBusInterfaceInfo _unit_dbus_interface_info = {-1, "org.example.Test.Unit", (GDBusMethodInfo **) (&_unit_dbus_method_info), (GDBusSignalInfo **) (&_unit_dbus_signal_info), (GDBusPropertyInfo **) (&_unit_dbus_property_info), NULL};
+static const GDBusInterfaceVTable _unit_dbus_interface_vtable = {unit_dbus_interface_method_call, unit_dbus_interface_get_property, unit_dbus_interface_set_property};
+
+char*
+manager_get_unit (Manager* self,
+ const gchar* name,
+ GError** error)
+{
+ ManagerIface* _iface_;
+ g_return_val_if_fail (IS_MANAGER (self), NULL);
+ _iface_ = MANAGER_GET_INTERFACE (self);
+ if (_iface_->get_unit) {
+ return _iface_->get_unit (self, name, error);
+ }
+ return NULL;
+}
+
+static void
+manager_default_init (ManagerIface * iface,
+ gpointer iface_data)
+{
+}
+
+static GType
+manager_get_type_once (void)
+{
+ static const GTypeInfo g_define_type_info = { sizeof (ManagerIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) manager_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
+ GType manager_type_id;
+ manager_type_id = g_type_register_static (G_TYPE_INTERFACE, "Manager", &g_define_type_info, 0);
+ g_type_interface_add_prerequisite (manager_type_id, G_TYPE_OBJECT);
+ g_type_set_qdata (manager_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) manager_proxy_get_type);
+ g_type_set_qdata (manager_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.example.Test.Manager");
+ g_type_set_qdata (manager_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_manager_dbus_interface_info));
+ g_type_set_qdata (manager_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) manager_register_object);
+ return manager_type_id;
+}
+
+GType
+manager_get_type (void)
+{
+ static volatile gsize manager_type_id__once = 0;
+ if (g_once_init_enter (&manager_type_id__once)) {
+ GType manager_type_id;
+ manager_type_id = manager_get_type_once ();
+ g_once_init_leave (&manager_type_id__once, manager_type_id);
+ }
+ return manager_type_id__once;
+}
+
+G_DEFINE_TYPE_EXTENDED (ManagerProxy, manager_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (TYPE_MANAGER, manager_proxy_manager_interface_init) )
+static void
+manager_proxy_class_init (ManagerProxyClass* klass)
+{
+ G_DBUS_PROXY_CLASS (klass)->g_signal = manager_proxy_g_signal;
+}
+
+static void
+manager_proxy_g_signal (GDBusProxy* proxy,
+ const gchar* sender_name,
+ const gchar* signal_name,
+ GVariant* parameters)
+{
+}
+
+static void
+manager_proxy_init (ManagerProxy* self)
+{
+ g_dbus_proxy_set_interface_info (G_DBUS_PROXY (self), (GDBusInterfaceInfo *) (&_manager_dbus_interface_info));
+}
+
+static char*
+manager_proxy_get_unit (Manager* self,
+ const gchar* name,
+ GError** error)
+{
+ GVariant *_reply;
+ GVariantBuilder _arguments_builder;
+ GVariantIter _reply_iter;
+ char* _result = NULL;
+ GVariant* _tmp0_;
+ g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
+ g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
+ _reply = g_dbus_proxy_call_sync ((GDBusProxy *) self, "GetUnit", g_variant_builder_end (&_arguments_builder), G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
+ if (!_reply) {
+ return NULL;
+ }
+ g_variant_iter_init (&_reply_iter, _reply);
+ _tmp0_ = g_variant_iter_next_value (&_reply_iter);
+ _result = g_variant_dup_string (_tmp0_, NULL);
+ g_variant_unref (_tmp0_);
+ g_variant_unref (_reply);
+ return _result;
+}
+
+static void
+manager_proxy_manager_interface_init (ManagerIface* iface)
+{
+ iface->get_unit = manager_proxy_get_unit;
+}
+
+static void
+_dbus_manager_get_unit (Manager* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation)
+{
+ GError* error = NULL;
+ GVariantIter _arguments_iter;
+ gchar* name = NULL;
+ GVariant* _tmp1_;
+ GDBusMessage* _reply_message = NULL;
+ GVariant* _reply;
+ GVariantBuilder _reply_builder;
+ char* result;
+ g_variant_iter_init (&_arguments_iter, _parameters_);
+ _tmp1_ = g_variant_iter_next_value (&_arguments_iter);
+ name = g_variant_dup_string (_tmp1_, NULL);
+ g_variant_unref (_tmp1_);
+ result = manager_get_unit (self, name, &error);
+ if (error) {
+ g_dbus_method_invocation_take_error (invocation, error);
+ goto _error;
+ }
+ _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);
+ _error:
+ _g_free0 (name);
+ ;
+}
+
+static void
+manager_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, "GetUnit") == 0) {
+ _dbus_manager_get_unit (object, parameters, invocation);
+ } else {
+ g_object_unref (invocation);
+ }
+}
+
+static GVariant*
+manager_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)
+{
+ return NULL;
+}
+
+static gboolean
+manager_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)
+{
+ return FALSE;
+}
+
+guint
+manager_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 *) (&_manager_dbus_interface_info), &_manager_dbus_interface_vtable, data, _manager_unregister_object, error);
+ if (!result) {
+ return 0;
+ }
+ return result;
+}
+
+static void
+_manager_unregister_object (gpointer user_data)
+{
+ gpointer* data;
+ data = user_data;
+ g_object_unref (data[0]);
+ g_object_unref (data[1]);
+ g_free (data[2]);
+ g_free (data);
+}
+
+gchar*
+unit_get_name (Unit* self)
+{
+ UnitIface* _iface_;
+ g_return_val_if_fail (IS_UNIT (self), NULL);
+ _iface_ = UNIT_GET_INTERFACE (self);
+ if (_iface_->get_name) {
+ return _iface_->get_name (self);
+ }
+ return NULL;
+}
+
+static void
+unit_default_init (UnitIface * iface,
+ gpointer iface_data)
+{
+}
+
+static GType
+unit_get_type_once (void)
+{
+ static const GTypeInfo g_define_type_info = { sizeof (UnitIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) unit_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
+ GType unit_type_id;
+ unit_type_id = g_type_register_static (G_TYPE_INTERFACE, "Unit", &g_define_type_info, 0);
+ g_type_interface_add_prerequisite (unit_type_id, G_TYPE_OBJECT);
+ g_type_set_qdata (unit_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) unit_proxy_get_type);
+ g_type_set_qdata (unit_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.example.Test.Unit");
+ g_type_set_qdata (unit_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_unit_dbus_interface_info));
+ g_type_set_qdata (unit_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) unit_register_object);
+ return unit_type_id;
+}
+
+GType
+unit_get_type (void)
+{
+ static volatile gsize unit_type_id__once = 0;
+ if (g_once_init_enter (&unit_type_id__once)) {
+ GType unit_type_id;
+ unit_type_id = unit_get_type_once ();
+ g_once_init_leave (&unit_type_id__once, unit_type_id);
+ }
+ return unit_type_id__once;
+}
+
+G_DEFINE_TYPE_EXTENDED (UnitProxy, unit_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (TYPE_UNIT, unit_proxy_unit_interface_init) )
+static void
+unit_proxy_class_init (UnitProxyClass* klass)
+{
+ G_DBUS_PROXY_CLASS (klass)->g_signal = unit_proxy_g_signal;
+}
+
+static void
+unit_proxy_g_signal (GDBusProxy* proxy,
+ const gchar* sender_name,
+ const gchar* signal_name,
+ GVariant* parameters)
+{
+}
+
+static void
+unit_proxy_init (UnitProxy* self)
+{
+ g_dbus_proxy_set_interface_info (G_DBUS_PROXY (self), (GDBusInterfaceInfo *) (&_unit_dbus_interface_info));
+}
+
+static gchar*
+unit_dbus_proxy_get_name (Unit* self)
+{
+ GVariant *_inner_reply;
+ gchar* _result;
+ _inner_reply = g_dbus_proxy_get_cached_property ((GDBusProxy *) self, "Name");
+ if (!_inner_reply) {
+ GVariant *_arguments;
+ GVariant *_reply;
+ GVariantBuilder _arguments_builder;
+ g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
+ g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("org.example.Test.Unit"));
+ g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("Name"));
+ _arguments = g_variant_builder_end (&_arguments_builder);
+ _reply = g_dbus_proxy_call_sync ((GDBusProxy *) self, "org.freedesktop.DBus.Properties.Get", _arguments, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
+ if (!_reply) {
+ return NULL;
+ }
+ if (G_UNLIKELY (!g_variant_is_of_type (_reply, G_VARIANT_TYPE ("(v)")))) {
+ g_variant_unref (_reply);
+ return NULL;
+ }
+ g_variant_get (_reply, "(v)", &_inner_reply);
+ g_variant_unref (_reply);
+ }
+ if (G_UNLIKELY (!g_variant_is_of_type (_inner_reply, G_VARIANT_TYPE ("s")))) {
+ g_warning ("Expected property %s.%s to be of type '%s', but received '%s'", "org.example.Test.Unit", "Name", "s", g_variant_get_type_string (_inner_reply));
+ g_variant_unref (_inner_reply);
+ return NULL;
+ }
+ _result = g_variant_dup_string (_inner_reply, NULL);
+ g_variant_unref (_inner_reply);
+ return _result;
+}
+
+static void
+unit_proxy_unit_interface_init (UnitIface* iface)
+{
+ iface->get_name = unit_dbus_proxy_get_name;
+}
+
+static void
+unit_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)
+{
+ g_object_unref (invocation);
+}
+
+static GVariant*
+_dbus_unit_get_name (Unit* self)
+{
+ gchar* result;
+ GVariant* _reply;
+ result = unit_get_name (self);
+ _reply = g_variant_new_string (result);
+ _g_free0 (result);
+ return _reply;
+}
+
+static GVariant*
+unit_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];
+ if (strcmp (property_name, "Name") == 0) {
+ return _dbus_unit_get_name (object);
+ }
+ return NULL;
+}
+
+static gboolean
+unit_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)
+{
+ return FALSE;
+}
+
+guint
+unit_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 *) (&_unit_dbus_interface_info), &_unit_dbus_interface_vtable, data, _unit_unregister_object, error);
+ if (!result) {
+ return 0;
+ }
+ return result;
+}
+
+static void
+_unit_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
+_vala_main (void)
+{
+ Manager* manager = NULL;
+ Manager* _tmp0_;
+ char* unit_path = NULL;
+ Manager* _tmp1_;
+ char* _tmp2_;
+ const char* _tmp3_;
+ GDBusProxy* manager_proxy = NULL;
+ Manager* _tmp4_;
+ Unit* unit = NULL;
+ GDBusProxy* _tmp5_;
+ GDBusConnection* _tmp6_;
+ GDBusProxy* _tmp7_;
+ gchar* _tmp8_;
+ gchar* _tmp9_;
+ const char* _tmp10_;
+ Unit* _tmp11_;
+ Unit* _tmp12_;
+ Unit* _tmp13_;
+ gchar* _tmp14_;
+ gchar* _tmp15_;
+ gchar* _tmp16_;
+ GError* _inner_error0_ = NULL;
+ _tmp0_ = (Manager*) g_initable_new (TYPE_MANAGER_PROXY, NULL, &_inner_error0_, "g-flags", 0, "g-name", "org.example.Test", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/example/test/Manager", "g-interface-name", "org.example.Test.Manager", NULL);
+ manager = (Manager*) _tmp0_;
+ if (G_UNLIKELY (_inner_error0_ != NULL)) {
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+ g_clear_error (&_inner_error0_);
+ return;
+ }
+ _tmp1_ = manager;
+ _tmp2_ = manager_get_unit (_tmp1_, "example.service", &_inner_error0_);
+ unit_path = _tmp2_;
+ if (G_UNLIKELY (_inner_error0_ != NULL)) {
+ _g_object_unref0 (manager);
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+ g_clear_error (&_inner_error0_);
+ return;
+ }
+ _tmp3_ = unit_path;
+ _vala_assert (g_strcmp0 (_tmp3_, "/org/example/test/Manager/0") == 0, "unit_path == \"/org/example/test/Manager/0\"");
+ _tmp4_ = manager;
+ manager_proxy = G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, g_dbus_proxy_get_type (), GDBusProxy);
+ _tmp5_ = manager_proxy;
+ _tmp6_ = g_dbus_proxy_get_connection (_tmp5_);
+ _tmp7_ = manager_proxy;
+ _tmp8_ = g_dbus_proxy_get_name_owner (_tmp7_);
+ _tmp9_ = _tmp8_;
+ _tmp10_ = unit_path;
+ _tmp11_ = (Unit*) g_initable_new (TYPE_UNIT_PROXY, NULL, &_inner_error0_, "g-flags", 0, "g-name", _tmp9_, "g-connection", _tmp6_, "g-object-path", (const gchar*) _tmp10_, "g-interface-name", "org.example.Test.Unit", NULL);
+ _tmp12_ = (Unit*) _tmp11_;
+ _g_free0 (_tmp9_);
+ unit = _tmp12_;
+ if (G_UNLIKELY (_inner_error0_ != NULL)) {
+ _g_free0 (unit_path);
+ _g_object_unref0 (manager);
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+ g_clear_error (&_inner_error0_);
+ return;
+ }
+ _tmp13_ = unit;
+ _tmp14_ = unit_get_name (_tmp13_);
+ _tmp15_ = _tmp14_;
+ _tmp16_ = _tmp15_;
+ _vala_assert (g_strcmp0 (_tmp16_, "example.service") == 0, "unit.name == \"example.service\"");
+ _g_free0 (_tmp16_);
+ _g_object_unref0 (unit);
+ _g_free0 (unit_path);
+ _g_object_unref0 (manager);
+}
+
+int
+main (int argc,
+ char ** argv)
+{
+ _vala_main ();
+ return 0;
+}
+
--- /dev/null
+/* dbus_special_parameters_2_server.c generated by valac, the Vala compiler
+ * generated from dbus_special_parameters_2_server.vala, do not modify */
+
+#include <glib-object.h>
+#include <gio/gio.h>
+#include <glib.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if !defined(VALA_STRICT_C)
+#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
+#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
+#elif defined(__clang__) && (__clang_major__ >= 16)
+#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
+#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
+#endif
+#endif
+#if !defined(VALA_EXTERN)
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define VALA_EXTERN __declspec(dllexport) extern
+#elif __GNUC__ >= 4
+#define VALA_EXTERN __attribute__((visibility("default"))) extern
+#else
+#define VALA_EXTERN extern
+#endif
+#endif
+
+#define TYPE_MANAGER (manager_get_type ())
+#define MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MANAGER, Manager))
+#define MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MANAGER, ManagerClass))
+#define IS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MANAGER))
+#define IS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MANAGER))
+#define MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MANAGER, ManagerClass))
+
+typedef struct _Manager Manager;
+typedef struct _ManagerClass ManagerClass;
+typedef struct _ManagerPrivate ManagerPrivate;
+enum {
+ MANAGER_0_PROPERTY,
+ MANAGER_NUM_PROPERTIES
+};
+static GParamSpec* manager_properties[MANAGER_NUM_PROPERTIES];
+#define _g_free0(var) (var = (g_free (var), NULL))
+
+#define TYPE_UNIT (unit_get_type ())
+#define UNIT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_UNIT, Unit))
+#define UNIT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_UNIT, UnitClass))
+#define IS_UNIT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_UNIT))
+#define IS_UNIT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_UNIT))
+#define UNIT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_UNIT, UnitClass))
+
+typedef struct _Unit Unit;
+typedef struct _UnitClass UnitClass;
+#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
+typedef struct _UnitPrivate UnitPrivate;
+enum {
+ UNIT_0_PROPERTY,
+ UNIT_NAME_PROPERTY,
+ UNIT_NUM_PROPERTIES
+};
+static GParamSpec* unit_properties[UNIT_NUM_PROPERTIES];
+#define _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))
+#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
+#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
+#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
+#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+
+struct _Manager {
+ GObject parent_instance;
+ ManagerPrivate * priv;
+};
+
+struct _ManagerClass {
+ GObjectClass parent_class;
+};
+
+struct _ManagerPrivate {
+ guint next_unit_id;
+};
+
+struct _Unit {
+ GObject parent_instance;
+ UnitPrivate * priv;
+};
+
+struct _UnitClass {
+ GObjectClass parent_class;
+};
+
+struct _UnitPrivate {
+ gchar* _name;
+};
+
+static gint Manager_private_offset;
+static gpointer manager_parent_class = NULL;
+static gint Unit_private_offset;
+static gpointer unit_parent_class = NULL;
+VALA_EXTERN GMainLoop* main_loop;
+GMainLoop* main_loop = NULL;
+
+VALA_EXTERN GType manager_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Manager, g_object_unref)
+VALA_EXTERN guint manager_register_object (void* object,
+ GDBusConnection* connection,
+ const gchar* path,
+ GError** error);
+VALA_EXTERN char* manager_get_unit (Manager* self,
+ const gchar* name,
+ GDBusConnection* connection,
+ GDBusMethodInvocation* invocation);
+VALA_EXTERN GType unit_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Unit, g_object_unref)
+VALA_EXTERN guint unit_register_object (void* object,
+ GDBusConnection* connection,
+ const gchar* path,
+ GError** error);
+VALA_EXTERN Unit* unit_new (void);
+VALA_EXTERN Unit* unit_construct (GType object_type);
+VALA_EXTERN void unit_set_name (Unit* self,
+ const gchar* value);
+VALA_EXTERN Manager* manager_new (void);
+VALA_EXTERN Manager* manager_construct (GType object_type);
+static void manager_finalize (GObject * obj);
+static GType manager_get_type_once (void);
+static void _dbus_manager_get_unit (Manager* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation);
+static void manager_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* manager_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 manager_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 _manager_unregister_object (gpointer user_data);
+VALA_EXTERN const gchar* unit_get_name (Unit* self);
+static void unit_finalize (GObject * obj);
+static GType unit_get_type_once (void);
+static void _vala_unit_get_property (GObject * object,
+ guint property_id,
+ GValue * value,
+ GParamSpec * pspec);
+static void _vala_unit_set_property (GObject * object,
+ guint property_id,
+ const GValue * value,
+ GParamSpec * pspec);
+static void unit_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* unit_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 GVariant* _dbus_unit_get_name (Unit* self);
+static gboolean unit_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_unit_set_name (Unit* self,
+ GVariant* _value);
+static void _unit_unregister_object (gpointer user_data);
+VALA_EXTERN void client_exit (GPid pid,
+ gint status);
+static void _vala_main (void);
+static guint _variant_get1 (GVariant* value);
+static void _client_exit_gchild_watch_func (GPid pid,
+ gint wait_status,
+ gpointer self);
+static void _vala_array_destroy (gpointer array,
+ gssize array_length,
+ GDestroyNotify destroy_func);
+static void _vala_array_free (gpointer array,
+ gssize array_length,
+ GDestroyNotify destroy_func);
+
+static const GDBusArgInfo _manager_dbus_arg_info_get_unit_name = {-1, "name", "s", NULL};
+static const GDBusArgInfo _manager_dbus_arg_info_get_unit_result = {-1, "result", "o", NULL};
+static const GDBusArgInfo * const _manager_dbus_arg_info_get_unit_in[] = {&_manager_dbus_arg_info_get_unit_name, NULL};
+static const GDBusArgInfo * const _manager_dbus_arg_info_get_unit_out[] = {&_manager_dbus_arg_info_get_unit_result, NULL};
+static const GDBusMethodInfo _manager_dbus_method_info_get_unit = {-1, "GetUnit", (GDBusArgInfo **) (&_manager_dbus_arg_info_get_unit_in), (GDBusArgInfo **) (&_manager_dbus_arg_info_get_unit_out), NULL};
+static const GDBusMethodInfo * const _manager_dbus_method_info[] = {&_manager_dbus_method_info_get_unit, NULL};
+static const GDBusSignalInfo * const _manager_dbus_signal_info[] = {NULL};
+static const GDBusPropertyInfo * const _manager_dbus_property_info[] = {NULL};
+static const GDBusInterfaceInfo _manager_dbus_interface_info = {-1, "org.example.Test.Manager", (GDBusMethodInfo **) (&_manager_dbus_method_info), (GDBusSignalInfo **) (&_manager_dbus_signal_info), (GDBusPropertyInfo **) (&_manager_dbus_property_info), NULL};
+static const GDBusInterfaceVTable _manager_dbus_interface_vtable = {manager_dbus_interface_method_call, manager_dbus_interface_get_property, manager_dbus_interface_set_property};
+static const GDBusMethodInfo * const _unit_dbus_method_info[] = {NULL};
+static const GDBusSignalInfo * const _unit_dbus_signal_info[] = {NULL};
+static const GDBusPropertyInfo _unit_dbus_property_info_name = {-1, "Name", "s", G_DBUS_PROPERTY_INFO_FLAGS_READABLE | G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE, NULL};
+static const GDBusPropertyInfo * const _unit_dbus_property_info[] = {&_unit_dbus_property_info_name, NULL};
+static const GDBusInterfaceInfo _unit_dbus_interface_info = {-1, "org.example.Test.Unit", (GDBusMethodInfo **) (&_unit_dbus_method_info), (GDBusSignalInfo **) (&_unit_dbus_signal_info), (GDBusPropertyInfo **) (&_unit_dbus_property_info), NULL};
+static const GDBusInterfaceVTable _unit_dbus_interface_vtable = {unit_dbus_interface_method_call, unit_dbus_interface_get_property, unit_dbus_interface_set_property};
+
+static inline gpointer
+manager_get_instance_private (Manager* self)
+{
+ return G_STRUCT_MEMBER_P (self, Manager_private_offset);
+}
+
+static const gchar*
+string_to_string (const gchar* self)
+{
+ const gchar* result;
+ g_return_val_if_fail (self != NULL, NULL);
+ result = self;
+ return result;
+}
+
+char*
+manager_get_unit (Manager* self,
+ const gchar* name,
+ GDBusConnection* connection,
+ GDBusMethodInvocation* invocation)
+{
+ const gchar* my_object_path = NULL;
+ const gchar* _tmp0_;
+ guint unit_id = 0U;
+ guint _tmp1_;
+ gchar* unit_object_path = NULL;
+ const gchar* _tmp2_;
+ gchar* _tmp3_;
+ gchar* _tmp4_;
+ gchar* _tmp5_;
+ gchar* _tmp6_;
+ Unit* unit = NULL;
+ gchar* _tmp7_;
+ Unit* _tmp8_ = NULL;
+ char* _tmp9_;
+ GError* _inner_error0_ = NULL;
+ char* result;
+ g_return_val_if_fail (IS_MANAGER (self), NULL);
+ g_return_val_if_fail (name != NULL, NULL);
+ g_return_val_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (connection, g_dbus_connection_get_type ()), NULL);
+ g_return_val_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (invocation, g_dbus_method_invocation_get_type ()), NULL);
+ _tmp0_ = g_dbus_method_invocation_get_object_path (invocation);
+ my_object_path = _tmp0_;
+ _tmp1_ = self->priv->next_unit_id;
+ self->priv->next_unit_id = _tmp1_ + 1;
+ unit_id = _tmp1_;
+ _tmp2_ = string_to_string (my_object_path);
+ _tmp3_ = g_strdup_printf ("%u", unit_id);
+ _tmp4_ = _tmp3_;
+ _tmp5_ = g_strconcat (_tmp2_, "/", _tmp4_, NULL);
+ _tmp6_ = _tmp5_;
+ _g_free0 (_tmp4_);
+ unit_object_path = _tmp6_;
+ _tmp7_ = g_strdup (name);
+ _tmp8_ = unit_new ();
+ unit_set_name (_tmp8_, _tmp7_);
+ _g_free0 (_tmp7_);
+ unit = _tmp8_;
+ unit_register_object (unit, connection, unit_object_path, &_inner_error0_);
+ if (G_UNLIKELY (_inner_error0_ != NULL)) {
+ _g_object_unref0 (unit);
+ _g_free0 (unit_object_path);
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+ g_clear_error (&_inner_error0_);
+ return NULL;
+ }
+ _tmp9_ = g_strdup (unit_object_path);
+ result = _tmp9_;
+ _g_object_unref0 (unit);
+ _g_free0 (unit_object_path);
+ return result;
+}
+
+Manager*
+manager_construct (GType object_type)
+{
+ Manager * self = NULL;
+ self = (Manager*) g_object_new (object_type, NULL);
+ return self;
+}
+
+Manager*
+manager_new (void)
+{
+ return manager_construct (TYPE_MANAGER);
+}
+
+static void
+manager_class_init (ManagerClass * klass,
+ gpointer klass_data)
+{
+ manager_parent_class = g_type_class_peek_parent (klass);
+ g_type_class_adjust_private_offset (klass, &Manager_private_offset);
+ G_OBJECT_CLASS (klass)->finalize = manager_finalize;
+}
+
+static void
+manager_instance_init (Manager * self,
+ gpointer klass)
+{
+ self->priv = manager_get_instance_private (self);
+ self->priv->next_unit_id = (guint) 0;
+}
+
+static void
+manager_finalize (GObject * obj)
+{
+ Manager * self;
+ self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_MANAGER, Manager);
+ G_OBJECT_CLASS (manager_parent_class)->finalize (obj);
+}
+
+static GType
+manager_get_type_once (void)
+{
+ static const GTypeInfo g_define_type_info = { sizeof (ManagerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) manager_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Manager), 0, (GInstanceInitFunc) manager_instance_init, NULL };
+ GType manager_type_id;
+ manager_type_id = g_type_register_static (G_TYPE_OBJECT, "Manager", &g_define_type_info, 0);
+ g_type_set_qdata (manager_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) manager_register_object);
+ Manager_private_offset = g_type_add_instance_private (manager_type_id, sizeof (ManagerPrivate));
+ return manager_type_id;
+}
+
+GType
+manager_get_type (void)
+{
+ static volatile gsize manager_type_id__once = 0;
+ if (g_once_init_enter (&manager_type_id__once)) {
+ GType manager_type_id;
+ manager_type_id = manager_get_type_once ();
+ g_once_init_leave (&manager_type_id__once, manager_type_id);
+ }
+ return manager_type_id__once;
+}
+
+static void
+_dbus_manager_get_unit (Manager* self,
+ GVariant* _parameters_,
+ GDBusMethodInvocation* invocation)
+{
+ GError* error = NULL;
+ GVariantIter _arguments_iter;
+ gchar* name = NULL;
+ GVariant* _tmp0_;
+ GDBusMessage* _reply_message = NULL;
+ GVariant* _reply;
+ GVariantBuilder _reply_builder;
+ char* result;
+ g_variant_iter_init (&_arguments_iter, _parameters_);
+ _tmp0_ = g_variant_iter_next_value (&_arguments_iter);
+ name = g_variant_dup_string (_tmp0_, NULL);
+ g_variant_unref (_tmp0_);
+ result = manager_get_unit (self, name, g_dbus_method_invocation_get_connection (invocation), 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);
+ 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);
+ _g_free0 (name);
+}
+
+static void
+manager_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, "GetUnit") == 0) {
+ _dbus_manager_get_unit (object, parameters, invocation);
+ } else {
+ g_object_unref (invocation);
+ }
+}
+
+static GVariant*
+manager_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)
+{
+ return NULL;
+}
+
+static gboolean
+manager_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)
+{
+ return FALSE;
+}
+
+guint
+manager_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 *) (&_manager_dbus_interface_info), &_manager_dbus_interface_vtable, data, _manager_unregister_object, error);
+ if (!result) {
+ return 0;
+ }
+ return result;
+}
+
+static void
+_manager_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 inline gpointer
+unit_get_instance_private (Unit* self)
+{
+ return G_STRUCT_MEMBER_P (self, Unit_private_offset);
+}
+
+Unit*
+unit_construct (GType object_type)
+{
+ Unit * self = NULL;
+ self = (Unit*) g_object_new (object_type, NULL);
+ return self;
+}
+
+Unit*
+unit_new (void)
+{
+ return unit_construct (TYPE_UNIT);
+}
+
+const gchar*
+unit_get_name (Unit* self)
+{
+ const gchar* result;
+ const gchar* _tmp0_;
+ g_return_val_if_fail (IS_UNIT (self), NULL);
+ _tmp0_ = self->priv->_name;
+ result = _tmp0_;
+ return result;
+}
+
+void
+unit_set_name (Unit* self,
+ const gchar* value)
+{
+ gchar* old_value;
+ g_return_if_fail (IS_UNIT (self));
+ old_value = unit_get_name (self);
+ if (g_strcmp0 (value, old_value) != 0) {
+ gchar* _tmp0_;
+ _tmp0_ = g_strdup (value);
+ _g_free0 (self->priv->_name);
+ self->priv->_name = _tmp0_;
+ g_object_notify_by_pspec ((GObject *) self, unit_properties[UNIT_NAME_PROPERTY]);
+ }
+}
+
+static void
+unit_class_init (UnitClass * klass,
+ gpointer klass_data)
+{
+ unit_parent_class = g_type_class_peek_parent (klass);
+ g_type_class_adjust_private_offset (klass, &Unit_private_offset);
+ G_OBJECT_CLASS (klass)->get_property = _vala_unit_get_property;
+ G_OBJECT_CLASS (klass)->set_property = _vala_unit_set_property;
+ G_OBJECT_CLASS (klass)->finalize = unit_finalize;
+ g_object_class_install_property (G_OBJECT_CLASS (klass), UNIT_NAME_PROPERTY, unit_properties[UNIT_NAME_PROPERTY] = g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
+}
+
+static void
+unit_instance_init (Unit * self,
+ gpointer klass)
+{
+ self->priv = unit_get_instance_private (self);
+}
+
+static void
+unit_finalize (GObject * obj)
+{
+ Unit * self;
+ self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_UNIT, Unit);
+ _g_free0 (self->priv->_name);
+ G_OBJECT_CLASS (unit_parent_class)->finalize (obj);
+}
+
+static GType
+unit_get_type_once (void)
+{
+ static const GTypeInfo g_define_type_info = { sizeof (UnitClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) unit_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Unit), 0, (GInstanceInitFunc) unit_instance_init, NULL };
+ GType unit_type_id;
+ unit_type_id = g_type_register_static (G_TYPE_OBJECT, "Unit", &g_define_type_info, 0);
+ g_type_set_qdata (unit_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) unit_register_object);
+ Unit_private_offset = g_type_add_instance_private (unit_type_id, sizeof (UnitPrivate));
+ return unit_type_id;
+}
+
+GType
+unit_get_type (void)
+{
+ static volatile gsize unit_type_id__once = 0;
+ if (g_once_init_enter (&unit_type_id__once)) {
+ GType unit_type_id;
+ unit_type_id = unit_get_type_once ();
+ g_once_init_leave (&unit_type_id__once, unit_type_id);
+ }
+ return unit_type_id__once;
+}
+
+static void
+_vala_unit_get_property (GObject * object,
+ guint property_id,
+ GValue * value,
+ GParamSpec * pspec)
+{
+ Unit * self;
+ self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_UNIT, Unit);
+ switch (property_id) {
+ case UNIT_NAME_PROPERTY:
+ g_value_set_string (value, unit_get_name (self));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+_vala_unit_set_property (GObject * object,
+ guint property_id,
+ const GValue * value,
+ GParamSpec * pspec)
+{
+ Unit * self;
+ self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_UNIT, Unit);
+ switch (property_id) {
+ case UNIT_NAME_PROPERTY:
+ unit_set_name (self, g_value_get_string (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+unit_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)
+{
+ g_object_unref (invocation);
+}
+
+static GVariant*
+_dbus_unit_get_name (Unit* self)
+{
+ const gchar* result;
+ GVariant* _reply;
+ result = unit_get_name (self);
+ _reply = g_variant_new_string (result);
+ return _reply;
+}
+
+static GVariant*
+unit_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];
+ if (strcmp (property_name, "Name") == 0) {
+ return _dbus_unit_get_name (object);
+ }
+ return NULL;
+}
+
+static void
+_dbus_unit_set_name (Unit* self,
+ GVariant* _value)
+{
+ gchar* value = NULL;
+ value = g_variant_dup_string (_value, NULL);
+ unit_set_name (self, value);
+ _g_free0 (value);
+}
+
+static gboolean
+unit_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];
+ if (strcmp (property_name, "Name") == 0) {
+ _dbus_unit_set_name (object, value);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+guint
+unit_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 *) (&_unit_dbus_interface_info), &_unit_dbus_interface_vtable, data, _unit_unregister_object, error);
+ if (!result) {
+ return 0;
+ }
+ return result;
+}
+
+static void
+_unit_unregister_object (gpointer user_data)
+{
+ gpointer* data;
+ data = user_data;
+ g_object_unref (data[0]);
+ g_object_unref (data[1]);
+ g_free (data[2]);
+ g_free (data);
+}
+
+void
+client_exit (GPid pid,
+ gint status)
+{
+ GMainLoop* _tmp0_;
+ _vala_assert (status == 0, "status == 0");
+ _tmp0_ = main_loop;
+ g_main_loop_quit (_tmp0_);
+}
+
+static guint
+_variant_get1 (GVariant* value)
+{
+ return g_variant_get_uint32 (value);
+}
+
+static void
+_client_exit_gchild_watch_func (GPid pid,
+ gint wait_status,
+ gpointer self)
+{
+ client_exit (pid, wait_status);
+}
+
+static void
+_vala_main (void)
+{
+ GDBusConnection* conn = NULL;
+ GDBusConnection* _tmp0_;
+ GDBusConnection* _tmp1_;
+ Manager* _tmp2_;
+ Manager* _tmp3_;
+ GVariant* request_result = NULL;
+ GDBusConnection* _tmp4_;
+ GVariant* _tmp5_;
+ GVariant* _tmp6_;
+ GVariant* _tmp7_;
+ GVariant* _tmp8_;
+ GVariant* _tmp9_;
+ GVariant* _tmp10_;
+ GVariant* _tmp11_;
+ guint _tmp12_;
+ GPid client_pid = 0;
+ gchar* _tmp13_;
+ gchar** _tmp14_;
+ gchar** _tmp15_;
+ gint _tmp15__length1;
+ GPid _tmp16_ = 0;
+ GMainLoop* _tmp17_;
+ GMainLoop* _tmp18_;
+ GError* _inner_error0_ = NULL;
+ _tmp0_ = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &_inner_error0_);
+ conn = _tmp0_;
+ if (G_UNLIKELY (_inner_error0_ != NULL)) {
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+ g_clear_error (&_inner_error0_);
+ return;
+ }
+ _tmp1_ = conn;
+ _tmp2_ = manager_new ();
+ _tmp3_ = _tmp2_;
+ manager_register_object (_tmp3_, _tmp1_, "/org/example/test/Manager", &_inner_error0_);
+ _g_object_unref0 (_tmp3_);
+ if (G_UNLIKELY (_inner_error0_ != NULL)) {
+ _g_object_unref0 (conn);
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+ g_clear_error (&_inner_error0_);
+ return;
+ }
+ _tmp4_ = conn;
+ _tmp5_ = g_variant_new ("(su)", "org.example.Test", 0x4, NULL);
+ g_variant_ref_sink (_tmp5_);
+ _tmp6_ = _tmp5_;
+ _tmp7_ = g_dbus_connection_call_sync (_tmp4_, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "RequestName", _tmp6_, NULL, 0, -1, NULL, &_inner_error0_);
+ _tmp8_ = _tmp7_;
+ _g_variant_unref0 (_tmp6_);
+ request_result = _tmp8_;
+ if (G_UNLIKELY (_inner_error0_ != NULL)) {
+ _g_object_unref0 (conn);
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+ g_clear_error (&_inner_error0_);
+ return;
+ }
+ _tmp9_ = request_result;
+ _tmp10_ = g_variant_get_child_value (_tmp9_, (gsize) 0);
+ _tmp11_ = _tmp10_;
+ _tmp12_ = _variant_get1 (_tmp11_);
+ _vala_assert (_tmp12_ == ((guint) 1), "(uint) request_result.get_child_value (0) == 1");
+ _g_variant_unref0 (_tmp11_);
+ _tmp13_ = g_strdup ("dbus_special_parameters_2_client");
+ _tmp14_ = g_new0 (gchar*, 1 + 1);
+ _tmp14_[0] = _tmp13_;
+ _tmp15_ = _tmp14_;
+ _tmp15__length1 = 1;
+ g_spawn_async (NULL, _tmp15_, NULL, G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL, &_tmp16_, &_inner_error0_);
+ client_pid = _tmp16_;
+ _tmp15_ = (_vala_array_free (_tmp15_, _tmp15__length1, (GDestroyNotify) g_free), NULL);
+ if (G_UNLIKELY (_inner_error0_ != NULL)) {
+ _g_variant_unref0 (request_result);
+ _g_object_unref0 (conn);
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+ g_clear_error (&_inner_error0_);
+ return;
+ }
+ g_child_watch_add_full (G_PRIORITY_DEFAULT_IDLE, client_pid, _client_exit_gchild_watch_func, NULL, NULL);
+ _tmp17_ = g_main_loop_new (NULL, FALSE);
+ _g_main_loop_unref0 (main_loop);
+ main_loop = _tmp17_;
+ _tmp18_ = main_loop;
+ g_main_loop_run (_tmp18_);
+ _g_variant_unref0 (request_result);
+ _g_object_unref0 (conn);
+}
+
+int
+main (int argc,
+ char ** argv)
+{
+ _vala_main ();
+ return 0;
+}
+
+static void
+_vala_array_destroy (gpointer array,
+ gssize array_length,
+ GDestroyNotify destroy_func)
+{
+ if ((array != NULL) && (destroy_func != NULL)) {
+ gssize 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,
+ gssize array_length,
+ GDestroyNotify destroy_func)
+{
+ _vala_array_destroy (array, array_length, destroy_func);
+ g_free (array);
+}
+
projects / thirdparty / vala.git / commitdiff
