Source code formating unification
[framework/web/wrt-commons.git] / modules / dbus / include / dpl / dbus / dbus_deserialization.h
1 /*
2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
3  *
4  *    Licensed under the Apache License, Version 2.0 (the "License");
5  *    you may not use this file except in compliance with the License.
6  *    You may obtain a copy of the License at
7  *
8  *        http://www.apache.org/licenses/LICENSE-2.0
9  *
10  *    Unless required by applicable law or agreed to in writing, software
11  *    distributed under the License is distributed on an "AS IS" BASIS,
12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  *    See the License for the specific language governing permissions and
14  *    limitations under the License.
15  */
16 /*
17  * @file        dbus_deserialization.h
18  * @author      Tomasz Swierczek (t.swierczek@samsung.com)
19  * @version     1.0
20  * @brief       Header file for DBus data deserialization
21  */
22
23 #ifndef DPL_DBUS_DBUS_DESERIALIZATION_H_
24 #define DPL_DBUS_DBUS_DESERIALIZATION_H_
25
26 #include <map>
27 #include <vector>
28 #include <list>
29 #include <set>
30 #include <string>
31 #include <dbus/dbus.h>
32 #include <dpl/dbus/dbus_signature.h>
33
34 namespace DPL {
35 namespace DBus {
36 struct Deserialization
37 {
38     static bool deserializePrimitive(
39         DBusMessageIter* responseIterator,
40         void* arg,
41         int type)
42     {
43         if (dbus_message_iter_get_arg_type(responseIterator) != type) {
44             return false;
45         }
46         dbus_message_iter_get_basic(responseIterator, arg);
47         return true;
48     }
49
50     // char* and all integer types + doubles
51     template<typename T>
52     static bool deserialize(DBusMessageIter* responseIterator, T* arg)
53     {
54         if (dbus_message_iter_get_arg_type(responseIterator)
55             != SimpleType<T>::value)
56         {
57             return false;
58         }
59         dbus_message_iter_get_basic(responseIterator, arg);
60         return true;
61     }
62
63     // float case - read as double
64     static bool deserialize(DBusMessageIter* responseIterator, float* arg)
65     {
66         double d;
67         if (!deserialize(responseIterator, &d)) {
68             return false;
69         }
70         *arg = static_cast<float>(d);
71         return true;
72     }
73
74     // std::string
75     static bool deserialize(
76         DBusMessageIter* responseIterator,
77         std::string* arg)
78     {
79         char* str = NULL;
80         if (!deserialize(responseIterator, &str)) {
81             return false;
82         }
83         *arg = std::string(str);
84         return true;
85     }
86
87     // dbus array deserialization
88     template<typename T>
89     static bool deserializeContainer(
90         DBusMessageIter* responseIterator,
91         T* arg)
92     {
93         if (dbus_message_iter_get_arg_type(responseIterator)
94             != DBUS_TYPE_ARRAY)
95         {
96             return false;
97         }
98         DBusMessageIter subIterator;
99         dbus_message_iter_recurse(responseIterator, &subIterator);
100         while (dbus_message_iter_get_arg_type(&subIterator)
101                != DBUS_TYPE_INVALID)
102         {
103             arg->push_back(typename T::value_type());
104             if (!deserialize(&subIterator, &arg->back())) {
105                 return false;
106             }
107             dbus_message_iter_next(&subIterator);
108         }
109         return true;
110     }
111
112     // std::vector
113     template<typename T>
114     static bool deserialize(
115         DBusMessageIter* responseIterator,
116         std::vector<T>* arg)
117     {
118         return deserializeContainer(responseIterator, arg);
119     }
120
121     // std::list
122     template<typename T>
123     static bool deserialize(
124         DBusMessageIter* responseIterator,
125         std::list<T>* arg)
126     {
127         return deserializeContainer(responseIterator, arg);
128     }
129
130     // std::set
131     template<typename T>
132     static bool deserialize(
133         DBusMessageIter* responseIterator,
134         std::set<T>* arg)
135     {
136         if (dbus_message_iter_get_arg_type(responseIterator)
137             != DBUS_TYPE_ARRAY)
138         {
139             return false;
140         }
141         DBusMessageIter subIterator;
142         dbus_message_iter_recurse(responseIterator, &subIterator);
143         while (dbus_message_iter_get_arg_type(&subIterator)
144                != DBUS_TYPE_INVALID)
145         {
146             typename std::set<T>::value_type element;
147             if (!deserialize(&subIterator, &element)) {
148                 return false;
149             }
150             arg->insert(element);
151             dbus_message_iter_next(&subIterator);
152         }
153         return true;
154     }
155
156     // std::pair
157     template<typename A, typename B>
158     static bool deserialize(
159         DBusMessageIter* argsIterator,
160         const std::pair<A, B>* arg)
161     {
162         if (dbus_message_iter_get_arg_type(argsIterator)
163             != DBUS_TYPE_DICT_ENTRY)
164         {
165             return false;
166         }
167         DBusMessageIter dictEntryIterator;
168         dbus_message_iter_recurse(argsIterator, &dictEntryIterator);
169         if (!deserialize(dictEntryIterator, &arg->first)) {
170             return false;
171         }
172         dbus_message_iter_next(&dictEntryIterator);
173         if (!deserialize(dictEntryIterator, &arg->second)) {
174             return false;
175         }
176         return true;
177     }
178
179     // std::map
180     template<typename K, typename V>
181     static bool deserialize(
182         DBusMessageIter* responseIterator,
183         const std::map<K, V>* arg)
184     {
185         if (dbus_message_iter_get_arg_type(responseIterator)
186             != DBUS_TYPE_ARRAY)
187         {
188             return false;
189         }
190         DBusMessageIter subIterator;
191         dbus_message_iter_recurse(responseIterator, &subIterator);
192         while (dbus_message_iter_get_arg_type(&subIterator)
193                != DBUS_TYPE_INVALID)
194         {
195             typename std::pair<K, V> element;
196             if (!deserialize(&subIterator, &element)) {
197                 return false;
198             }
199             arg->insert(element);
200             dbus_message_iter_next(&subIterator);
201         }
202         return true;
203     }
204 };
205
206 template<>
207 inline bool Deserialization::deserialize<bool>(
208     DBusMessageIter* responseIterator,
209     bool* arg)
210 {
211     unsigned int value;
212     if (dbus_message_iter_get_arg_type(responseIterator)
213         != SimpleType<bool>::value)
214     {
215         return false;
216     }
217     dbus_message_iter_get_basic(responseIterator, &value);
218     *arg = static_cast<bool>(value);
219     return true;
220 }
221 } // namespace DBus
222 } // namespace DPL
223
224 #endif // DPL_DBUS_DBUS_DESERIALIZATION_H_