-
Notifications
You must be signed in to change notification settings - Fork 0
/
gvariant-utils.h
134 lines (118 loc) · 3.74 KB
/
gvariant-utils.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/*
* GVariant utilities
*
* Based on the earlier QObject API
*
* Copyright (C) 2011 Red Hat, Inc.
*
* Authors:
* Paolo Bonzini <pbonzini@redhat.com>
*
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
* See the COPYING.LIB file in the top-level directory.
*/
#ifndef GVARIANT_UTILS_H
#define GVARIANT_UTILS_H
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <assert.h>
#include <glib.h>
static inline void g_variant_array_iterate(GVariant *array,
void (*iter)(GVariant *obj, void *opaque), void *opaque)
{
GVariant *var;
GVariantIter _iter;
g_variant_iter_init(&_iter, array);
while (g_variant_iter_loop (&_iter, "v", &var))
iter (var, opaque);
}
#if GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION <= 26
extern
gboolean
g_variant_lookup (GVariant *dictionary,
const gchar *key,
const gchar *format_string,
...);
extern
GVariant *
g_variant_lookup_value (GVariant *dictionary,
const gchar *key,
const GVariantType *expected_type);
#endif
static inline bool g_variant_has_key(GVariant *dict, const char *key)
{
GVariant *value;
value = g_variant_lookup_value(dict, key, NULL);
if (value)
g_variant_unref(value);
return value != NULL;
}
#define g_variant_do_lookup(dict, key, type, c_type) ({ \
c_type _val = (c_type) 0; g_variant_lookup(dict, key, type, &_val); _val; })
#define g_variant_lookup_boolean(dict, key) \
g_variant_do_lookup(dict, key, "b", bool)
#define g_variant_lookup_array(dict, key) \
g_variant_do_lookup(dict, key, "av", GVariant *)
#define g_variant_lookup_dictionary(dict, key) \
g_variant_do_lookup(dict, key, "a{sv}", GVariant *)
static inline void g_variant_dictionary_iterate(GVariant *dict,
void (*iter)(const char *key, GVariant *value, void *opaque),
void *opaque)
{
GVariantIter _iter;
const char *key;
GVariant *value;
g_variant_iter_init(&_iter, dict);
while (g_variant_iter_loop (&_iter, "{sv}", &key, &value)) {
iter (key, value, opaque);
}
}
/* High level helpers */
static inline double g_variant_lookup_double(GVariant *dict, const char *key)
{
GVariant *value = g_variant_lookup_value (dict, key, NULL);
double result;
if (g_variant_is_of_type (value, G_VARIANT_TYPE_DOUBLE))
result = g_variant_get_double (value);
else
result = g_variant_get_int64 (value);
g_variant_unref(value);
return result;
}
static inline int64_t g_variant_lookup_int64_default(GVariant *dict, const char *key,
int64_t def_value)
{
GVariant *value = g_variant_lookup_value (dict, key, NULL);
int64_t result;
if (g_variant_is_of_type (value, G_VARIANT_TYPE_INT64))
result = g_variant_get_int64 (value);
else
result = def_value;
g_variant_unref(value);
return def_value;
}
static inline int g_variant_lookup_boolean_default(GVariant *dict, const char *key, int def_value)
{
GVariant *value = g_variant_lookup_value (dict, key, NULL);
int result;
if (g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN))
result = g_variant_get_boolean (value);
else
result = def_value;
g_variant_unref(value);
return def_value;
}
static inline
const char *g_variant_lookup_string(GVariant *dict, const char *key)
{
GVariant *value = g_variant_lookup_value (dict, key, NULL);
const char *result;
if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
result = g_variant_get_string (value, NULL);
else
result = NULL;
g_variant_unref(value);
return result;
}
#endif /* GVARIANT_UTILS_H */