guint
asCFlag(USER_OBJECT_ s_flag, GType ftype)
{
GFlagsClass* fclass = g_type_class_ref(ftype);
guint flags = 0;
if (IS_INTEGER(s_flag) || IS_NUMERIC(s_flag)) {
if (asCNumeric(s_flag) > fclass->mask) {
PROBLEM "The flags value %f is too high", asCNumeric(s_flag)
ERROR;
}
flags = asCNumeric(s_flag);
} else {
int i;
for (i = 0; i < GET_LENGTH(s_flag); i++) {
const gchar *fname = CHAR_DEREF(STRING_ELT(s_flag, i));
/*Rprintf("Searching for flag value %s\n", fname);*/
GFlagsValue *fvalue = g_flags_get_value_by_name(fclass, fname);
if (!fvalue)
fvalue = g_flags_get_value_by_nick(fclass, fname);
if (!fvalue && atoi(fname) <= fclass->mask) {
flags |= atoi(fname);
continue;
}
if (!fvalue) {
PROBLEM "Could not find flag by name %s", fname
ERROR;
}
/*Rprintf("Found: %d\n", fvalue->value);*/
flags |= fvalue->value;
}
}
return(flags);
}
guint
ephy_string_flags_from_string (GType type,
const char *flags_string)
{
GFlagsClass *flags_class;
const GFlagsValue *value;
gchar **flags;
guint retval = 0, i;
g_return_val_if_fail (flags_string != NULL, 0);
flags = g_strsplit (flags_string, "|", -1);
if (!flags) return 0;
flags_class = g_type_class_ref (type);
for (i = 0; flags[i] != NULL; ++i)
{
value = g_flags_get_value_by_nick (flags_class, flags[i]);
if (value != NULL)
{
retval |= value->value;
}
}
g_type_class_unref (flags_class);
return retval;
}
static guint
parse_flags(GType type,
const char *string)
{
GFlagsClass *flags_klass;
guint value = 0;
char **flags;
guint i;
flags = g_strsplit_set(string, ",|", -1);
if (flags == NULL)
return 0;
flags_klass = (GFlagsClass*)g_type_class_ref(type);
for (i = 0; flags[i] != NULL; ++i) {
const GFlagsValue *flags_value;
flags_value = g_flags_get_value_by_nick(flags_klass, flags[i]);
if (flags_value)
value |= flags_value->value;
else
g_warning("Unknown flag '%s'\n", flags[i]);
}
g_type_class_unref(flags_klass);
return value;
}
unsigned getGstPlayFlag(const char* nick)
{
static GFlagsClass* flagsClass = static_cast<GFlagsClass*>(g_type_class_ref(g_type_from_name("GstPlayFlags")));
ASSERT(flagsClass);
GFlagsValue* flag = g_flags_get_value_by_nick(flagsClass, nick);
if (!flag)
return 0;
return flag->value;
}
/* Flags can contain multiple values. We assume here that values are like
* C identifiers (that is, they match /[A-Za-z_][A-Za-z0-9_]+/), although
* that doesn't seem to be a requirement of GLib. With that assumption in
* mind, we look for the format "FLAG_1 | FLAG_2 | ... | FLAG_N". */
static gboolean g_value_set_flags_from_string(GValue * val, char * string) {
guint value = 0;
char * strtok_saveptr;
char * string_copy;
char * strtok_first_arg;
const char delim[] = " \t,|";
GFlagsClass * flags_class;
flags_class = (GFlagsClass*) g_type_class_ref(G_VALUE_TYPE(val));
g_return_val_if_fail(flags_class != NULL, FALSE);
g_return_val_if_fail(G_IS_FLAGS_CLASS(flags_class), FALSE);
/* Don't let strtok stop on original. */
strtok_first_arg = string_copy = strdup(string);
for (;;) {
GFlagsValue * flag_value;
char * token = strtok_r(strtok_first_arg, delim, &strtok_saveptr);
strtok_first_arg = NULL;
if (token == NULL) {
break;
}
flag_value = g_flags_get_value_by_name(flags_class, token);
if (flag_value == NULL) {
flag_value = g_flags_get_value_by_nick(flags_class, token);
}
if (flag_value == NULL) {
g_fprintf(stderr, _("Invalid flag %s for type %s\n"), token,
g_type_name(G_VALUE_TYPE(val)));
continue;
}
value |= flag_value->value;
}
amfree(string_copy);
if (value == 0) {
g_fprintf(stderr, _("No valid flags for type %s in string %s\n"),
g_type_name(G_VALUE_TYPE(val)), string);
return FALSE;
}
g_value_set_flags(val, value);
return TRUE;
}
static void _xfdashboard_gvalue_transform_string_flags(const GValue *inSourceValue, GValue *ioDestValue)
{
GFlagsClass *flagsClass;
GFlagsValue *flagsValue;
guint finalValue;
gchar **values, **entry;
/* Reference flags class to keep it alive for transformation */
flagsClass=g_type_class_ref(G_VALUE_TYPE(ioDestValue));
/* Split string into space-separated needles and lookup each needle
* for a match and add found values OR'ed to final value
*/
finalValue=0;
entry=values=g_strsplit(inSourceValue->data[0].v_pointer, " ", 0);
while(*entry)
{
/* Do not look-up empty values */
if(!entry[0]) continue;
/* Get flags value either by name or by nickname (whatever matches first) */
flagsValue=g_flags_get_value_by_name(flagsClass, *entry);
if(!flagsValue) flagsValue=g_flags_get_value_by_nick(flagsClass, *entry);
/* Add value OR'ed if flags could be found */
if(flagsValue) finalValue|=flagsValue->value;
else
{
XFDASHBOARD_DEBUG(NULL, MISC,
"Cannot get value for unknown flag '%s' for type %s",
*entry,
g_type_name(G_VALUE_TYPE(ioDestValue)));
}
/* Continue with next entry */
entry++;
}
g_strfreev(values);
/* Set value */
ioDestValue->data[0].v_uint=finalValue;
/* Release allocated resources */
g_type_class_unref(flagsClass);
}
static gboolean
flags_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
{
GFlagsClass *flags_class;
GFlagsValue *flag_value;
guint flags = 0;
char *str;
flags_class = g_type_class_ref (G_VALUE_TYPE (value));
do {
str = _gtk_css_parser_try_ident (parser, TRUE);
if (str == NULL)
{
_gtk_css_parser_error (parser, "Expected an identifier");
g_type_class_unref (flags_class);
return FALSE;
}
flag_value = g_flags_get_value_by_nick (flags_class, str);
if (!flag_value)
{
_gtk_css_parser_error (parser,
"Unknown flag value '%s' for type '%s'",
str, g_type_name (G_VALUE_TYPE (value)));
/* XXX Do we want to return FALSE here? We can get
* forward-compatibility for new values this way
*/
g_free (str);
g_type_class_unref (flags_class);
return FALSE;
}
g_free (str);
}
while (_gtk_css_parser_try (parser, ",", FALSE));
g_type_class_unref (flags_class);
g_value_set_enum (value, flags);
return TRUE;
}
DasomKey *
dasom_key_new_from_nicks (const gchar **nicks)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
DasomKey *key = g_slice_new0 (DasomKey);
GEnumValue *enum_value; /* Do not free */
GFlagsValue *flags_value; /* Do not free */
GFlagsClass *flags_class = g_type_class_ref (DASOM_TYPE_MODIFIER_TYPE);
GEnumClass *enum_class = g_type_class_ref (DASOM_TYPE_KEY_SYM);
gint i;
for (i = 0; nicks[i] != NULL; i++)
{
if (g_str_has_suffix (nicks[i], "mask"))
{
flags_value = g_flags_get_value_by_nick (flags_class, nicks[i]);
if (flags_value)
key->mods |= flags_value->value;
else
g_warning ("DasomModifierType doesn't have a member with that nickname: %s", nicks[i]);
}
else
{
enum_value = g_enum_get_value_by_nick (enum_class, nicks[i]);
if (enum_value)
key->keyval = enum_value->value;
else
g_warning ("DasomKeySym doesn't have a member with that nickname: %s", nicks[i]);
}
}
g_type_class_unref (flags_class);
g_type_class_unref (enum_class);
return key;
}
int main(int argc, char **argv) {
GEnumClass *xenum = g_type_class_ref(MESON_TYPE_THE_XENUM);
GFlagsClass *flags_enum = g_type_class_ref(MESON_TYPE_THE_FLAGS_ENUM);
if (g_enum_get_value_by_name(xenum, "MESON_THE_XVALUE")->value != MESON_THE_XVALUE) {
fprintf(stderr, "Get MESON_THE_XVALUE by name failed.\n");
return 1;
}
if (g_enum_get_value_by_nick(xenum, "the-xvalue")->value != MESON_THE_XVALUE) {
fprintf(stderr, "Get MESON_THE_XVALUE by nick failed.\n");
return 2;
}
if (g_flags_get_value_by_name(flags_enum, "MESON_THE_FIRST_VALUE")->value != MESON_THE_FIRST_VALUE) {
fprintf(stderr, "Get MESON_THE_FIRST_VALUE by name failed.\n");
return 3;
}
if (g_flags_get_value_by_nick(flags_enum, "the-first-value")->value != MESON_THE_FIRST_VALUE) {
fprintf(stderr, "Get MESON_THE_FIRST_VALUE by nick failed.\n");
return 4;
}
g_type_class_unref(xenum);
g_type_class_unref(flags_enum);
fprintf(stderr, "All ok.\n");
return 0;
}
gboolean
qmicli_read_rat_mode_pref_from_string (const gchar *str,
QmiNasRatModePreference *out)
{
GType type;
GFlagsClass *flags_class;
GFlagsValue *flags_value;
gboolean success = TRUE, set = FALSE;
char **items, **iter;
type = qmi_nas_rat_mode_preference_get_type ();
flags_class = G_FLAGS_CLASS (g_type_class_ref (type));
items = g_strsplit_set (str, "|", 0);
for (iter = items; iter && *iter && success; iter++) {
if (!*iter[0])
continue;
flags_value = g_flags_get_value_by_nick (flags_class, *iter);
if (flags_value) {
*out |= (QmiNasRatModePreference)flags_value->value;
set = TRUE;
} else {
g_printerr ("error: invalid rat mode pref value given: '%s'\n", *iter);
success = FALSE;
}
}
if (!set)
g_printerr ("error: invalid rat mode pref input given: '%s'\n", str);
if (items)
g_strfreev (items);
g_type_class_unref (flags_class);
return success && set;
}
static gboolean
flags_from_string (GType type,
const gchar *string,
gint *flags_value)
{
GFlagsClass *fclass;
gchar *endptr, *prevptr;
guint i, j, ret, value;
gchar *flagstr;
GFlagsValue *fv;
const gchar *flag;
gunichar ch;
gboolean eos;
g_return_val_if_fail (G_TYPE_IS_FLAGS (type), 0);
g_return_val_if_fail (string != 0, 0);
ret = TRUE;
value = strtoul (string, &endptr, 0);
if (endptr != string) /* parsed a number */
*flags_value = value;
else
{
fclass = g_type_class_ref (type);
flagstr = g_strdup (string);
for (value = i = j = 0; ; i++)
{
eos = flagstr[i] == '\0';
if (!eos && flagstr[i] != '|')
continue;
flag = &flagstr[j];
endptr = &flagstr[i];
if (!eos)
{
flagstr[i++] = '\0';
j = i;
}
/* trim spaces */
for (;;)
{
ch = g_utf8_get_char (flag);
if (!g_unichar_isspace (ch))
break;
flag = g_utf8_next_char (flag);
}
while (endptr > flag)
{
prevptr = g_utf8_prev_char (endptr);
ch = g_utf8_get_char (prevptr);
if (!g_unichar_isspace (ch))
break;
endptr = prevptr;
}
if (endptr > flag)
{
*endptr = '\0';
fv = g_flags_get_value_by_name (fclass, flag);
if (!fv)
fv = g_flags_get_value_by_nick (fclass, flag);
if (fv)
value |= fv->value;
else
{
ret = FALSE;
break;
}
}
if (eos)
{
*flags_value = value;
break;
}
}
g_free (flagstr);
g_type_class_unref (fclass);
}
return ret;
}
/**
* pyg_flags_get_value:
* @flag_type: the GType of the flag.
* @obj: a Python object representing the flag value
* @val: a pointer to the location to store the integer representation of the flag.
*
* Converts a Python object to the integer equivalent. The conversion
* will depend on the type of the Python object. If the object is an
* integer, it is passed through directly. If it is a string, it will
* be treated as a full or short flag name as defined in the GType.
* If it is a tuple, then the items are treated as strings and ORed
* together.
*
* Returns: 0 on success or -1 on failure
*/
gint
pyg_flags_get_value(GType flag_type, PyObject *obj, guint *val)
{
GFlagsClass *fclass = NULL;
gint res = -1;
g_return_val_if_fail(val != NULL, -1);
if (!obj) {
*val = 0;
res = 0;
} else if (PYGLIB_PyLong_Check(obj)) {
*val = PYGLIB_PyLong_AsUnsignedLong(obj);
res = 0;
} else if (PyLong_Check(obj)) {
*val = PyLong_AsLongLong(obj);
res = 0;
} else if (PYGLIB_PyUnicode_Check(obj)) {
GFlagsValue *info;
char *str = PYGLIB_PyUnicode_AsString(obj);
if (flag_type != G_TYPE_NONE)
fclass = G_FLAGS_CLASS(g_type_class_ref(flag_type));
else {
PyErr_SetString(PyExc_TypeError, "could not convert string to flag because there is no GType associated to look up the value");
res = -1;
}
info = g_flags_get_value_by_name(fclass, str);
g_type_class_unref(fclass);
if (!info)
info = g_flags_get_value_by_nick(fclass, str);
if (info) {
*val = info->value;
res = 0;
} else {
PyErr_SetString(PyExc_TypeError, "could not convert string");
res = -1;
}
} else if (PyTuple_Check(obj)) {
int i, len;
len = PyTuple_Size(obj);
*val = 0;
res = 0;
if (flag_type != G_TYPE_NONE)
fclass = G_FLAGS_CLASS(g_type_class_ref(flag_type));
else {
PyErr_SetString(PyExc_TypeError, "could not convert string to flag because there is no GType associated to look up the value");
res = -1;
}
for (i = 0; i < len; i++) {
PyObject *item = PyTuple_GetItem(obj, i);
char *str = PYGLIB_PyUnicode_AsString(item);
GFlagsValue *info = g_flags_get_value_by_name(fclass, str);
if (!info)
info = g_flags_get_value_by_nick(fclass, str);
if (info) {
*val |= info->value;
} else {
PyErr_SetString(PyExc_TypeError, "could not convert string");
res = -1;
break;
}
}
g_type_class_unref(fclass);
} else {
PyErr_SetString(PyExc_TypeError,
"flag values must be strings, ints, longs, or tuples");
res = -1;
}
return res;
}
gboolean
g_settings_get_mapping (GValue *value,
GVariant *variant,
gpointer user_data)
{
if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BOOLEAN))
{
if (!G_VALUE_HOLDS_BOOLEAN (value))
return FALSE;
g_value_set_boolean (value, g_variant_get_boolean (variant));
return TRUE;
}
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTE))
{
if (G_VALUE_HOLDS_UCHAR (value))
g_value_set_uchar (value, g_variant_get_byte (variant));
else if (G_VALUE_HOLDS_CHAR (value))
g_value_set_char (value, (gchar) g_variant_get_byte (variant));
else
return FALSE;
return TRUE;
}
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT16) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_INT64))
return g_settings_get_mapping_int (value, variant);
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_DOUBLE))
return g_settings_get_mapping_float (value, variant);
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT16) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT32) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT64) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_HANDLE))
return g_settings_get_mapping_unsigned_int (value, variant);
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_STRING) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_is_of_type (variant, G_VARIANT_TYPE_SIGNATURE))
{
if (G_VALUE_HOLDS_STRING (value))
{
g_value_set_string (value, g_variant_get_string (variant, NULL));
return TRUE;
}
else if (G_VALUE_HOLDS_ENUM (value))
{
GEnumClass *eclass;
GEnumValue *evalue;
const gchar *nick;
/* GParamSpecEnum holds a ref on the class so we just peek... */
eclass = g_type_class_peek (G_VALUE_TYPE (value));
nick = g_variant_get_string (variant, NULL);
evalue = g_enum_get_value_by_nick (eclass, nick);
if (evalue)
{
g_value_set_enum (value, evalue->value);
return TRUE;
}
g_warning ("Unable to lookup enum nick '%s' via GType\n", nick);
return FALSE;
}
}
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE ("as")))
{
if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
g_value_take_boxed (value, g_variant_dup_strv (variant, NULL));
return TRUE;
}
else if (G_VALUE_HOLDS_FLAGS (value))
{
GFlagsClass *fclass;
GFlagsValue *fvalue;
const gchar *nick;
GVariantIter iter;
guint flags = 0;
fclass = g_type_class_peek (G_VALUE_TYPE (value));
g_variant_iter_init (&iter, variant);
while (g_variant_iter_next (&iter, "&s", &nick))
{
fvalue = g_flags_get_value_by_nick (fclass, nick);
if (fvalue)
flags |= fvalue->value;
else
{
g_warning ("Unable to lookup flags nick '%s' via GType\n",
nick);
return FALSE;
}
}
g_value_set_flags (value, flags);
return TRUE;
}
}
else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTESTRING))
{
g_value_set_string (value, g_variant_get_bytestring (variant));
return TRUE;
}
g_critical ("No GSettings bind handler for type \"%s\".",
g_variant_get_type_string (variant));
return FALSE;
}
gboolean
qmicli_read_net_open_flags_from_string (const gchar *str,
QmiDeviceOpenFlags *out)
{
GType type;
GFlagsClass *flags_class;
GFlagsValue *flags_value;
gboolean success = TRUE, set = FALSE;
char **items, **iter;
type = qmi_device_open_flags_get_type ();
flags_class = G_FLAGS_CLASS (g_type_class_ref (type));
items = g_strsplit_set (str, "|", 0);
for (iter = items; iter && *iter && success; iter++) {
if (!*iter[0])
continue;
flags_value = g_flags_get_value_by_nick (flags_class, *iter);
if (flags_value) {
*out |= (QmiDeviceOpenFlags)flags_value->value;
set = TRUE;
} else {
g_printerr ("error: invalid net open flags value given: '%s'\n", *iter);
success = FALSE;
}
}
if (!set)
g_printerr ("error: invalid net open flags input given: '%s'\n", str);
if (items)
g_strfreev (items);
if (*out & QMI_DEVICE_OPEN_FLAGS_NET_802_3 &&
*out & QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP) {
g_printerr ("error: cannot give both 802.3 and raw-IP options\n");
success = FALSE;
}
if (*out & QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER &&
*out & QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER) {
g_printerr ("error: cannot request both QoS and no-QoS headers\n");
success = FALSE;
}
if ((*out & (QMI_DEVICE_OPEN_FLAGS_NET_802_3 | QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP)) &&
!(*out & (QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER | QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER))) {
g_printerr ("error: missing QoS or no-QoS header request\n");
success = FALSE;
}
if ((*out & (QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER | QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER)) &&
!(*out & (QMI_DEVICE_OPEN_FLAGS_NET_802_3 | QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP))) {
g_printerr ("error: missing link protocol (802.3 or raw IP)\n");
success = FALSE;
}
g_type_class_unref (flags_class);
return success && set;
}
static guint
resolve_flags_value(VALUE klass, GFlagsClass *gclass, VALUE flag_or_flags)
{
guint value = 0;
switch (TYPE(flag_or_flags)) {
case RUBY_T_NIL:
value = 0;
break;
case RUBY_T_FIXNUM:
case RUBY_T_BIGNUM:
value = NUM2UINT(flag_or_flags);
break;
case RUBY_T_STRING:
case RUBY_T_SYMBOL:
{
const gchar *name;
GFlagsValue *info;
name = RVAL2CSTR_ACCEPT_SYMBOL(flag_or_flags);
info = g_flags_get_value_by_name(gclass, name);
if (!info) {
gchar *nick;
nick = rbg_name_to_nick(name);
info = g_flags_get_value_by_nick(gclass, nick);
g_free(nick);
}
if (!info) {
rb_raise(rb_eArgError,
"unknown flag name: <%s>(%s)",
name,
g_type_name(G_TYPE_FROM_CLASS(gclass)));
}
value = info->value;
break;
}
case RUBY_T_ARRAY:
{
int i, n;
n = RARRAY_LEN(flag_or_flags);
for (i = 0; i < n; i++) {
value |= resolve_flags_value(klass,
gclass,
RARRAY_PTR(flag_or_flags)[i]);
}
break;
}
default:
if (RVAL2CBOOL(rb_obj_is_kind_of(flag_or_flags, klass))) {
value = NUM2UINT(rb_funcall(flag_or_flags, id_to_i, 0));
} else {
rb_raise(rb_eArgError,
"flag value must be one of "
"nil, Fixnum, String, Symbol, %s or Array of them: "
"<%s>(%s)",
RBG_INSPECT(klass),
RBG_INSPECT(flag_or_flags),
g_type_name(G_TYPE_FROM_CLASS(gclass)));
}
break;
}
return value;
}
