void TagExtractor::printOneTag( const GstTagList * list, const gchar * tag, gpointer user_data ) { int i, num; num = gst_tag_list_get_tag_size( list, tag ); for (i = 0; i < num; ++i) { const GValue *val; /* Note: when looking for specific tags, use the gst_tag_list_get_xyz() API, * we only use the GValue approach here because it is more generic */ val = gst_tag_list_get_value_index( list, tag, i ); if( G_VALUE_HOLDS_STRING (val)) { g_print( "\t%20s : %s\n", tag, g_value_get_string( val ) ); } else if( G_VALUE_HOLDS_UINT (val)) { g_print( "\t%20s : %u\n", tag, g_value_get_uint( val ) ); } else if( G_VALUE_HOLDS_DOUBLE (val)) { g_print( "\t%20s : %g\n", tag, g_value_get_double( val ) ); } else if( G_VALUE_HOLDS_BOOLEAN (val)) { g_print( "\t%20s : %s\n", tag, (g_value_get_boolean( val )) ? "true" : "false" ); } else if( GST_VALUE_HOLDS_BUFFER (val)) { GstBuffer *buf = gst_value_get_buffer (val); guint buffer_size = gst_buffer_get_size( buf ); g_print( "\t%20s : buffer of size %u\n", tag, buffer_size ); } else if( GST_VALUE_HOLDS_DATE_TIME (val)) { GstDateTime *dt = (GstDateTime*) g_value_get_boxed( val ); gchar *dt_str = gst_date_time_to_iso8601_string( dt ); g_print( "\t%20s : %s\n", tag, dt_str ); g_free( dt_str ); } else { g_print( "\t%20s : tag of type '%s'\n", tag, G_VALUE_TYPE_NAME (val)); } } }
static void print_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data) { gint i, num; num = gst_tag_list_get_tag_size (list, tag); for (i = 0; i < num; ++i) { const GValue *val; val = gst_tag_list_get_value_index (list, tag, i); if (G_VALUE_HOLDS_STRING (val)) { g_print (" %s : %s \n", tag, g_value_get_string (val)); } else if (G_VALUE_HOLDS_UINT (val)) { g_print (" %s : %u \n", tag, g_value_get_uint (val)); } else if (G_VALUE_HOLDS_DOUBLE (val)) { g_print (" %s : %g \n", tag, g_value_get_double (val)); } else if (G_VALUE_HOLDS_BOOLEAN (val)) { g_print (" %s : %s \n", tag, g_value_get_boolean (val) ? "true" : "false"); } else if (GST_VALUE_HOLDS_DATE_TIME (val)) { GstDateTime *dt = g_value_get_boxed (val); gchar *dt_str = gst_date_time_to_iso8601_string (dt); g_print (" %s : %s \n", tag, dt_str); g_free (dt_str); } else { g_print (" %s : tag of type '%s' \n", tag, G_VALUE_TYPE_NAME (val)); } } }
void cd_NetworkMonitor_get_wired_connection_infos (void) { cd_debug ("%s ()", __func__); GHashTable *hProperties; GValue *v; //\_____________ On recupere les proprietes du device "wired" hProperties = cairo_dock_dbus_get_all_properties (myData.dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device.Wired"); g_return_if_fail (hProperties != NULL); v = (GValue *)g_hash_table_lookup (hProperties, "Speed"); if (v != NULL && G_VALUE_HOLDS_UINT (v)) { myData.iSpeed = g_value_get_uint (v); cd_debug(" Vitesse de connexion : %d",myData.iSpeed); } v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress"); if (v != NULL && G_VALUE_HOLDS_STRING (v)) { myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v)); cd_debug(" Adresse physique : %s",myData.cAccessPointHwAdress); } myData.iQuality = WIRED_NO_CONNECTION; v = (GValue *)g_hash_table_lookup (hProperties, "Carrier"); if (v != NULL && G_VALUE_HOLDS_BOOLEAN (v)) { if (g_value_get_boolean (v)) myData.iQuality = WIRED_CONNECTION; cd_debug(" cable branche : %d", g_value_get_boolean (v)); } g_hash_table_unref (hProperties); }
/* * Returns object's disk usage size */ guint midgard_quota_get_object_size(MidgardObject *object) { g_assert(object != NULL); MidgardConnection *mgd = MGD_OBJECT_CNC (object); if (!MGD_CNC_QUOTA (mgd) || !MGD_DBOBJECT_HAS_METADATA(object)) return 0; const gchar *tablename = midgard_core_class_get_table(MIDGARD_DBOBJECT_GET_CLASS(object)); gchar *where = midgard_core_query_where_guid(tablename, MGD_OBJECT_GUID (object)); GValue *value = midgard_core_query_get_field_value( MGD_OBJECT_CNC (object), "metadata_size", tablename, where); g_free(where); guint size = 0; if(G_VALUE_HOLDS_UINT(value)) size = g_value_get_uint(value); if(G_VALUE_HOLDS_INT(value)) size = (guint) g_value_get_int(value); g_value_unset(value); g_free(value); return size; }
int ce_get_property_default (NMSetting *setting, const char *property_name) { GParamSpec *spec; GValue value = { 0, }; g_return_val_if_fail (NM_IS_SETTING (setting), -1); spec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), property_name); g_return_val_if_fail (spec != NULL, -1); g_value_init (&value, spec->value_type); g_param_value_set_default (spec, &value); if (G_VALUE_HOLDS_CHAR (&value)) return (int) g_value_get_schar (&value); else if (G_VALUE_HOLDS_INT (&value)) return g_value_get_int (&value); else if (G_VALUE_HOLDS_INT64 (&value)) return (int) g_value_get_int64 (&value); else if (G_VALUE_HOLDS_LONG (&value)) return (int) g_value_get_long (&value); else if (G_VALUE_HOLDS_UINT (&value)) return (int) g_value_get_uint (&value); else if (G_VALUE_HOLDS_UINT64 (&value)) return (int) g_value_get_uint64 (&value); else if (G_VALUE_HOLDS_ULONG (&value)) return (int) g_value_get_ulong (&value); else if (G_VALUE_HOLDS_UCHAR (&value)) return (int) g_value_get_uchar (&value); g_return_val_if_fail (FALSE, 0); return 0; }
static gpointer value_as_pointer (GValue *value) { if (g_value_fits_pointer (value)) return g_value_peek_pointer (value); if (G_VALUE_HOLDS_BOOLEAN (value)) return (void*) g_value_get_boolean (value); if (G_VALUE_HOLDS_CHAR (value)) return (void*) (gssize) g_value_get_char (value); if (G_VALUE_HOLDS_UCHAR (value)) return (void*) (gsize) g_value_get_uchar (value); if (G_VALUE_HOLDS_INT (value)) return (void*) g_value_get_int (value); if (G_VALUE_HOLDS_UINT (value)) return (void*) g_value_get_uint (value); if (G_VALUE_HOLDS_LONG (value)) return (void*) g_value_get_long (value); if (G_VALUE_HOLDS_ULONG (value)) return (void*) g_value_get_ulong (value); if (G_VALUE_HOLDS_FLOAT (value)) return (void*) (gssize) g_value_get_float (value); if (G_VALUE_HOLDS_DOUBLE (value)) return (void*) (gssize) g_value_get_double (value); if (G_VALUE_HOLDS_ENUM (value)) return (void*) (gssize) g_value_get_enum (value); if (G_VALUE_HOLDS_FLAGS (value)) return (void*) (gsize) g_value_get_flags (value); return (void*) 0x1373babe; }
/** * midgard_workspace_context_has_workspace: * @self: #MidgardWorkspaceContext instance * @workspace: #MidgardWorkspace to check * * Check, whether given @workspace is in given context * * Returns: %TRUE on success, %FALSE otherwise * Since: 10.05.5 */ gboolean midgard_workspace_context_has_workspace (MidgardWorkspaceContext *self, MidgardWorkspace *workspace) { g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (workspace != NULL, FALSE); gboolean rv = FALSE; GSList *ids = MIDGARD_WORKSPACE_STORAGE_GET_INTERFACE (self)->priv->list_ids (NULL, MIDGARD_WORKSPACE_STORAGE (self)); if (!ids) return rv; GSList *l; guint ws_id = 0; for (l = ids; l != NULL; l = l->next) { GValue *val = (GValue *) l->data; if (G_VALUE_HOLDS_UINT (val)) ws_id = g_value_get_uint (val); else ws_id = g_value_get_int (val); if (ws_id == workspace->priv->id) { rv = TRUE; break; } } g_slist_free (ids); return rv; }
static void serving_system_reply (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { CdmaDeviceInfo *info = user_data; GError *error = NULL; GValueArray *array = NULL; guint32 new_sid = 0; GValue *value; if (dbus_g_proxy_end_call (proxy, call, &error, SERVING_SYSTEM_TYPE, &array, G_TYPE_INVALID)) { if (array->n_values == 3) { value = g_value_array_get_nth (array, 2); if (G_VALUE_HOLDS_UINT (value)) new_sid = g_value_get_uint (value); } g_value_array_free (array); } if (new_sid != info->sid) { info->sid = new_sid; g_free (info->provider_name); info->provider_name = mobile_helper_parse_3gpp2_operator_name (&(info->mobile_providers_database), info->sid); } g_clear_error (&error); }
/** * g_value_get_uint: * @value: a valid #GValue of type %G_TYPE_UINT * * Get the contents of a %G_TYPE_UINT #GValue. * * Returns: unsigned integer contents of @value */ guint g_value_get_uint (const GValue *value) { g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0); return value->data[0].v_uint; }
/** * g_value_set_uint: * @value: a valid #GValue of type %G_TYPE_UINT * @v_uint: unsigned integer value to be set * * Set the contents of a %G_TYPE_UINT #GValue to @v_uint. */ void g_value_set_uint (GValue *value, guint v_uint) { g_return_if_fail (G_VALUE_HOLDS_UINT (value)); value->data[0].v_uint = v_uint; }
static GVariant * g_settings_set_mapping_unsigned_int (const GValue *value, const GVariantType *expected_type) { GVariant *variant = NULL; guint64 u; if (G_VALUE_HOLDS_UINT (value)) u = g_value_get_uint (value); else if (G_VALUE_HOLDS_UINT64 (value)) u = g_value_get_uint64 (value); else return NULL; if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16)) { if (u <= G_MAXINT16) variant = g_variant_new_int16 ((gint16) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16)) { if (u <= G_MAXUINT16) variant = g_variant_new_uint16 ((guint16) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32)) { if (u <= G_MAXINT32) variant = g_variant_new_int32 ((gint) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32)) { if (u <= G_MAXUINT32) variant = g_variant_new_uint32 ((guint) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64)) { if (u <= G_MAXINT64) variant = g_variant_new_int64 ((gint64) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64)) { if (u <= G_MAXUINT64) variant = g_variant_new_uint64 ((guint64) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE)) { if (u <= G_MAXUINT32) variant = g_variant_new_handle ((guint) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE)) variant = g_variant_new_double ((gdouble) u); return variant; }
static void set_sysfs_uint (const char *iface, GObject *obj, const char *obj_prop, const char *dir, const char *sysfs_prop, gboolean default_if_zero, gboolean user_hz_compensate) { char *path, *s; GParamSpec *pspec; GValue val = { 0 }; guint32 uval = 0; pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (obj), obj_prop); g_return_if_fail (pspec != NULL); /* Get the property's value */ g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec)); g_object_get_property (obj, obj_prop, &val); if (G_VALUE_HOLDS_BOOLEAN (&val)) uval = g_value_get_boolean (&val) ? 1 : 0; else if (G_VALUE_HOLDS_UINT (&val)) { uval = g_value_get_uint (&val); /* zero means "unspecified" for some NM properties but isn't in the * allowed kernel range, so reset the property to the default value. */ if (default_if_zero && uval == 0) { g_value_unset (&val); g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec)); g_param_value_set_default (pspec, &val); uval = g_value_get_uint (&val); } } else g_assert_not_reached (); g_value_unset (&val); /* Linux kernel bridge interfaces use 'centiseconds' for time-based values. * In reality it's not centiseconds, but depends on HZ and USER_HZ, which * is almost always works out to be a multiplier of 100, so we can assume * centiseconds. See clock_t_to_jiffies(). */ if (user_hz_compensate) uval *= 100; path = g_strdup_printf ("/sys/class/net/%s/%s/%s", iface, dir, sysfs_prop); s = g_strdup_printf ("%u", uval); /* FIXME: how should failure be handled? */ nm_utils_do_sysctl (path, s); g_free (path); g_free (s); }
static void manager_prepared_cb (GObject *source, GAsyncResult *result, gpointer user_data) { TpWeakRef *wr = user_data; EmpathyAppPluginWidget *self = tp_weak_ref_dup_object (wr); TpAccountManager *manager = (TpAccountManager *) source; GList *accounts; GError *error = NULL; if (self == NULL) { tp_weak_ref_destroy (wr); return; } if (!tp_proxy_prepare_finish (manager, result, &error)) { g_debug ("Error preparing Account Manager: %s", error->message); g_clear_error (&error); goto out; } accounts = tp_account_manager_dup_valid_accounts (manager); while (accounts != NULL) { TpAccount *account = accounts->data; const GValue *value; value = tp_account_get_storage_identifier (account); if (G_VALUE_HOLDS_UINT (value) && g_value_get_uint (value) == self->priv->account->id) { GtkWidget *alig; alig = gtk_alignment_new (0.5, 0, 0, 0); self->priv->user_info = tpaw_user_info_new (account); gtk_container_add (GTK_CONTAINER (alig), self->priv->user_info); gtk_widget_show (self->priv->user_info); gtk_box_pack_start (GTK_BOX (self), alig, TRUE, TRUE, 0); gtk_widget_show (alig); break; } accounts = g_list_delete_link (accounts, accounts); } g_list_free_full (accounts, g_object_unref); out: tp_weak_ref_destroy (wr); g_object_unref (self); }
guint ol_get_uint_from_hash_table (GHashTable *hash_table, const gchar *key) { if (!hash_table) return 0; GValue *value; value = (GValue *) g_hash_table_lookup(hash_table, key); if (value != NULL && G_VALUE_HOLDS_UINT(value)) return g_value_get_uint (value); else return 0; }
/* * Set a new maximum total size for the map tile cache. */ void ph_config_set_max_tile_cache_size(const GValue *value) { g_return_if_fail(ph_config != NULL); g_return_if_fail(value == NULL || G_VALUE_HOLDS_UINT(value)); if (value != NULL) g_key_file_set_uint64(ph_config->key_file, "tile-cache", "max-size", g_value_get_uint(value)); else g_key_file_remove_key(ph_config->key_file, "tile-cache", "max-size", NULL); }
/* * If the given row in the model is the name we're looking for, run it. * Otherwise keep looking. */ gboolean run_desktop_entry(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) { char *name_v; struct state *st; GValue value = G_VALUE_INIT; st = (struct state *)data; gtk_tree_model_get_value(model, iter, NAME_COLUMN, &value); if (!G_VALUE_HOLDS_STRING(&value)) { warnx("gtk_tree_model_get_value: name is not a string"); return FALSE; } name_v = g_value_dup_string(&value); g_value_unset(&value); if (strlen(name_v) != strlen(st->name) || strncmp(name_v, st->name, strlen(st->name)) != 0) return FALSE; gtk_tree_model_get_value(model, iter, EXEC_COLUMN, &value); if (!G_VALUE_HOLDS_STRING(&value)) { warnx("gtk_tree_model_get_value: exec is not a string"); return TRUE; } st->cmd = g_value_dup_string(&value); g_value_unset(&value); gtk_tree_model_get_value(model, iter, FCODE_COLUMN, &value); if (!G_VALUE_HOLDS_UINT(&value)) { warnx("gtk_tree_model_get_value: flags are not an integer"); return TRUE; } st->flags = g_value_get_uint(&value); g_value_unset(&value); gtk_tree_model_get_value(model, iter, TERM_COLUMN, &value); if (!G_VALUE_HOLDS_BOOLEAN(&value)) { warnx("gtk_tree_model_get_value: term is not a Boolean"); return TRUE; } st->use_term = g_value_get_boolean(&value); g_value_unset(&value); if (run_cmd(st)) return TRUE; return TRUE; }
/* * Get the maximum total size, in megabytes, of the tile cache directory. This * is an unsigned integer value. */ void ph_config_get_max_tile_cache_size(GValue *value) { guint max_size; g_return_if_fail(ph_config != NULL); g_return_if_fail(G_VALUE_HOLDS_UINT(value)); max_size = g_key_file_get_uint64(ph_config->key_file, "tile-cache", "max-size", NULL); g_value_set_uint(value, (max_size != 0) ? max_size : 100); }
void cd_NetworkMonitor_get_wireless_connection_infos (void) { cd_debug ("%s ()", __func__); GHashTable *hProperties; GValue *v; g_free (myData.cAccessPointHwAdress); myData.cAccessPointHwAdress = NULL; myData.iSpeed = 0; //\_____________ On recupere les proprietes du device "wireless". hProperties = cairo_dock_dbus_get_all_properties (myData.dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device.Wireless"); g_return_if_fail (hProperties != NULL); v = (GValue *)g_hash_table_lookup (hProperties, "Bitrate"); if (v && G_VALUE_HOLDS_UINT (v)) { myData.iSpeed = g_value_get_uint (v); cd_debug (" Bitrate : %d\n",myData.iSpeed); } v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress"); if (v && G_VALUE_HOLDS_STRING (v)) { myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v)); cd_debug (" Adresse physique : %s\n",myData.cAccessPointHwAdress); } v = (GValue *)g_hash_table_lookup (hProperties, "ActiveAccessPoint"); if (v && G_VALUE_HOLDS (v, DBUS_TYPE_G_OBJECT_PATH)) { gchar *cAccessPoint = g_value_get_boxed (v); cd_debug (" Access point : %s", cAccessPoint); if (cAccessPoint && strncmp (cAccessPoint, "/org/freedesktop/NetworkManager/AccessPoint/", 44) == 0) { g_free (myData.cAccessPoint); myData.cAccessPoint = g_strdup (cAccessPoint); } } g_hash_table_unref (hProperties); //\_____________ On recupere le point d'acces courant sur le bus. myData.iQuality = WIFI_QUALITY_NO_SIGNAL; if (myData.cAccessPoint != NULL) { cd_NetworkMonitor_get_new_access_point (); } }
const gchar * _midgard_workspace_context_get_path (MidgardWorkspaceStorage *wss) { g_return_val_if_fail (wss != NULL, NULL); MidgardWorkspaceContext *self = MIDGARD_WORKSPACE_CONTEXT (wss); if (!self->priv->manager) return NULL; MidgardConnection *mgd = self->priv->manager->priv->mgd; if (!mgd) return NULL; guint ws_id = self->priv->id; if (ws_id == 0) return NULL; const GValue *up_val = midgard_core_workspace_get_value_by_id (mgd, MGD_WORKSPACE_FIELD_IDX_UP, ws_id, NULL); if (!up_val) return NULL; guint up_id = 0; if (G_VALUE_HOLDS_UINT (up_val)) up_id = g_value_get_uint (up_val); else up_id = (guint) g_value_get_int (up_val); GSList *list = midgard_core_workspace_get_parent_names (mgd, up_id); GSList *l; GString *str = g_string_new (""); for (l = list; l != NULL; l = l->next) { gchar *name = (gchar *) l->data; g_string_append_printf (str, "/%s", name); } if (list) g_slist_free (list); const GValue *name_value = midgard_core_workspace_get_value_by_id (mgd, MGD_WORKSPACE_FIELD_IDX_NAME, ws_id, NULL); g_string_append_printf (str, "/%s", g_value_get_string (name_value)); g_free (self->priv->path); self->priv->path = g_string_free (str, FALSE); return (const gchar *) self->priv->path; }
static void commit_option (NMDevice *device, NMSetting *setting, const Option *option, gboolean slave) { int ifindex = nm_device_get_ifindex (device); GParamSpec *pspec; GValue val = G_VALUE_INIT; guint32 uval = 0; gs_free char *value = NULL; g_assert (setting); pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), option->name); g_assert (pspec); /* Get the property's value */ g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec)); g_object_get_property ((GObject *) setting, option->name, &val); if (G_VALUE_HOLDS_BOOLEAN (&val)) uval = g_value_get_boolean (&val) ? 1 : 0; else if (G_VALUE_HOLDS_UINT (&val)) { uval = g_value_get_uint (&val); /* zero means "unspecified" for some NM properties but isn't in the * allowed kernel range, so reset the property to the default value. */ if (option->default_if_zero && uval == 0) { g_value_unset (&val); g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec)); g_param_value_set_default (pspec, &val); uval = g_value_get_uint (&val); } /* Linux kernel bridge interfaces use 'centiseconds' for time-based values. * In reality it's not centiseconds, but depends on HZ and USER_HZ, which * is almost always works out to be a multiplier of 100, so we can assume * centiseconds. See clock_t_to_jiffies(). */ if (option->user_hz_compensate) uval *= 100; } else g_assert_not_reached (); g_value_unset (&val); value = g_strdup_printf ("%u", uval); if (slave) nm_platform_slave_set_option (ifindex, option->sysname, value); else nm_platform_master_set_option (ifindex, option->sysname, value); }
/* * Pull out the executable from the selected entry, and run it. */ void app_selected(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data) { GtkTreeModel *model; GtkTreeIter iter; GValue value = G_VALUE_INIT; struct state *st; st = (struct state *)user_data; if ((model = gtk_tree_view_get_model(tree_view)) == NULL) { warnx("gtk_tree_view_get_model is NULL"); return; } if (!gtk_tree_model_get_iter(model, &iter, path)) { warnx("gtk_tree_model_get_iter: path does not exist"); return; } gtk_tree_model_get_value(model, &iter, EXEC_COLUMN, &value); if (!G_VALUE_HOLDS_STRING(&value)) { warnx("gtk_tree_model_get_value: exec is not a string"); return; } st->cmd = g_value_dup_string(&value); g_value_unset(&value); gtk_tree_model_get_value(model, &iter, FCODE_COLUMN, &value); if (!G_VALUE_HOLDS_UINT(&value)) { warnx("gtk_tree_model_get_value: flags are not an integer"); return; } st->flags = g_value_get_uint(&value); g_value_unset(&value); gtk_tree_model_get_value(model, &iter, TERM_COLUMN, &value); if (!G_VALUE_HOLDS_BOOLEAN(&value)) { warnx("gtk_tree_model_get_value: term is not a Boolean"); return; } st->use_term = g_value_get_boolean(&value); g_value_unset(&value); if (run_cmd(st)) gtk_main_quit(); }
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 char * build_message (GPtrArray *fields, AuditBackend backend) { GString *string; AuditField *field; gboolean first = TRUE; guint i; string = g_string_new (NULL); for (i = 0; i < fields->len; i++) { field = fields->pdata[i]; if (!NM_FLAGS_HAS (field->backends, backend)) continue; if (first) first = FALSE; else g_string_append_c (string, ' '); if (G_VALUE_HOLDS_STRING (&field->value)) { const char *str = g_value_get_string (&field->value); #if HAVE_LIBAUDIT if (backend == BACKEND_AUDITD) { if (field->need_encoding) { char *value; value = audit_encode_nv_string (field->name, str, 0); g_string_append (string, value); g_free (value); } else g_string_append_printf (string, "%s=%s", field->name, str); continue; } #endif /* HAVE_LIBAUDIT */ g_string_append_printf (string, "%s=\"%s\"", field->name, str); } else if (G_VALUE_HOLDS_UINT (&field->value)) { g_string_append_printf (string, "%s=%u", field->name, g_value_get_uint (&field->value)); } else g_assert_not_reached (); } return g_string_free (string, FALSE); }
static gboolean g_settings_get_mapping_int (GValue *value, GVariant *variant) { const GVariantType *type; gint64 l; type = g_variant_get_type (variant); if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16)) l = g_variant_get_int16 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32)) l = g_variant_get_int32 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64)) l = g_variant_get_int64 (variant); else return FALSE; if (G_VALUE_HOLDS_INT (value)) { g_value_set_int (value, l); return (G_MININT32 <= l && l <= G_MAXINT32); } else if (G_VALUE_HOLDS_UINT (value)) { g_value_set_uint (value, l); return (0 <= l && l <= G_MAXUINT32); } else if (G_VALUE_HOLDS_INT64 (value)) { g_value_set_int64 (value, l); return (G_MININT64 <= l && l <= G_MAXINT64); } else if (G_VALUE_HOLDS_UINT64 (value)) { g_value_set_uint64 (value, l); return (0 <= l && l <= G_MAXUINT64); } else if (G_VALUE_HOLDS_DOUBLE (value)) { g_value_set_double (value, l); return TRUE; } return FALSE; }
static gboolean lldp_neighbor_equal (LLDPNeighbor *a, LLDPNeighbor *b) { GHashTableIter iter; gpointer k, v; g_return_val_if_fail (a && a->tlvs, FALSE); g_return_val_if_fail (b && b->tlvs, FALSE); if ( a->chassis_id_type != b->chassis_id_type || a->port_id_type != b->port_id_type || a->dest != b->dest || g_strcmp0 (a->chassis_id, b->chassis_id) || g_strcmp0 (a->port_id, b->port_id)) return FALSE; if (g_hash_table_size (a->tlvs) != g_hash_table_size (b->tlvs)) return FALSE; g_hash_table_iter_init (&iter, a->tlvs); while (g_hash_table_iter_next (&iter, &k, &v)) { GValue *value_a, *value_b; value_a = v; value_b = g_hash_table_lookup (b->tlvs, k); if (!value_b) return FALSE; g_return_val_if_fail (G_VALUE_TYPE (value_a) == G_VALUE_TYPE (value_b), FALSE); if (G_VALUE_HOLDS_STRING (value_a)) { if (g_strcmp0 (g_value_get_string (value_a), g_value_get_string (value_b))) return FALSE; } else if (G_VALUE_HOLDS_UINT (value_a)) { if (g_value_get_uint (value_a) != g_value_get_uint (value_b)) return FALSE; } else g_return_val_if_reached (FALSE); } return TRUE; }
static void print_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data) { int i, num; num = gst_tag_list_get_tag_size (list, tag); for (i = 0; i < num; ++i) { const GValue *val; /* Note: when looking for specific tags, use the g_tag_list_get_xyz() API, * we only use the GValue approach here because it is more generic */ val = gst_tag_list_get_value_index (list, tag, i); if (G_VALUE_HOLDS_STRING (val)) { const char* unformatted = g_value_get_string (val); gchar* formatted = strescape(unformatted,"\"","\""); g_print ("(%s . \"%s\")\n", tag, formatted); g_free(formatted); } else if (G_VALUE_HOLDS_UINT (val)) { unsigned int uint = g_value_get_uint (val); if(uint > 0xf) g_print ("(%s . #x%x)\n", tag, uint); } else if (G_VALUE_HOLDS_DOUBLE (val)) { g_print ("(%s . %g)\n", tag, g_value_get_double (val)); } else if (G_VALUE_HOLDS_BOOLEAN (val)) { g_print ("(%s . %s)\n", tag, (g_value_get_boolean (val)) ? "#t" : "#f"); } else if (GST_VALUE_HOLDS_BUFFER (val)) { g_print ("(%s . (buffer %u))", tag, gst_buffer_get_size(gst_value_get_buffer (val))); } else if (GST_VALUE_HOLDS_DATE_TIME (val)) { GDate* date = (GDate*)g_value_get_boxed(val); g_print ("(%s . (date 0 0 0 %u %u %u))\n", tag, g_date_get_day(date), g_date_get_month(date), g_date_get_year (date)); } else { g_print ("(%20s . (type %s))", tag, G_VALUE_TYPE_NAME (val)); } } }
/* This function really ought not to be part of Amanda. In my (Ian's) opinion, serialization and deserialization should be a part of the GValue interface. But it's not, and here we are. */ gboolean g_value_set_from_string(GValue * val, char * string) { g_return_val_if_fail(val != NULL, FALSE); g_return_val_if_fail(G_IS_VALUE(val), FALSE); if (G_VALUE_HOLDS_BOOLEAN(val)) { return g_value_set_boolean_from_string(val, string); } else if (G_VALUE_HOLDS_INT(val)) { return g_value_set_int_from_string(val, string); } else if (G_VALUE_HOLDS_UINT(val)) { return g_value_set_uint_from_string(val, string); } else if (G_VALUE_HOLDS_UINT64(val)) { return g_value_set_uint64_from_string(val, string); } else if (G_VALUE_HOLDS_STRING(val)) { g_value_set_string(val, string); return TRUE; } else if (G_VALUE_HOLDS_FLAGS(val)) { return g_value_set_flags_from_string(val, string); } return TRUE; }
// les proprietes d'un AccessPoint sont : // Flags - u - (read) (NM_802_11_AP_FLAGS) // Flags describing the capabilities of the access point. // WpaFlags - u - (read) (NM_802_11_AP_SEC) // Flags describing the access point's capabilities according to WPA (Wifi Protected Access). // RsnFlags - u - (read) (NM_802_11_AP_SEC) // Flags describing the access point's capabilities according to the RSN (Robust Secure Network) protocol. // Ssid - ay - (read) // The Service Set Identifier identifying the access point. // Frequency - u - (read) // The radio channel frequency in use by the access point, in MHz. // HwAddress - s - (read) // The hardware address (BSSID) of the access point. // Mode - u - (read) (NM_802_11_MODE) // Describes the operating mode of the access point. // MaxBitrate - u - (read) // The maximum bitrate this access point is capable of, in kilobits/second (Kb/s). // Strength - y - (read) // The current signal quality of the access point, in percent. void cd_NetworkMonitor_fetch_access_point_properties (GHashTable *hProperties) { GValue *v; v = (GValue *)g_hash_table_lookup (hProperties, "Strength"); if (v != NULL && G_VALUE_HOLDS_UCHAR (v)) { myData.iPercent = MIN (100, (gint) g_value_get_uchar (v)); // pas clair si c'est deja des % ou s'il faut convertir par 100/255, des fois on se chope des 255 ... cd_debug ("Network-Monitor : Force du signal : %d %%", myData.iPercent); cd_NetworkMonitor_quality (); cd_NetworkMonitor_draw_icon (); } v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress"); if (v != NULL && G_VALUE_HOLDS_STRING (v)) { myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v)); cd_debug ("Network-Monitor : Adresse physique de l'AP active : %s", myData.cAccessPointHwAdress); } v = (GValue *)g_hash_table_lookup (hProperties, "Ssid"); if (v != NULL && G_VALUE_HOLDS_BOXED (v)) { GByteArray *a = g_value_get_boxed (v); myData.cESSID = g_new0 (gchar, a->len+1); for (uint i = 0; i < a->len; i ++) { myData.cESSID[i] = a->data[i]; } cd_debug ("Network-Monitor : SSID : %s", myData.cESSID); } v = (GValue *)g_hash_table_lookup (hProperties, "MaxBitrate"); // in kilobits/second (Kb/s). if (v != NULL && G_VALUE_HOLDS_UINT (v)) { myData.iSpeed = (gint) g_value_get_uint (v) / 8; // Ko/s cd_debug("Network-Monitor : Max Bitrate au demarrage : %d",myData.iSpeed); } }
static gboolean string_to_num (GBinding *binding, const GValue *source_value, GValue *target_value, gpointer userdata) { if (G_VALUE_HOLDS_INT (target_value)) g_value_set_int (target_value, atoi (g_value_get_string (source_value))); else if (G_VALUE_HOLDS_UINT (target_value)) g_value_set_uint (target_value, atoi (g_value_get_string (source_value))); else if (G_VALUE_HOLDS_DOUBLE (target_value)) g_value_set_double (target_value, strtod (g_value_get_string (source_value), NULL)); else if (G_VALUE_HOLDS_FLOAT (target_value)) g_value_set_float (target_value, strtof (g_value_get_string (source_value), NULL)); else return FALSE; return TRUE; }
static gboolean num_to_string (GBinding *binding, const GValue *source_value, GValue *target_value, gpointer userdata) { gchar *string; if (G_VALUE_HOLDS_INT (source_value)) string = g_strdup_printf ("%d", g_value_get_int (source_value)); else if (G_VALUE_HOLDS_UINT (source_value)) string = g_strdup_printf ("%d", g_value_get_uint (source_value)); else if (G_VALUE_HOLDS_DOUBLE (source_value)) string = g_strdup_printf ("%.2f", g_value_get_double (source_value)); else if (G_VALUE_HOLDS_FLOAT (source_value)) string = g_strdup_printf ("%.2f", g_value_get_float (source_value)); else return FALSE; g_value_take_string (target_value, string); return TRUE; }