void activate_action_string(GmpvApplication *app, const gchar *str) { GActionMap *map = G_ACTION_MAP(app); GAction *action = NULL; gchar *name = NULL; GVariant *param = NULL; gboolean param_match = FALSE; g_action_parse_detailed_name(str, &name, ¶m, NULL); if(name) { const GVariantType *action_ptype; const GVariantType *given_ptype; action = g_action_map_lookup_action(map, name); action_ptype = g_action_get_parameter_type(action); given_ptype = param?g_variant_get_type(param):NULL; param_match = (action_ptype == given_ptype) || g_variant_type_is_subtype_of (action_ptype, given_ptype); } if(action && param_match) { g_debug("Activating action %s", str); g_action_activate(action, param); } else { g_warning("Failed to activate action \"%s\"", str); } }
static void bluez_handle_disconnect(GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data) { // check if parameter is valid and is the parameter we were looking for if( !(g_variant_type_equal(g_variant_get_type(parameters), "(sv)") && g_variant_n_children(parameters) == 2) ) return; GVariant* name = g_variant_get_child_value(parameters, 0); GVariant* value = g_variant_get_variant(g_variant_get_child_value(parameters, 1)); if( !(g_strcmp0(g_variant_get_string(name, NULL), "Connected") == 0 && g_variant_type_equal(g_variant_get_type(value), G_VARIANT_TYPE_BOOLEAN) ) ) return; gboolean connected = g_variant_get_boolean(value); g_printf("Connected: %d\n", connected); if(!connected) { gchar* device_path = (gchar*)user_data; gchar* service_path = g_strconcat(device_path, "/service0007", NULL); bluez_unregister_watcher(connection, service_path); bluez_register_watcher(connection, service_path); } }
// Simple wrapper for a common D-Bus pattern. GVariant * g_dbus_simple_send(GDBusConnection *bus, GDBusMessage *msg, const gchar *type) { GDBusMessage *reply; GVariant *body; gchar *fmt; if (!(reply = g_dbus_send(bus, msg, 0, -1, 0, 0, 0))) { g_object_unref(msg); return NULL; } body = g_dbus_message_get_body(reply); fmt = g_dbus_message_print(reply, 0); g_variant_ref(body); if (g_strcmp0(g_variant_type_peek_string(g_variant_get_type(body)), type) != 0) { g_message("body type %s does not match expected type %s, message: %s", g_variant_type_peek_string(g_variant_get_type(body)), type, fmt); g_variant_unref(body); // return error body = NULL; } g_free(fmt); g_object_unref(reply); g_object_unref(msg); return body; }
gboolean variantIsValidForCCSType (GVariant *gsettingsValue, CCSSettingType settingType) { gboolean valid = FALSE; switch (settingType) { case TypeString: case TypeMatch: case TypeColor: case TypeKey: case TypeButton: case TypeEdge: valid = (g_variant_type_is_subtype_of (G_VARIANT_TYPE_STRING, g_variant_get_type (gsettingsValue))); break; case TypeInt: valid = (g_variant_type_is_subtype_of (G_VARIANT_TYPE_INT32, g_variant_get_type (gsettingsValue))); break; case TypeBool: case TypeBell: valid = (g_variant_type_is_subtype_of (G_VARIANT_TYPE_BOOLEAN, g_variant_get_type (gsettingsValue))); break; case TypeFloat: valid = (g_variant_type_is_subtype_of (G_VARIANT_TYPE_DOUBLE, g_variant_get_type (gsettingsValue))); break; case TypeList: valid = (g_variant_type_is_array (g_variant_get_type (gsettingsValue))); break; default: break; } return valid; }
unsigned char bluez_characteristic_extract_value(GVariant* variant) { GVariant* var_array = g_variant_get_child_value(variant, 0); for(unsigned int i = 0; i < g_variant_n_children(var_array); i++) { GVariant* var_child = g_variant_get_child_value(var_array, i); if(g_variant_n_children(var_child) == 2) { GVariant* var_id = g_variant_get_child_value(var_child, 0); if(g_variant_type_equal(g_variant_get_type(var_id), G_VARIANT_TYPE_STRING) && g_strcmp0(g_variant_get_string(var_id, NULL), "Value") == 0) { GVariant* inner_var = g_variant_get_child_value(var_child, 1); if( g_variant_type_equal(g_variant_get_type(inner_var), G_VARIANT_TYPE_VARIANT) ) { GVariant* var_value = g_variant_get_variant(inner_var); if( g_variant_type_equal(g_variant_get_type(var_value), G_VARIANT_TYPE_BYTESTRING) ) { GVariant* var_byte = g_variant_get_child_value(var_value, 0); return g_variant_get_byte(var_byte); } } } } g_variant_unref(var_child); } return 0; }
boost::shared_ptr<AuthProvider> createSignonAuthProvider(const InitStateString &username, const InitStateString &password) { // Expected content of parameter GVariant. boost::shared_ptr<GVariantType> hashtype(g_variant_type_new("a{sv}"), g_variant_type_free); // 'username' is the part after signon: which we can parse directly. GErrorCXX gerror; GVariantCXX parametersVar(g_variant_parse(hashtype.get(), username.c_str(), NULL, NULL, gerror), TRANSFER_REF); if (!parametersVar) { gerror.throwError(SE_HERE, "parsing 'signon:' username"); } GHashTableCXX parameters(Variant2HashTable(parametersVar)); // Extract the values that we expect in the parameters hash. guint32 signonID; const char *method; const char *mechanism; GVariant *value; value = (GVariant *)g_hash_table_lookup(parameters, "identity"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_UINT32, g_variant_get_type(value))) { SE_THROW("need 'identity: <numeric ID>' in 'signon:' parameters"); } signonID = g_variant_get_uint32(value); value = (GVariant *)g_hash_table_lookup(parameters, "method"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) { SE_THROW("need 'method: <string>' in 'signon:' parameters"); } method = g_variant_get_string(value, NULL); value = (GVariant *)g_hash_table_lookup(parameters, "mechanism"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) { SE_THROW("need 'mechanism: <string>' in 'signon:' parameters"); } mechanism = g_variant_get_string(value, NULL); value = (GVariant *)g_hash_table_lookup(parameters, "session"); if (!value || !g_variant_type_equal(hashtype.get(), g_variant_get_type(value))) { SE_THROW("need 'session: <hash>' in 'signon:' parameters"); } GHashTableCXX sessionData(Variant2HashTable(value)); SE_LOG_DEBUG(NULL, "using identity %u, method %s, mechanism %s", signonID, method, mechanism); SignonIdentityCXX identity(signon_identity_new_from_db(signonID), TRANSFER_REF); SE_LOG_DEBUG(NULL, "using signond identity %d", signonID); SignonAuthSessionCXX authSession(signon_identity_create_session(identity, method, gerror), TRANSFER_REF); boost::shared_ptr<AuthProvider> provider(new SignonAuthProvider(authSession, sessionData, mechanism)); return provider; }
static GError * _stmt_apply_GV_parameter_simple(sqlite3_stmt *stmt, int pos, GVariant *p) { int rc; gsize slen = 0; const gchar *s; switch (*((gchar*)g_variant_get_type(p))) { case 'b': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_boolean(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'i': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int32(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'n': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int16(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'q': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint16(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 's': s = g_variant_get_string(p, &slen); rc = sqlite3_bind_text(stmt, pos, s, slen, NULL); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 't': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint64(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'u': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint32(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'x': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int64(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'y': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_byte(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; /* XXX TODO manage the G_VARIANT_UNIT associtaed to NULL'd fields */ default: return NEWERROR(CODE_BAD_REQUEST, "Unexpected parameter at position %d ('%s')", pos, (gchar*)g_variant_get_type(p)); } (void) rc; }
TYPE get_numeric_value(GVariant *variant_, const char *type_str, const char *fallback_type_str) { GTYPE value = 0; if (!variant_) return static_cast<TYPE>(value); if (g_variant_is_of_type(variant_, G_VARIANT_TYPE(type_str))) { g_variant_get(variant_, type_str, &value); } else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE(fallback_type_str))) { g_variant_get(variant_, fallback_type_str, &value); } else { auto const& variant = get_variant(variant_); if (variant) return get_numeric_value<TYPE, GTYPE>(static_cast<GVariant*>(variant), type_str, fallback_type_str); LOG_ERROR(logger) << "You're trying to extract a '" << type_str << "'" << " from a variant which is of type '" << g_variant_type_peek_string(g_variant_get_type(variant_)) << "'"; } return static_cast<TYPE>(value); }
std::string Variant::GetString() const { const gchar *result = nullptr; if (!variant_) return ""; if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_STRING)) { // g_variant_get_string doesn't duplicate the string result = g_variant_get_string(variant_, nullptr); } else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(s)"))) { // As we're using the '&' prefix we don't need to free the string! g_variant_get(variant_, "(&s)", &result); } else { auto const& variant = get_variant(variant_); if (variant) return variant.GetString(); LOG_ERROR(logger) << "You're trying to extract a 's' from a variant which is of type '" << g_variant_type_peek_string(g_variant_get_type(variant_)) << "'"; } return result ? result : ""; }
static GError * _stmt_apply_GV_parameter(sqlite3_stmt *stmt, int pos, GVariant *p) { if (g_variant_is_of_type(p, G_VARIANT_TYPE_UNIT)) { sqlite3_bind_null(stmt, pos); return NULL; } if (g_variant_is_of_type(p, G_VARIANT_TYPE_BASIC)) { return _stmt_apply_GV_parameter_simple(stmt, pos, p); } if (g_variant_is_of_type(p, G_VARIANT_TYPE_UNIT)) { sqlite3_bind_null(stmt, pos); return NULL; } if (g_variant_is_of_type(p, G_VARIANT_TYPE_BYTESTRING)) { sqlite3_bind_blob(stmt, pos, g_variant_get_data(p), g_variant_get_size(p), NULL); return NULL; } return NEWERROR(CODE_BAD_REQUEST, "Unexpected parameter at position %d (type '%s')", pos, (gchar*)g_variant_get_type(p)); }
static void services_changed(GVariant *params) { connman_service_t *prev = NULL, *cs; GVariant *del = g_variant_get_child_value(params, 1); for(int i = 0, n = g_variant_n_children(del); i < n; i++) { GVariant *v = g_variant_get_child_value(del, i); if(g_variant_type_equal(g_variant_get_type(v), G_VARIANT_TYPE_OBJECT_PATH)) { const char *name = g_variant_get_string(v, NULL); TRACE(TRACE_DEBUG, "CONNMAN", "Deleted network %s", name); if((cs = connman_service_find(name)) != NULL) connman_service_destroy(cs); } } GVariant *add = g_variant_get_child_value(params, 0); for(int i = 0, n = g_variant_n_children(add); i < n; i++) { GVariant *v = g_variant_get_child_value(add, i); const char *id = g_variant_get_string(g_variant_get_child_value(v, 0), NULL); cs = update_service(g_variant_get_child_value(v, 1), id, prev); if(cs != NULL) prev = cs; } }
static void g_simple_action_set_state (GAction *action, GVariant *value) { GSimpleAction *simple = G_SIMPLE_ACTION (action); g_return_if_fail (value != NULL); { const GVariantType *state_type; state_type = simple->priv->state ? g_variant_get_type (simple->priv->state) : NULL; g_return_if_fail (state_type != NULL); g_return_if_fail (g_variant_is_of_type (value, state_type)); } g_variant_ref_sink (value); if (!g_variant_equal (simple->priv->state, value)) { if (simple->priv->state) g_variant_unref (simple->priv->state); simple->priv->state = g_variant_ref (value); g_object_notify (G_OBJECT (simple), "state"); } g_variant_unref (value); }
static void gb_color_picker_prefs_palette_row_activate (GbColorPickerPrefsPaletteRow *self) { g_autoptr (GVariant) value = NULL; g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self)); g_assert (self->target != NULL); if (!gtk_widget_get_sensitive (GTK_WIDGET (self)) || self->settings == NULL || self->updating) return; value = g_settings_get_value (self->settings, self->key); if (g_variant_is_of_type (value, g_variant_get_type (self->target))) { if (!g_variant_equal (value, self->target)) { self->updating = TRUE; g_settings_set_value (self->settings, self->key, self->target); gtk_widget_set_visible (GTK_WIDGET (self->image), TRUE); self->updating = FALSE; } } else g_warning ("Value and target must be of the same type"); }
static void gb_color_picker_prefs_palette_row_changed (GbColorPickerPrefsPaletteRow *self, const gchar *key, GSettings *settings) { g_autoptr (GVariant) value = NULL; gboolean active; g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self)); g_assert (key != NULL); g_assert (G_IS_SETTINGS (settings)); if (self->target == NULL) { gtk_widget_set_visible (GTK_WIDGET (self->image), FALSE); return; } if (self->updating == TRUE) return; value = g_settings_get_value (settings, key); if (g_variant_is_of_type (value, g_variant_get_type (self->target))) { active = (g_variant_equal (value, self->target)); gtk_widget_set_visible (GTK_WIDGET (self->image), active); } else g_warning ("Value and target must be of the same type"); }
bool QGSettings::trySetValue(const QString &key, const QVariant &value) { Q_D(QGSettings); if (!d->valid) return false; gchar *keyName = Utils::fromCamelCase(key); // Since gio crashes when setting a key that doesn't exist, // we better check here and return false if (!keys().contains(key)) return false; bool result = false; // It might be hard to detect the right GVariant type from // complext QVariant types such as string lists or more detailed // types such as integers (GVariant has different sizes), // therefore we get the current value for the key and convert // to QVariant using the GVariant type GVariant *oldValue = g_settings_get_value(d->settings, keyName); GVariant *newValue = Utils::toGVariant(g_variant_get_type(oldValue), value); if (newValue) result = g_settings_set_value(d->settings, keyName, newValue); g_free(keyName); g_variant_unref(oldValue); return result; }
SR_PRIV int sr_variant_type_check(uint32_t key, GVariant *value) { const struct sr_key_info *info; const GVariantType *type, *expected; char *expected_string, *type_string; info = sr_key_info_get(SR_KEY_CONFIG, key); if (!info) return SR_OK; expected = sr_variant_type_get(info->datatype); type = g_variant_get_type(value); if (!g_variant_type_equal(type, expected) && !g_variant_type_is_subtype_of(type, expected)) { expected_string = g_variant_type_dup_string(expected); type_string = g_variant_type_dup_string(type); sr_err("Wrong variant type for key '%s': expected '%s', got '%s'", info->name, expected_string, type_string); g_free(expected_string); g_free(type_string); return SR_ERR_ARG; } return SR_OK; }
static gboolean iter_get_fields (GVariant *variant, gulong attr_type, GckBuilder *builder) { GString *result; const gchar *key, *value; GVariantIter iter; g_assert (variant != NULL); g_assert (builder != NULL); g_return_val_if_fail (g_variant_type_is_array (g_variant_get_type (variant)), FALSE); result = g_string_new (""); g_variant_iter_init (&iter, variant); while (g_variant_iter_next (&iter, "{&s&s}", &key, &value)) { /* Key */ g_string_append (result, key); g_string_append_c (result, '\0'); /* Value */ g_string_append (result, value); g_string_append_c (result, '\0'); } gck_builder_add_data (builder, attr_type, (const guchar *)result->str, result->len); g_string_free (result, TRUE); return TRUE; }
static void handle_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) { if(g_strcmp0(method_name, "ValueChanged") == 0) { for(unsigned int j = 0; j < g_variant_n_children(parameters); j++) { GVariant* var_child = g_variant_get_child_value(parameters, j); if( g_variant_type_equal(g_variant_get_type(var_child), G_VARIANT_TYPE_OBJECT_PATH) ) g_printf("%s\n", g_variant_get_string(var_child, NULL)); else if( g_variant_type_equal(g_variant_get_type(var_child), "ay") ) { BLEThread* thread = (BLEThread*)user_data; GVariant* var_state = g_variant_get_child_value(var_child, 0); thread->setState(g_variant_get_byte(var_state)); for(unsigned int i = 0; i < g_variant_n_children(var_child); i++) { GVariant* var_inner_child = g_variant_get_child_value(var_child, i); if( g_variant_type_equal(g_variant_get_type(var_inner_child), G_VARIANT_TYPE_BYTE) ) g_printf("%02x ", g_variant_get_byte(var_inner_child)); } g_printf("\n"); } g_variant_unref(var_child); } } else { g_printf("Received method with name %s\n", method_name); } }
static const GVariantType * g_simple_action_get_state_type (GAction *action) { GSimpleAction *simple = G_SIMPLE_ACTION (action); if (simple->priv->state != NULL) return g_variant_get_type (simple->priv->state); else return NULL; }
static void conf_tray_settings_cb (GSettings *settings, guint cnxn_id, gchar *key, gpointer user_data) { GVariant *gv; if (key) { gv = g_settings_get_value (settings, key); if (gv && g_variant_get_type(gv) == G_VARIANT_TYPE_BOOLEAN) ui_tray_enable (g_settings_get_boolean (settings,key)); } }
static gboolean type_uint32 (GSettings *settings, const gchar *key) { const GVariantType *type; GVariant *value; value = g_settings_get_value (settings, key); type = g_variant_get_type (value); g_variant_unref (value); return g_variant_type_equal (type, G_VARIANT_TYPE_UINT32); }
/** * workman_attribute_set_value: * @attr: a #WorkmanAttribute * @value: (transfer floating): the attribute %G_VARIANT_TYPE_MAYBE value to set * @error: (allow-none): return location for a #GError, or %NULL * * Returns: %TRUE if the operation succeeded */ gboolean workman_attribute_set_value(WorkmanAttribute *attr, GVariant *value, GError **error) { g_return_val_if_fail(value != NULL, FALSE); if (attr->priv->value) { const GVariantType *old_type = g_variant_get_type(attr->priv->value); const GVariantType *new_type = g_variant_get_type(value); g_return_val_if_fail(g_variant_type_equal(old_type, new_type), FALSE); g_variant_unref(attr->priv->value); } attr->priv->value = value; g_variant_ref_sink(attr->priv->value); return TRUE; }
void prop_set_from_gvariant(GVariant *v, prop_t *p) { const GVariantType *T = g_variant_get_type(v); if(g_variant_type_equal(T, G_VARIANT_TYPE_BOOLEAN)) { prop_set_int(p, g_variant_get_boolean(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_BYTE)) { prop_set_int(p, g_variant_get_byte(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT16)) { prop_set_int(p, g_variant_get_int16(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT16)) { prop_set_int(p, g_variant_get_uint16(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT32)) { prop_set_int(p, g_variant_get_int32(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT32)) { prop_set_int(p, g_variant_get_uint32(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT64)) { int64_t val = g_variant_get_int64(v); if(val <= INT_MAX) prop_set_int(p, val); else prop_set_float(p, val); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT64)) { uint64_t val = g_variant_get_uint64(v); if(val <= INT_MAX) prop_set_int(p, val); else prop_set_float(p, val); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_STRING) || g_variant_type_equal(T, G_VARIANT_TYPE_OBJECT_PATH) || g_variant_type_equal(T, G_VARIANT_TYPE_SIGNATURE)) { const gchar *val = g_variant_get_string(v, NULL); prop_set_string(p, val); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_VARDICT)) { prop_void_childs(p); prop_set_from_vardict(v, p); } else if(g_variant_type_is_array(T)) { int num = g_variant_n_children(v); prop_destroy_childs(p); for(int i = 0; i < num; i++) { prop_set_from_gvariant(g_variant_get_child_value(v, i), prop_create(p, NULL)); } } else { fprintf(stderr, "%s(): can't deal with type %s\n", __FUNCTION__, g_variant_get_type_string(v)); } }
static void settings_changed (GSettings *settings, gchar *key, gpointer data) { GVariant *value; const GVariantType *type; MetaEnumPreference *cursor; gboolean found_enum; /* String array, handled separately */ if (strcmp (key, KEY_WORKSPACE_NAMES) == 0) { if (update_workspace_names ()); queue_changed (META_PREF_WORKSPACE_NAMES); return; } value = g_settings_get_value (settings, key); type = g_variant_get_type (value); if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) handle_preference_update_bool (settings, key); else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32)) handle_preference_update_int (settings, key); else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) { cursor = preferences_enum; found_enum = FALSE; while (cursor->base.key != NULL) { if (strcmp (key, cursor->base.key) == 0) found_enum = TRUE; cursor++; } if (found_enum) handle_preference_update_enum (settings, key); else handle_preference_update_string (settings, key); } else /* Someone added a preference of an unhandled type */ g_assert_not_reached (); g_variant_unref (value); }
/** * Convert a g_variant to a Scheme return value. */ static Scheme_Object * g_variant_to_scheme_result (GVariant *gv) { const GVariantType *type; // The type of the GVariant // Special case: Singleton tuple. type = g_variant_get_type (gv); if ( (g_variant_type_is_tuple (type)) && (g_variant_n_children (gv) == 1) ) return g_variant_to_scheme_object (g_variant_get_child_value (gv, 0)); // Normal case else return g_variant_to_scheme_object (gv); } // g_variant_to_scheme_result
std::string StringFromVariant(GVariant* variant) { std::stringstream ss; const GVariantType* info_hint_type = g_variant_get_type(variant); if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_BOOLEAN)) { ss << g_variant_get_int16(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT16)) { ss << g_variant_get_int16(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT16)) { ss << g_variant_get_uint16(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT32)) { ss << g_variant_get_int32(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT32)) { ss << g_variant_get_uint32(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT64)) { ss << g_variant_get_int64(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT64)) { ss << g_variant_get_uint64(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_DOUBLE)) { ss << g_variant_get_double(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_STRING)) { std::string str = g_variant_get_string(variant, NULL); ss << str; } else { ss << "unknown value"; } return ss.str(); }
static gboolean g_settings_get_mapping_unsigned_int (GValue *value, GVariant *variant) { const GVariantType *type; guint64 u; type = g_variant_get_type (variant); if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16)) u = g_variant_get_uint16 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32)) u = g_variant_get_uint32 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64)) u = g_variant_get_uint64 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE)) u = g_variant_get_handle (variant); else return FALSE; if (G_VALUE_HOLDS_INT (value)) { g_value_set_int (value, u); return (u <= G_MAXINT32); } else if (G_VALUE_HOLDS_UINT (value)) { g_value_set_uint (value, u); return (u <= G_MAXUINT32); } else if (G_VALUE_HOLDS_INT64 (value)) { g_value_set_int64 (value, u); return (u <= G_MAXINT64); } else if (G_VALUE_HOLDS_UINT64 (value)) { g_value_set_uint64 (value, u); return (u <= G_MAXUINT64); } else if (G_VALUE_HOLDS_DOUBLE (value)) { g_value_set_double (value, u); return TRUE; } return FALSE; }
static gboolean check_value_type (const char *key, GVariant *value, const GVariantType *type, GError **error) { if (g_variant_is_of_type (value, type)) return TRUE; g_set_error (error, XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_INVALID_ARGUMENT, "expected type for key %s is %s, found %s", key, (const char *)type, (const char *)g_variant_get_type (value)); return FALSE; }
Variant Variant::GetVariant() const { Variant value; if (!variant_) return value; value = get_variant(variant_); if (!value) { LOG_ERROR(logger) << "You're trying to extract a 'v' from a variant which is of type '" << g_variant_type_peek_string(g_variant_get_type(variant_)) << "'"; } return value; }
static void _compare_key_value( gchar *key, GVariant *value, Data *user_data) { GVariant *value2 = (GVariant *)g_hash_table_lookup (user_data->table, key); if (value2 && g_variant_get_size (value) == g_variant_get_size (value2) && memcmp (g_variant_get_data(value2), g_variant_get_data(value), g_variant_get_size(value2)) == 0 && g_variant_is_of_type(value2, g_variant_get_type (value))) { return; } user_data->status = 0; }