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
144
145
146
147
148
149
150
151
152
153
|
#ifndef _MAPPROPERTYTYPE_H_
#define _MAPPROPERTYTYPE_H_
#include "abstractpropertytype.h"
#include <map>
#include <debugout.h>
#include "picojson.h"
template <class N>
class MapPropertyType: public AbstractPropertyType
{
public:
MapPropertyType(std::string propertyName):AbstractPropertyType(propertyName){}
void append(std::string key, N value)
{
appendPriv(key, value);
}
AbstractPropertyType* copy()
{
MapPropertyType<N> *t = new MapPropertyType<N>(name);
t->setMap(mMap);
t->timestamp = timestamp;
t->sequence = sequence;
t->sourceUuid = sourceUuid;
t->name = name;
t->zone = zone;
return t;
}
std::string toString() const
{
std::stringstream str;
str<<"{";
for(auto itr: mMap)
{
if(str.str() != "{")
str << ", ";
str <<"\""<< itr.first <<"\":\""<<itr.second.toString()<<"\"";
}
str << "}";
return str.str();
}
void fromString(std::string str)
{
clear();
DebugOut() << str << endl;
picojson::value value;
picojson::parse(value, str);
std::string picojsonerr = picojson::get_last_error();
if(!value.is<picojson::object>() || !picojsonerr.empty())
{
DebugOut(DebugOut::Warning) << "JSon is invalid for MapPropertyType: " << str << endl;
DebugOut(DebugOut::Warning) << picojsonerr << endl;
return;
}
const picojson::object& obj = value.get<picojson::object>();
DebugOut() << "obj size: " << obj.size() << endl;
for(auto i : obj)
{
std::string key = i.first;
N val("");
val.fromString(i.second.to_str());
append(key, val);
}
}
GVariant* toVariant()
{
GVariantBuilder params;
g_variant_builder_init(¶ms, G_VARIANT_TYPE_DICTIONARY);
for(auto itr = mMap.begin(); itr != mMap.end(); itr++)
{
auto &foo = (*itr).first;
g_variant_builder_add(¶ms,"{sv}",foo.c_str(), (*itr).second.toVariant());
}
GVariant* var = g_variant_builder_end(¶ms);
g_assert(var);
return var;
}
void fromVariant(GVariant* variant)
{
clear();
gsize dictsize = g_variant_n_children(variant);
for (int i=0;i<dictsize;i++)
{
GVariant *childvariant = g_variant_get_child_value(variant,i);
gsize dictvalsize = g_variant_n_children(childvariant);
if (dictvalsize == 2)
{
//It is a dictionary entry
GVariant *keyvariant = g_variant_get_child_value(childvariant,0);
GVariant *valvariant = g_variant_get_child_value(childvariant,1);
std::string key = g_variant_get_string(keyvariant, nullptr);
N n = N();
GVariant *innerValue = nullptr;
DebugOut() << "variantType: " << g_variant_get_type_string(valvariant) << endl;
g_variant_get(valvariant, "v", &innerValue);
DebugOut() << "inner variange: " << g_variant_get_type_string(innerValue) << endl;
n.fromVariant(innerValue);
appendPriv(key,n);
}
}
}
void setMap(std::map<std::string, N> m)
{
mMap = m;
}
private:
void clear()
{
mMap.clear();
}
void appendPriv(std::string key, N value)
{
mMap[key] = value;
}
std::map<std::string, N> mMap;
};
#endif
|
