/** * json_gvariant_serialize: * @variant: A #GVariant to convert * * Converts @variant to a JSON tree. * * Return value: (transfer full): A #JsonNode representing the root of the * JSON data structure obtained from @variant * * Since: 0.14 */ JsonNode * json_gvariant_serialize (GVariant *variant) { JsonNode *json_node = NULL; GVariantClass class; g_return_val_if_fail (variant != NULL, NULL); class = g_variant_classify (variant); if (! g_variant_is_container (variant)) { json_node = json_node_new (JSON_NODE_VALUE); switch (class) { case G_VARIANT_CLASS_BOOLEAN: json_node_set_boolean (json_node, g_variant_get_boolean (variant)); break; case G_VARIANT_CLASS_BYTE: json_node_set_int (json_node, g_variant_get_byte (variant)); break; case G_VARIANT_CLASS_INT16: json_node_set_int (json_node, g_variant_get_int16 (variant)); break; case G_VARIANT_CLASS_UINT16: json_node_set_int (json_node, g_variant_get_uint16 (variant)); break; case G_VARIANT_CLASS_INT32: json_node_set_int (json_node, g_variant_get_int32 (variant)); break; case G_VARIANT_CLASS_UINT32: json_node_set_int (json_node, g_variant_get_uint32 (variant)); break; case G_VARIANT_CLASS_INT64: json_node_set_int (json_node, g_variant_get_int64 (variant)); break; case G_VARIANT_CLASS_UINT64: json_node_set_int (json_node, g_variant_get_uint64 (variant)); break; case G_VARIANT_CLASS_HANDLE: json_node_set_int (json_node, g_variant_get_handle (variant)); break; case G_VARIANT_CLASS_DOUBLE: json_node_set_double (json_node, g_variant_get_double (variant)); break; case G_VARIANT_CLASS_STRING: case G_VARIANT_CLASS_OBJECT_PATH: case G_VARIANT_CLASS_SIGNATURE: json_node_set_string (json_node, g_variant_get_string (variant, NULL)); break; default: break; } }
static void get_properties_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { CMService *cm_service; GVariant *ret; GVariant *dict; GVariant *value; GVariantIter iter; gchar *key; GError *error = NULL; ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (error != NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("Error fetching properties: %s", error->message); g_error_free (error); return; } if (ret == NULL) { g_warning ("Failed fetching properties but no error"); return; } if (g_variant_is_container (ret) != TRUE) { g_warning ("Unexpected result type: %s", g_variant_get_type_string (ret)); g_variant_unref (ret); return; } cm_service = user_data; dict = g_variant_get_child_value (ret, 0); g_variant_iter_init (&iter, dict); while (g_variant_iter_loop (&iter, "{sv}", &key, &value)) on_service_property_changed (cm_service, key, value); g_variant_unref (dict); g_variant_unref (ret); }
static void get_services_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GUPnPConnmanManager *manager; GVariant *ret; GVariant *services_array; GError *error = NULL; ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (error != NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("Error fetching service list: %s", error->message); g_error_free (error); return; } if (ret == NULL) { g_warning ("Failed fetching list of services but no error"); return; } if (g_variant_is_container (ret) != TRUE) { g_warning ("Wrong format result"); g_variant_unref (ret); return; } manager = GUPNP_CONNMAN_MANAGER (user_data); services_array = g_variant_get_child_value (ret, 0); services_array_add (manager, services_array); g_variant_unref (services_array); g_variant_unref (ret); }
/** * cockpit_fake_manager_scrape: * @self: a fake manager * @variant: a variant to scrape * * Get all object paths out of the variant in question * (which is usually the parameters to a signal) and * try and poke those object paths. */ void cockpit_fake_manager_scrape (CockpitFakeManager *self, GVariant *variant) { GVariantIter iter; GVariant *child; const gchar *path; if (g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH)) { path = g_variant_get_string (variant, NULL); if (!g_str_equal (path, "/")) cockpit_fake_manager_poke (self, path); } else if (g_variant_is_container (variant)) { g_variant_iter_init (&iter, variant); while ((child = g_variant_iter_next_value (&iter)) != NULL) { cockpit_fake_manager_scrape (self, child); g_variant_unref (child); } } }
static void ide_lsp_formatter_apply_changes (IdeLspFormatter *self, IdeBuffer *buffer, GVariant *text_edits) { g_autoptr(GPtrArray) edits = NULL; g_autoptr(IdeContext) context = NULL; IdeBufferManager *buffer_manager; GVariant *text_edit; GFile *file; GVariantIter iter; IDE_ENTRY; g_assert (IDE_IS_LSP_FORMATTER (self)); g_assert (text_edits != NULL); if (!g_variant_is_container (text_edits)) { g_warning ("variant is not a container, ignoring"); IDE_EXIT; } file = ide_buffer_get_file (buffer); edits = g_ptr_array_new_with_free_func (g_object_unref); g_variant_iter_init (&iter, text_edits); while (g_variant_iter_loop (&iter, "v", &text_edit)) { g_autoptr(IdeLocation) begin_location = NULL; g_autoptr(IdeLocation) end_location = NULL; g_autoptr(IdeRange) range = NULL; const gchar *new_text = NULL; gboolean success; struct { gint64 line; gint64 column; } begin, end; success = JSONRPC_MESSAGE_PARSE (text_edit, "range", "{", "start", "{", "line", JSONRPC_MESSAGE_GET_INT64 (&begin.line), "character", JSONRPC_MESSAGE_GET_INT64 (&begin.column), "}", "end", "{", "line", JSONRPC_MESSAGE_GET_INT64 (&end.line), "character", JSONRPC_MESSAGE_GET_INT64 (&end.column), "}", "}", "newText", JSONRPC_MESSAGE_GET_STRING (&new_text) ); if (!success) { IDE_TRACE_MSG ("Failed to extract change from variant"); continue; } begin_location = ide_location_new (file, begin.line, begin.column); end_location = ide_location_new (file, end.line, end.column); range = ide_range_new (begin_location, end_location); g_ptr_array_add (edits, ide_text_edit_new (range, new_text)); } context = ide_buffer_ref_context (buffer); buffer_manager = ide_buffer_manager_from_context (context); ide_buffer_manager_apply_edits_async (buffer_manager, IDE_PTR_ARRAY_STEAL_FULL (&edits), NULL, NULL, NULL); IDE_EXIT; }
/* Returns a new floating variant (essentially a fixed-up copy of @value) */ static GVariant * _my_replace (GVariant *value) { GVariant *ret; const gchar *dbus_type; if (g_variant_is_of_type (value, G_VARIANT_TYPE_VARDICT) && g_variant_lookup (value, "_dbus_type", "&s", &dbus_type)) { GVariant *passed_value; passed_value = g_variant_lookup_value (value, "value", NULL); if (passed_value != NULL) { JsonNode *serialized; GError *error; serialized = json_gvariant_serialize (passed_value); error = NULL; ret = json_gvariant_deserialize (serialized, dbus_type, &error); json_node_free (serialized); if (ret == NULL) { /* * HACK: Work around bug in JSON-glib, see: * https://bugzilla.gnome.org/show_bug.cgi?id=724319 */ if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_INVALID_DATA && g_variant_is_of_type (passed_value, G_VARIANT_TYPE_INT64) && g_strcmp0 (dbus_type, "d") == 0) { ret = g_variant_new_double (g_variant_get_int64 (passed_value)); g_clear_error (&error); } else { g_warning ("Error converting JSON to requested type %s: %s (%s, %d)", dbus_type, error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); ret = g_variant_ref (value); } } } else { g_warning ("Malformed _dbus_type vardict"); ret = g_variant_ref (value); } } else if (g_variant_is_container (value)) { GVariantBuilder builder; GVariantIter iter; GVariant *child; g_variant_builder_init (&builder, g_variant_get_type (value)); g_variant_iter_init (&iter, value); while ((child = g_variant_iter_next_value (&iter)) != NULL) { g_variant_builder_add_value (&builder, _my_replace (child)); g_variant_unref (child); } ret = g_variant_builder_end (&builder); } else { ret = g_variant_ref (value); } return ret; }