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
135
136
137
138
139
140
141
142
143
|
/*
* Copyright (C) 2014 The glibmm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <glibmm/variant.h>
_DEFS(glibmm,glib)
namespace Glib
{
/** VariantDict is a mutable interface to Variant dictionaries.
*
* It can be used for doing a sequence of dictionary lookups in an
* efficient way on an existing Variant dictionary or it can be used
* to construct new dictionaries with a hashtable-like interface. It
* can also be used for taking existing dictionaries and modifying them
* in order to create new ones.
*
* newin{2,40}
*/
class VariantDict final
{
//GVariantDict is registered as a boxed type, but it has ref/unref functions instead of copy/free,
//so we use it via RefPtr.
_CLASS_OPAQUE_REFCOUNTED(VariantDict, GVariantDict, NONE, g_variant_dict_ref, g_variant_dict_unref)
_IGNORE(g_variant_dict_ref, g_variant_dict_unref, g_variant_dict_init)
public:
_WRAP_METHOD(static Glib::RefPtr<VariantDict> create(const VariantBase& from_asv{?}), g_variant_dict_new)
//TODO: Add a method overload that does not take expected_type (which can be null),
//just returning a VariantBase that should be cast_dynamic()ed?
/** Looks up a value in the VariantDict. See also lookup_value().
*
* If the @a key is not found the false is returned.
*
* The @a expected_type string specifies what type of value is expected.
* If the value associated with @a key has a different type then false is
* returned.
*
* If the key is found and the value has the correct type, it is
* returned in the @a value output variable.
*/
bool lookup_value_variant(const Glib::ustring& key, const VariantType& expected_type, VariantBase& value) const;
_IGNORE(g_variant_dict_lookup_value)
/** Looks up a value in the VariantDict.
*
* If the @a key is not found the false is returned.
*
* If the value associated with @a key has a different type than expected then false is
* returned.
*
* If the key is found and the value has the correct type, it is
* returned in the @a value output variable.
*/
template <typename T_Value>
bool lookup_value(const Glib::ustring& key, T_Value& value) const;
_IGNORE(g_variant_dict_lookup)
_WRAP_METHOD(bool contains(const Glib::ustring& key) const, g_variant_dict_contains)
_IGNORE(g_variant_dict_insert)
_WRAP_METHOD(void insert_value_variant(const Glib::ustring& key, const VariantBase& value), g_variant_dict_insert_value)
/** Inserts (or replaces) a key in a VariantDict.
*
* @param key The key to insert a value for.
* @param value The value to insert.
*/
template <typename T_Value>
void insert_value(const Glib::ustring& key, const T_Value& value);
_WRAP_METHOD(bool remove(const Glib::ustring& key), g_variant_dict_remove)
_WRAP_METHOD(void clear(), g_variant_dict_clear)
_IGNORE(g_variant_dict_end)
};
template <typename T_Value>
void VariantDict::insert_value(const Glib::ustring& key, const T_Value& value)
{
using type_glib_variant = Glib::Variant<T_Value>;
//TODO: Can we do any check like this here, before glib does?
//g_return_val_if_fail(
// g_variant_type_equal(g_action_get_parameter_type(const_cast<GAction*>(gobj())), type_glib_variant::variant_type().gobj()),
// Glib::ustring());
return insert_value_variant(key, type_glib_variant::create(value));
}
template <typename T_Value>
bool VariantDict::lookup_value(const Glib::ustring& key, T_Value& value) const
{
value = T_Value(); //Make sure that it is initialized.
using type_glib_variant = Glib::Variant<T_Value>;
//TODO: Can we do any check like this here, before glib does?
//g_variant_type_equal(g_action_group_get_action_state_type(const_cast<GActionGroup*>(gobj()), action_name.c_str()), type_glib_variant::variant_type().gobj()));
Glib::VariantBase variantBase;
const bool result = lookup_value_variant(key, type_glib_variant::variant_type(), variantBase);
if(!result)
return result;
try
{
const type_glib_variant variantDerived = variantBase.cast_dynamic<type_glib_variant>(variantBase);
value = variantDerived.get();
}
catch(const std::bad_cast& ex)
{
return false;
}
return result;
}
} //namespace Glib
|
