/* * * Fundemental type transformations * */ static GVariant * serialize_fundamental(GvsSerializer *self, const GValue *value, gpointer unused) { GVariant *variant; switch (G_VALUE_TYPE(value)) { case G_TYPE_BOOLEAN: variant = g_variant_new_boolean(g_value_get_boolean(value)); break; case G_TYPE_CHAR: variant = g_variant_new_byte(g_value_get_schar(value)); break; case G_TYPE_DOUBLE: variant = g_variant_new_double(g_value_get_double(value)); break; case G_TYPE_FLOAT: variant = g_variant_new_double(g_value_get_float(value)); break; case G_TYPE_INT: variant = g_variant_new_int32(g_value_get_int(value)); break; case G_TYPE_INT64: case G_TYPE_LONG: variant = g_variant_new_int64(g_value_get_int64(value)); break; case G_TYPE_STRING: variant = g_variant_new("ms", g_value_get_string(value)); break; case G_TYPE_UCHAR: variant = g_variant_new_byte(g_value_get_uchar(value)); break; case G_TYPE_UINT: variant = g_variant_new_uint32(g_value_get_uint(value)); break; case G_TYPE_UINT64: case G_TYPE_ULONG: variant = g_variant_new_uint64(g_value_get_uint64(value)); break; case G_TYPE_VARIANT: variant = g_value_dup_variant(value); break; default: g_assert_not_reached(); break; } return variant; }
static GVariant* _field_to_gvariant(gpointer bean, guint position) { gpointer pf = FIELD(bean, position); if (!_bean_has_field(bean, position)) return g_variant_new_tuple(NULL, 0); switch (DESCR_FIELD(bean,position)->type) { case FT_BOOL: return g_variant_new_byte(*((gboolean*)pf) ? 1 : 0); case FT_INT: return g_variant_new_int64(*((gint64*)pf)); case FT_REAL: return g_variant_new_double(*((gdouble*)pf)); case FT_TEXT: if (!*((gpointer*)(pf))) return g_variant_new_tuple(NULL, 0); return g_variant_new_string(GSTR(pf)->str); case FT_BLOB: if (!*((gpointer*)(pf))) return g_variant_new_tuple(NULL, 0); return _gba_to_gvariant(GBA(pf)); default: g_assert_not_reached(); break; } g_assert_not_reached(); return NULL; }
void mooshi_initialized(SooshiState *state, gpointer user_data) { AppState *s = (AppState*)user_data; g_info("Mooshimeter initialized!"); sooshi_node_subscribe(state, sooshi_node_find(state, "BAT_V", NULL), battery_update, user_data); sooshi_node_subscribe(state, sooshi_node_find(state, "CH1:VALUE", NULL), channel1_update, user_data); sooshi_node_subscribe(state, sooshi_node_find(state, "CH2:VALUE", NULL), channel2_update, user_data); SooshiNode *sampling_trigger = sooshi_node_find(state, "SAMPLING:TRIGGER", NULL); SooshiNode *sampling_rate = sooshi_node_find(state, "SAMPLING:RATE", NULL); SooshiNode *sampling_depth = sooshi_node_find(state, "SAMPLING:DEPTH", NULL); fill_combo_box_with_children(s->trigger, sampling_trigger); fill_combo_box_with_children(s->sample_rate, sampling_rate); fill_combo_box_with_children(s->sample_depth, sampling_depth); sooshi_node_subscribe(state, sampling_trigger, sample_config_update, s->trigger); sooshi_node_subscribe(state, sampling_rate, sample_config_update, s->sample_rate); sooshi_node_subscribe(state, sampling_depth, sample_config_update, s->sample_depth); g_signal_connect(s->trigger, "changed", G_CALLBACK(sample_config_changed), s); g_signal_connect(s->sample_rate, "changed", G_CALLBACK(sample_config_changed), s); g_signal_connect(s->sample_depth, "changed", G_CALLBACK(sample_config_changed), s); sooshi_node_choose(state, sooshi_node_find(state, "SAMPLING:TRIGGER:CONTINUOUS", NULL)); sooshi_node_choose(state, sooshi_node_find(state, "CH2:MAPPING:VOLTAGE", NULL)); sooshi_node_choose(state, sooshi_node_find(state, "CH2:ANALYSIS:MEAN", NULL)); sooshi_node_set_value(state, sooshi_node_find(state, "CH2:RANGE_I", NULL), g_variant_new_byte(0), TRUE); }
static int reverse_map(uint8_t u, const uint8_t *arr, int n) { GVariant *v = g_variant_new_byte(u); int i = find_in_array(v, G_VARIANT_TYPE_BYTE, arr, n); g_variant_unref(v); return i; }
GVariant *convertVariant(const QVariant &variant) { switch (variant.type()) { case QVariant::Bool: return g_variant_new_boolean(variant.toBool()); case QVariant::Char: return g_variant_new_byte(variant.toChar().toLatin1()); case QVariant::Int: return g_variant_new_int32(variant.toInt()); case QVariant::UInt: return g_variant_new_uint32(variant.toUInt()); case QVariant::LongLong: return g_variant_new_int64(variant.toLongLong()); case QVariant::ULongLong: return g_variant_new_uint64(variant.toULongLong()); case QVariant::Double: return g_variant_new_double(variant.toDouble()); case QVariant::String: return g_variant_new_string(variant.toString().toUtf8().constData()); case QVariant::StringList: { QStringList value = variant.toStringList(); GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("as")); foreach (QString item ,value) g_variant_builder_add(builder, "s", item.toUtf8().constData()); GVariant *result = g_variant_new("as", builder); g_variant_builder_unref(builder); return result; } case QVariant::ByteArray: return g_variant_new_bytestring(variant.toByteArray().constData()); case QVariant::Url: return g_variant_new_string(variant.toUrl().toString().toUtf8().constData()); case QVariant::Color: return g_variant_new_string(variant.toString().toUtf8().constData()); default: { #ifndef QT_NO_DATASTREAM QByteArray a; QDataStream s(&a, QIODevice::WriteOnly); s.setVersion(QDataStream::Qt_4_0); s << variant; return g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING, a.constData(), a.size(), TRUE, NULL, NULL); #else Q_ASSERT(!"QConfiguration: Cannot save custom types without QDataStream support"); #endif } } return 0; }
GVariant* _gba_to_gvariant(GByteArray *gba) { guint8 *b; size_t i, max; GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); for (b=gba->data,max=gba->len,i=0; i<max ;i++) g_variant_builder_add_value(builder, g_variant_new_byte(b[i])); GVariant *result = g_variant_builder_end(builder); g_variant_builder_unref(builder); return result; }
GVariant* _gb_to_gvariant(GBytes *gb) { gsize max; gconstpointer b = g_bytes_get_data(gb, &max); const guint8 *b8 = b; GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); for (gsize i=0; i<max ;i++) g_variant_builder_add_value(builder, g_variant_new_byte(b8[i])); GVariant *result = g_variant_builder_end(builder); g_variant_builder_unref(builder); return result; }
static void eog_application_add_platform_data (GApplication *application, GVariantBuilder *builder) { EogApplication *app = EOG_APPLICATION (application); G_APPLICATION_CLASS (eog_application_parent_class)->add_platform_data (application, builder); if (app->flags) { g_variant_builder_add (builder, "{sv}", "eog-application-startup-flags", g_variant_new_byte (app->flags)); } }
static GVariant * bytes_serialize(GvsSerializer *self, const GValue *value, gpointer unused) { gsize size, i; const guint8 *data; GVariantBuilder builder; data = g_bytes_get_data(g_value_get_boxed(value), &size); /* Hmmm, g_variant_new_bytestring for some reason wants the incoming * data to be nul-terminated, which of course a generic chunk of data * in the form of bytes might not be. So we have to manually go through * and create the byte array ourselves. */ g_variant_builder_init(&builder, G_VARIANT_TYPE_BYTESTRING); for (i = 0; i < size; i++) { g_variant_builder_add_value(&builder, g_variant_new_byte(data[i])); } return g_variant_builder_end(&builder); }
static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel *ch, const struct sr_channel_group *cg) { (void) cg; struct dev_context *const devc = sdi->priv; switch (id) { case SR_CONF_SAMPLERATE: *data = g_variant_new_uint64(devc->cur_samplerate); break; case SR_CONF_LIMIT_SAMPLES: *data = g_variant_new_uint64(devc->limit_samples_show); break; case SR_CONF_LIMIT_MSEC: *data = g_variant_new_uint64(devc->limit_msec); break; case SR_CONF_DEVICE_MODE: *data = g_variant_new_int16(sdi->mode); break; case SR_CONF_TEST: *data = g_variant_new_boolean(FALSE); break; case SR_CONF_INSTANT: *data = g_variant_new_boolean(devc->instant); break; case SR_CONF_PATTERN_MODE: *data = g_variant_new_string(pattern_strings[devc->sample_generator]); break; case SR_CONF_MAX_HEIGHT: *data = g_variant_new_string(maxHeights[devc->max_height]); break; case SR_CONF_MAX_HEIGHT_VALUE: *data = g_variant_new_byte(devc->max_height); break; case SR_CONF_VPOS: *data = g_variant_new_double(ch->vpos); break; case SR_CONF_VDIV: *data = g_variant_new_uint64(ch->vdiv); break; case SR_CONF_FACTOR: *data = g_variant_new_uint64(ch->vfactor); break; case SR_CONF_TIMEBASE: *data = g_variant_new_uint64(devc->timebase); break; case SR_CONF_COUPLING: *data = g_variant_new_byte(ch->coupling); break; case SR_CONF_TRIGGER_VALUE: *data = g_variant_new_byte(ch->trig_value); break; case SR_CONF_EN_CH: *data = g_variant_new_uint64(ch->enabled); break; case SR_CONF_DATALOCK: *data = g_variant_new_boolean(devc->data_lock); break; case SR_CONF_MAX_DSO_SAMPLERATE: *data = g_variant_new_uint64(DEMO_MAX_DSO_SAMPLERATE); break; case SR_CONF_MAX_DSO_SAMPLELIMITS: *data = g_variant_new_uint64(DEMO_MAX_DSO_DEPTH); break; case SR_CONF_MAX_LOGIC_SAMPLERATE: *data = g_variant_new_uint64(DEMO_MAX_LOGIC_SAMPLERATE); break; case SR_CONF_MAX_LOGIC_SAMPLELIMITS: *data = g_variant_new_uint64(DEMO_MAX_LOGIC_DEPTH); break; case SR_CONF_RLE_SAMPLELIMITS: *data = g_variant_new_uint64(DEMO_MAX_LOGIC_DEPTH); break; case SR_CONF_DSO_BITS: *data = g_variant_new_byte(devc->dso_bits); break; default: return SR_ERR_NA; } return SR_OK; }
GVariant * g_settings_set_mapping (const GValue *value, const GVariantType *expected_type, gpointer user_data) { gchar *type_string; if (G_VALUE_HOLDS_BOOLEAN (value)) { if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN)) return g_variant_new_boolean (g_value_get_boolean (value)); } else if (G_VALUE_HOLDS_CHAR (value) || G_VALUE_HOLDS_UCHAR (value)) { if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE)) { if (G_VALUE_HOLDS_CHAR (value)) return g_variant_new_byte (g_value_get_char (value)); else return g_variant_new_byte (g_value_get_uchar (value)); } } else if (G_VALUE_HOLDS_INT (value) || G_VALUE_HOLDS_INT64 (value)) return g_settings_set_mapping_int (value, expected_type); else if (G_VALUE_HOLDS_DOUBLE (value)) return g_settings_set_mapping_float (value, expected_type); else if (G_VALUE_HOLDS_UINT (value) || G_VALUE_HOLDS_UINT64 (value)) return g_settings_set_mapping_unsigned_int (value, expected_type); else if (G_VALUE_HOLDS_STRING (value)) { if (g_value_get_string (value) == NULL) return NULL; else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING)) return g_variant_new_string (g_value_get_string (value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTESTRING)) return g_variant_new_bytestring (g_value_get_string (value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH)) return g_variant_new_object_path (g_value_get_string (value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE)) return g_variant_new_signature (g_value_get_string (value)); } else if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { if (g_value_get_boxed (value) == NULL) return NULL; return g_variant_new_strv ((const gchar **) g_value_get_boxed (value), -1); } else if (G_VALUE_HOLDS_ENUM (value)) { GEnumValue *enumval; GEnumClass *eclass; /* GParamSpecEnum holds a ref on the class so we just peek... */ eclass = g_type_class_peek (G_VALUE_TYPE (value)); enumval = g_enum_get_value (eclass, g_value_get_enum (value)); if (enumval) return g_variant_new_string (enumval->value_nick); else return NULL; } else if (G_VALUE_HOLDS_FLAGS (value)) { GVariantBuilder builder; GFlagsValue *flagsval; GFlagsClass *fclass; guint flags; fclass = g_type_class_peek (G_VALUE_TYPE (value)); flags = g_value_get_flags (value); g_variant_builder_init (&builder, G_VARIANT_TYPE ("as")); while (flags) { flagsval = g_flags_get_first_value (fclass, flags); if (flagsval == NULL) { g_variant_builder_clear (&builder); return NULL; } g_variant_builder_add (&builder, "s", flagsval->value_nick); flags &= ~flagsval->value; } return g_variant_builder_end (&builder); } type_string = g_variant_type_dup_string (expected_type); g_critical ("No GSettings bind handler for type \"%s\".", type_string); g_free (type_string); return NULL; }
static GVariant * dconf_dbus_to_gv (DBusMessageIter *iter, GError **error) { gint arg_type; arg_type = dbus_message_iter_get_arg_type (iter); switch (dbus_message_iter_get_arg_type (iter)) { case DBUS_TYPE_BOOLEAN: { dbus_bool_t value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_boolean (value); } case DBUS_TYPE_BYTE: { guchar value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_byte (value); } case DBUS_TYPE_INT16: { gint16 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_int16 (value); } case DBUS_TYPE_UINT16: { guint16 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_uint16 (value); } case DBUS_TYPE_INT32: { gint32 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_int32 (value); } case DBUS_TYPE_UINT32: { guint32 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_uint32 (value); } case DBUS_TYPE_INT64: { gint64 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_int64 (value); } case DBUS_TYPE_UINT64: { guint64 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_uint64 (value); } case DBUS_TYPE_DOUBLE: { gdouble value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_double (value); } case DBUS_TYPE_STRING: { const gchar *value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_string (value); } case DBUS_TYPE_OBJECT_PATH: { const gchar *value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_object_path (value); } case DBUS_TYPE_SIGNATURE: { const gchar *value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_signature (value); } case DBUS_TYPE_VARIANT: { GVariantBuilder *builder; GVariantClass class; DBusMessageIter sub; char *type; GVariant *val; dbus_message_iter_recurse (iter, &sub); class = dbus_message_iter_get_arg_type (iter); type = dbus_message_iter_get_signature (&sub); builder = g_variant_builder_new (G_VARIANT_TYPE_VARIANT); dbus_free (type); while (dbus_message_iter_get_arg_type (&sub)) { val = dconf_dbus_to_gv (&sub, error); if (val == NULL) { g_variant_builder_cancel (builder); goto fail; } g_variant_builder_add_value (builder, val); dbus_message_iter_next (&sub); } return g_variant_builder_end (builder); } case DBUS_TYPE_ARRAY: case DBUS_TYPE_STRUCT: case DBUS_TYPE_DICT_ENTRY: { GVariantBuilder *builder; GVariantClass class; DBusMessageIter sub; char *type; GVariant *val; dbus_message_iter_recurse (iter, &sub); class = dbus_message_iter_get_arg_type (iter); type = dbus_message_iter_get_signature (iter); builder = g_variant_builder_new (G_VARIANT_TYPE (type)); dbus_free (type); while (dbus_message_iter_get_arg_type (&sub)) { val = dconf_dbus_to_gv (&sub, error); if (val == NULL) { g_variant_builder_cancel (builder); goto fail; } g_variant_builder_add_value (builder, val); dbus_message_iter_next (&sub); } return g_variant_builder_end (builder); } default: g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_CONVERSION_FAILED, _("Error serializing D-Bus message to GVariant. Unsupported arg type `%c' (%d)"), arg_type, arg_type); goto fail; } g_assert_not_reached (); fail: return NULL; }
Variant::Variant(unsigned char value) : Variant(g_variant_new_byte(value)) {}
static GVariant * gconf_settings_backend_simple_gconf_value_type_to_gvariant (GConfValue *gconf_value, const GVariantType *expected_type) { /* Note: it's guaranteed that the types are compatible */ GVariant *variant = NULL; if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN)) variant = g_variant_new_boolean (gconf_value_get_bool (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE)) { int value = gconf_value_get_int (gconf_value); if (value < 0 || value > 255) return NULL; variant = g_variant_new_byte (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16)) { int value = gconf_value_get_int (gconf_value); if (value < G_MINSHORT || value > G_MAXSHORT) return NULL; variant = g_variant_new_int16 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16)) { int value = gconf_value_get_int (gconf_value); if (value < 0 || value > G_MAXUSHORT) return NULL; variant = g_variant_new_uint16 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32)) variant = g_variant_new_int32 (gconf_value_get_int (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32)) { int value = gconf_value_get_int (gconf_value); if (value < 0) return NULL; variant = g_variant_new_uint32 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64)) variant = g_variant_new_int64 ((gint64) gconf_value_get_int (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64)) { int value = gconf_value_get_int (gconf_value); if (value < 0) return NULL; variant = g_variant_new_uint64 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE)) { int value = gconf_value_get_int (gconf_value); if (value < 0) return NULL; variant = g_variant_new_handle (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE)) variant = g_variant_new_double (gconf_value_get_float (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING)) variant = g_variant_new_string (gconf_value_get_string (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH)) variant = g_variant_new_object_path (gconf_value_get_string (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE)) variant = g_variant_new_signature (gconf_value_get_string (gconf_value)); return variant; }
static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel *ch, const struct sr_channel_group *cg) { struct session_vdev *vdev; switch (id) { case SR_CONF_SAMPLERATE: if (sdi) { vdev = sdi->priv; *data = g_variant_new_uint64(vdev->samplerate); } else return SR_ERR; break; case SR_CONF_LIMIT_SAMPLES: if (sdi) { vdev = sdi->priv; *data = g_variant_new_uint64(vdev->total_samples); } else return SR_ERR; break; case SR_CONF_TIMEBASE: if (sdi) { vdev = sdi->priv; *data = g_variant_new_uint64(vdev->timebase); } else return SR_ERR; break; case SR_CONF_EN_CH: if (sdi && ch) { *data = g_variant_new_boolean(ch->enabled); } else return SR_ERR; break; case SR_CONF_COUPLING: if (sdi && ch) { *data = g_variant_new_byte(ch->coupling); } else return SR_ERR; break; case SR_CONF_VDIV: if (sdi && ch) { *data = g_variant_new_uint64(ch->vdiv); } else return SR_ERR; break; case SR_CONF_FACTOR: if (sdi && ch) { *data = g_variant_new_uint64(ch->vfactor); } else return SR_ERR; break; case SR_CONF_VPOS: if (sdi && ch) { *data = g_variant_new_double(ch->vpos); } else return SR_ERR; break; case SR_CONF_MAX_DSO_SAMPLERATE: if (!sdi) return SR_ERR; *data = g_variant_new_uint64(vdev->samplerate); break; case SR_CONF_MAX_DSO_SAMPLELIMITS: if (!sdi) return SR_ERR; *data = g_variant_new_uint64(vdev->total_samples); break; default: return SR_ERR_ARG; } return SR_OK; }
/** * Load the session from the specified filename. * * @param filename The name of the session file to load. Must not be NULL. * * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, * SR_ERR_MALLOC upon memory allocation errors, or SR_ERR upon * other errors. */ SR_API int sr_session_load(const char *filename) { GKeyFile *kf; GPtrArray *capturefiles; struct zip *archive; struct zip_file *zf; struct zip_stat zs; struct sr_dev_inst *sdi; struct sr_channel *probe; int ret, devcnt, i, j, k; uint16_t probenum; uint64_t tmp_u64, total_probes, enabled_probes; uint16_t p; char **sections, **keys, *metafile, *val, s[11]; char probename[SR_MAX_PROBENAME_LEN + 1]; int mode = LOGIC; int channel_type = SR_CHANNEL_LOGIC; double tmp_double; if (!filename) { sr_err("%s: filename was NULL", __func__); return SR_ERR_ARG; } if (!(archive = zip_open(filename, 0, &ret))) { sr_dbg("Failed to open session file: zip error %d", ret); return SR_ERR; } /* read "metadata" */ if (zip_stat(archive, "header", 0, &zs) == -1) { sr_dbg("Not a valid DSView data file."); return SR_ERR; } if (!(metafile = g_try_malloc(zs.size))) { sr_err("%s: metafile malloc failed", __func__); return SR_ERR_MALLOC; } zf = zip_fopen_index(archive, zs.index, 0); zip_fread(zf, metafile, zs.size); zip_fclose(zf); kf = g_key_file_new(); if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) { sr_dbg("Failed to parse metadata."); return SR_ERR; } sr_session_new(); devcnt = 0; capturefiles = g_ptr_array_new_with_free_func(g_free); sections = g_key_file_get_groups(kf, NULL); for (i = 0; sections[i]; i++) { if (!strcmp(sections[i], "version")) /* nothing really interesting in here yet */ continue; if (!strncmp(sections[i], "header", 6)) { /* device section */ sdi = NULL; enabled_probes = total_probes = 0; keys = g_key_file_get_keys(kf, sections[i], NULL, NULL); for (j = 0; keys[j]; j++) { val = g_key_file_get_string(kf, sections[i], keys[j], NULL); if (!strcmp(keys[j], "device mode")) { mode = strtoull(val, NULL, 10); } else if (!strcmp(keys[j], "capturefile")) { sdi = sr_dev_inst_new(mode, devcnt, SR_ST_ACTIVE, NULL, NULL, NULL); sdi->driver = &session_driver; if (devcnt == 0) /* first device, init the driver */ sdi->driver->init(NULL); sr_dev_open(sdi); sr_session_dev_add(sdi); sdi->driver->config_set(SR_CONF_SESSIONFILE, g_variant_new_bytestring(filename), sdi, NULL, NULL); sdi->driver->config_set(SR_CONF_CAPTUREFILE, g_variant_new_bytestring(val), sdi, NULL, NULL); g_ptr_array_add(capturefiles, val); } else if (!strcmp(keys[j], "samplerate")) { sr_parse_sizestring(val, &tmp_u64); sdi->driver->config_set(SR_CONF_SAMPLERATE, g_variant_new_uint64(tmp_u64), sdi, NULL, NULL); } else if (!strcmp(keys[j], "unitsize")) { tmp_u64 = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE, g_variant_new_uint64(tmp_u64), sdi, NULL, NULL); } else if (!strcmp(keys[j], "total samples")) { tmp_u64 = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_LIMIT_SAMPLES, g_variant_new_uint64(tmp_u64), sdi, NULL, NULL); } else if (!strcmp(keys[j], "hDiv")) { tmp_u64 = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_TIMEBASE, g_variant_new_uint64(tmp_u64), sdi, NULL, NULL); } else if (!strcmp(keys[j], "total probes")) { total_probes = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES, g_variant_new_uint64(total_probes), sdi, NULL, NULL); channel_type = (mode == DSO) ? SR_CHANNEL_DSO : (mode == ANALOG) ? SR_CHANNEL_ANALOG : SR_CHANNEL_LOGIC; for (p = 0; p < total_probes; p++) { snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p); if (!(probe = sr_channel_new(p, channel_type, FALSE, probename))) return SR_ERR; sdi->channels = g_slist_append(sdi->channels, probe); } } else if (!strncmp(keys[j], "probe", 5)) { if (!sdi) continue; enabled_probes++; tmp_u64 = strtoul(keys[j]+5, NULL, 10); /* sr_session_save() */ sr_dev_probe_name_set(sdi, tmp_u64, val); sr_dev_probe_enable(sdi, tmp_u64, TRUE); } else if (!strncmp(keys[j], "trigger", 7)) { probenum = strtoul(keys[j]+7, NULL, 10); sr_dev_trigger_set(sdi, probenum, val); } else if (!strncmp(keys[j], "enable", 6)) { probenum = strtoul(keys[j]+6, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_EN_CH, g_variant_new_boolean(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "coupling", 8)) { probenum = strtoul(keys[j]+8, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_COUPLING, g_variant_new_byte(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "vDiv", 4)) { probenum = strtoul(keys[j]+4, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_VDIV, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "vFactor", 7)) { probenum = strtoul(keys[j]+7, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_FACTOR, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "vPos", 4)) { probenum = strtoul(keys[j]+4, NULL, 10); tmp_double = strtod(val, NULL); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_VPOS, g_variant_new_double(tmp_double), sdi, probe, NULL); } } else if (!strncmp(keys[j], "period", 6)) { probenum = strtoul(keys[j]+6, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_STATUS_PERIOD, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "pcnt", 4)) { probenum = strtoul(keys[j]+4, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_STATUS_PCNT, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "max", 3)) { probenum = strtoul(keys[j]+3, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_STATUS_MAX, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "min", 3)) { probenum = strtoul(keys[j]+3, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_STATUS_MIN, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } } g_strfreev(keys); } devcnt++; } g_strfreev(sections); g_key_file_free(kf); return SR_OK; }
/** * g_dbus_gvalue_to_gvariant: * @gvalue: A #GValue to convert to a #GVariant * @type: A #GVariantType * * Converts a #GValue to a #GVariant of the type indicated by the @type * parameter. * * The conversion is using the following rules: * * - #G_TYPE_STRING: 's', 'o', 'g' or 'ay' * - #G_TYPE_STRV: 'as', 'ao' or 'aay' * - #G_TYPE_BOOLEAN: 'b' * - #G_TYPE_UCHAR: 'y' * - #G_TYPE_INT: 'i', 'n' * - #G_TYPE_UINT: 'u', 'q' * - #G_TYPE_INT64 'x' * - #G_TYPE_UINT64: 't' * - #G_TYPE_DOUBLE: 'd' * - #G_TYPE_VARIANT: Any #GVariantType * * This can fail if e.g. @gvalue is of type #G_TYPE_STRING and @type * is ['i'][G-VARIANT-TYPE-INT32:CAPS]. It will also fail for any #GType * (including e.g. #G_TYPE_OBJECT and #G_TYPE_BOXED derived-types) not * in the table above. * * Note that if @gvalue is of type #G_TYPE_VARIANT and its value is * %NULL, the empty #GVariant instance (never %NULL) for @type is * returned (e.g. 0 for scalar types, the empty string for string types, * '/' for object path types, the empty array for any array type and so on). * * See the g_dbus_gvariant_to_gvalue() function for how to convert a * #GVariant to a #GValue. * * Returns: A #GVariant (never floating) of #GVariantType @type holding * the data from @gvalue or %NULL in case of failure. Free with * g_variant_unref(). * * Since: 2.30 */ GVariant * g_dbus_gvalue_to_gvariant (const GValue *gvalue, const GVariantType *type) { GVariant *ret; const gchar *s; const gchar * const *as; const gchar *empty_strv[1] = {NULL}; g_return_val_if_fail (gvalue != NULL, NULL); g_return_val_if_fail (type != NULL, NULL); ret = NULL; /* @type can easily be e.g. "s" with the GValue holding a GVariant - for example this * can happen when using the org.gtk.GDBus.C.ForceGVariant annotation with the * gdbus-codegen(1) tool. */ if (G_VALUE_TYPE (gvalue) == G_TYPE_VARIANT) { ret = g_value_dup_variant (gvalue); } else { switch (g_variant_type_peek_string (type)[0]) { case G_VARIANT_CLASS_BOOLEAN: ret = g_variant_ref_sink (g_variant_new_boolean (g_value_get_boolean (gvalue))); break; case G_VARIANT_CLASS_BYTE: ret = g_variant_ref_sink (g_variant_new_byte (g_value_get_uchar (gvalue))); break; case G_VARIANT_CLASS_INT16: ret = g_variant_ref_sink (g_variant_new_int16 (g_value_get_int (gvalue))); break; case G_VARIANT_CLASS_UINT16: ret = g_variant_ref_sink (g_variant_new_uint16 (g_value_get_uint (gvalue))); break; case G_VARIANT_CLASS_INT32: ret = g_variant_ref_sink (g_variant_new_int32 (g_value_get_int (gvalue))); break; case G_VARIANT_CLASS_UINT32: ret = g_variant_ref_sink (g_variant_new_uint32 (g_value_get_uint (gvalue))); break; case G_VARIANT_CLASS_INT64: ret = g_variant_ref_sink (g_variant_new_int64 (g_value_get_int64 (gvalue))); break; case G_VARIANT_CLASS_UINT64: ret = g_variant_ref_sink (g_variant_new_uint64 (g_value_get_uint64 (gvalue))); break; case G_VARIANT_CLASS_DOUBLE: ret = g_variant_ref_sink (g_variant_new_double (g_value_get_double (gvalue))); break; case G_VARIANT_CLASS_STRING: s = g_value_get_string (gvalue); if (s == NULL) s = ""; ret = g_variant_ref_sink (g_variant_new_string (s)); break; case G_VARIANT_CLASS_OBJECT_PATH: s = g_value_get_string (gvalue); if (s == NULL) s = "/"; ret = g_variant_ref_sink (g_variant_new_object_path (s)); break; case G_VARIANT_CLASS_SIGNATURE: s = g_value_get_string (gvalue); if (s == NULL) s = ""; ret = g_variant_ref_sink (g_variant_new_signature (s)); break; case G_VARIANT_CLASS_ARRAY: switch (g_variant_type_peek_string (type)[1]) { case G_VARIANT_CLASS_BYTE: s = g_value_get_string (gvalue); if (s == NULL) s = ""; ret = g_variant_ref_sink (g_variant_new_bytestring (s)); break; case G_VARIANT_CLASS_STRING: as = g_value_get_boxed (gvalue); if (as == NULL) as = empty_strv; ret = g_variant_ref_sink (g_variant_new_strv (as, -1)); break; case G_VARIANT_CLASS_OBJECT_PATH: as = g_value_get_boxed (gvalue); if (as == NULL) as = empty_strv; ret = g_variant_ref_sink (g_variant_new_objv (as, -1)); break; case G_VARIANT_CLASS_ARRAY: switch (g_variant_type_peek_string (type)[2]) { case G_VARIANT_CLASS_BYTE: as = g_value_get_boxed (gvalue); if (as == NULL) as = empty_strv; ret = g_variant_ref_sink (g_variant_new_bytestring_array (as, -1)); break; default: ret = g_value_dup_variant (gvalue); break; } break; default: ret = g_value_dup_variant (gvalue); break; } break; case G_VARIANT_CLASS_HANDLE: case G_VARIANT_CLASS_VARIANT: case G_VARIANT_CLASS_MAYBE: case G_VARIANT_CLASS_TUPLE: case G_VARIANT_CLASS_DICT_ENTRY: ret = g_value_dup_variant (gvalue); break; } } /* Could be that the GValue is holding a NULL GVariant - in that case, * we return an "empty" GVariant instead of a NULL GVariant */ if (ret == NULL) { GVariant *untrusted_empty; untrusted_empty = g_variant_new_from_data (type, NULL, 0, FALSE, NULL, NULL); ret = g_variant_ref_sink (g_variant_get_normal_form (untrusted_empty)); g_variant_unref (untrusted_empty); } g_assert (!g_variant_is_floating (ret)); return ret; }
GVariant* js_to_dbus(JSContextRef ctx, const JSValueRef jsvalue, const GVariantType* sig, JSValueRef *exception) { if (g_variant_type_is_array(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); if (g_variant_type_is_dict_entry(child_sig)) { const GVariantType* key_sig = g_variant_type_first(child_sig); const GVariantType* value_sig = g_variant_type_next(key_sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_function_child(ctx, jsvalue, i)) continue; g_variant_builder_open(&builder, child_sig); JSValueRef key = JSValueMakeString(ctx, JSPropertyNameArrayGetNameAtIndex(array, i)); JSValueRef value = JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL); g_variant_builder_add_value(&builder, js_to_dbus(ctx, key, key_sig, exception)); g_variant_builder_add_value(&builder, js_to_dbus(ctx, value, value_sig, exception)); g_variant_builder_close(&builder); } return g_variant_builder_end(&builder); } else { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) continue; g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), child_sig, exception)); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } } else if (g_variant_type_is_tuple(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* current_sig = g_variant_type_first(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) continue; g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), current_sig, exception)); current_sig = g_variant_type_next(current_sig); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } else { switch (g_variant_type_peek_string(sig)[0]) { case 'y': return g_variant_new_byte(JSValueToNumber(ctx, jsvalue, exception)); case 'n': return g_variant_new_int16(JSValueToNumber(ctx, jsvalue, exception)); case 'q': return g_variant_new_uint16(JSValueToNumber(ctx, jsvalue, exception)); case 'i': return g_variant_new_int32(JSValueToNumber(ctx, jsvalue, exception)); case 'u': return g_variant_new_uint32(JSValueToNumber(ctx, jsvalue, exception)); case 'x': return g_variant_new_int64(JSValueToNumber(ctx, jsvalue, exception)); case 't': return g_variant_new_uint64(JSValueToNumber(ctx, jsvalue, exception)); case 'd': return g_variant_new_double(JSValueToNumber(ctx, jsvalue, exception)); case 'h': return g_variant_new_handle(JSValueToNumber(ctx, jsvalue, exception)); case 'b': return g_variant_new_boolean(JSValueToBoolean(ctx, jsvalue)); case 's': { char* v = jsvalue_to_cstr(ctx, jsvalue); GVariant* r = g_variant_new_string(v); g_free(v); return r; } case 'v': { //TODO: /*g_variant_new_variant()*/ g_assert_not_reached(); } } } g_assert_not_reached(); }
static GVariant * parse_json (JsonNode *node, const GVariantType *type, GError **error) { const GVariantType *element_type; const gchar *str; if (!g_variant_type_is_definite (type)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Indefinite type '%.*s' is not supported", (int)g_variant_type_get_string_length (type), g_variant_type_peek_string (type)); return NULL; } if (g_variant_type_is_basic (type)) { if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_BOOLEAN, error)) return g_variant_new_boolean (json_node_get_boolean (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_byte (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_int16 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_uint16 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_int32 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_uint32 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_int64 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_uint64 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, NULL)) return g_variant_new_double (json_node_get_int (node)); else if (check_type (node, JSON_NODE_VALUE, G_TYPE_DOUBLE, error)) return g_variant_new_double (json_node_get_double (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error)) return g_variant_new_string (json_node_get_string (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error)) { str = json_node_get_string (node); if (g_variant_is_object_path (str)) return g_variant_new_object_path (str); else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Invalid object path '%s'", str); return NULL; } } } else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error)) { str = json_node_get_string (node); if (g_variant_is_signature (str)) return g_variant_new_signature (str); else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Invalid signature '%s'", str); return NULL; } } } else { parse_not_supported (type, error); } } else if (g_variant_type_is_variant (type)) { return parse_json_variant (node, error); } else if (g_variant_type_is_array (type)) { element_type = g_variant_type_element (type); if (g_variant_type_is_dict_entry (element_type)) return parse_json_dictionary (node, element_type, error); else return parse_json_array (node, element_type, error); } else if (g_variant_type_is_tuple (type)) { return parse_json_tuple (node, g_variant_type_first (type), error); } else { parse_not_supported (type, error); } return NULL; }