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
  37 struct Deserialization
  38 {
  39
  40     static bool deserializePrimitive(
  41             DBusMessageIter* responseIterator,
  42             void* arg,
  43             int type)
  44     {
  45         if (dbus_message_iter_get_arg_type(responseIterator) != type) {
  46             return false;
  47         }
  48         dbus_message_iter_get_basic(responseIterator, arg);
  49         return true;
  50     }
  51
  52     // char* and all integer types + doubles
  53     template<typename T>
  54     static bool deserialize(DBusMessageIter* responseIterator, T* arg)
  55     {
  56         if (dbus_message_iter_get_arg_type(responseIterator)
  57                 != SimpleType<T>::value) {
  58             return false;
  59         }
  60         dbus_message_iter_get_basic(responseIterator, arg);
  61         return true;
  62     }
  63
  64     // float case - read as double
  65     static bool deserialize(DBusMessageIter* responseIterator, float* arg)
  66     {
  67         double d;
  68         if (!deserialize(responseIterator, &d)){
  69             return false;
  70         }
  71         *arg = static_cast<float>(d);
  72         return true;
  73     }
  74
  75     // std::string
  76     static bool deserialize(
  77             DBusMessageIter* responseIterator,
  78             std::string* arg)
  79     {
  80         char* str = NULL;
  81         if (!deserialize(responseIterator, &str)){
  82             return false;
  83         }
  84         *arg = std::string(str);
  85         return true;
  86     }
  87
  88     // dbus array deserialization
  89     template<typename T>
  90     static bool deserializeContainer(
  91             DBusMessageIter* responseIterator,
  92             T* arg)
  93     {
  94         if (dbus_message_iter_get_arg_type(responseIterator)
  95                 != DBUS_TYPE_ARRAY) {
  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             arg->push_back(typename T::value_type());
 103             if (!deserialize(&subIterator, &arg->back())){
 104                 return false;
 105             }
 106             dbus_message_iter_next(&subIterator);
 107         }
 108         return true;
 109     }
 110
 111     // std::vector
 112     template<typename T>
 113     static bool deserialize(
 114             DBusMessageIter* responseIterator,
 115             std::vector<T>* arg)
 116     {
 117         return deserializeContainer(responseIterator, arg);
 118     }
 119
 120     // std::list
 121     template<typename T>
 122     static bool deserialize(
 123             DBusMessageIter* responseIterator,
 124             std::list<T>* arg)
 125     {
 126         return deserializeContainer(responseIterator, arg);
 127     }
 128
 129     // std::set
 130     template<typename T>
 131     static bool deserialize(
 132             DBusMessageIter* responseIterator,
 133             std::set<T>* arg)
 134     {
 135         if (dbus_message_iter_get_arg_type(responseIterator)
 136                 != DBUS_TYPE_ARRAY) {
 137             return false;
 138         }
 139         DBusMessageIter subIterator;
 140         dbus_message_iter_recurse(responseIterator, &subIterator);
 141         while (dbus_message_iter_get_arg_type(&subIterator)
 142                 != DBUS_TYPE_INVALID) {
 143             typename std::set<T>::value_type element;
 144             if (!deserialize(&subIterator, &element)){
 145                 return false;
 146             }
 147             arg->insert(element);
 148             dbus_message_iter_next(&subIterator);
 149         }
 150         return true;
 151     }
 152
 153     // std::pair
 154     template<typename A, typename B>
 155     static bool deserialize(
 156             DBusMessageIter* argsIterator,
 157             const std::pair<A, B>* arg)
 158     {
 159         if (dbus_message_iter_get_arg_type(argsIterator)
 160                 != DBUS_TYPE_DICT_ENTRY) {
 161             return false;
 162         }
 163         DBusMessageIter dictEntryIterator;
 164         dbus_message_iter_recurse(argsIterator, &dictEntryIterator);
 165         if (!deserialize(dictEntryIterator, &arg->first)){
 166             return false;
 167         }
 168         dbus_message_iter_next(&dictEntryIterator);
 169         if (!deserialize(dictEntryIterator, &arg->second)){
 170             return false;
 171         }
 172         return true;
 173     }
 174
 175     // std::map
 176     template<typename K, typename V>
 177     static bool deserialize(
 178             DBusMessageIter* responseIterator,
 179             const std::map<K, V>* arg)
 180     {
 181         if (dbus_message_iter_get_arg_type(responseIterator)
 182                 != DBUS_TYPE_ARRAY) {
 183             return false;
 184         }
 185         DBusMessageIter subIterator;
 186         dbus_message_iter_recurse(responseIterator, &subIterator);
 187         while (dbus_message_iter_get_arg_type(&subIterator)
 188                 != DBUS_TYPE_INVALID) {
 189             typename std::pair<K, V> element;
 190             if (!deserialize(&subIterator, &element)){
 191                 return false;
 192             }
 193             arg->insert(element);
 194             dbus_message_iter_next(&subIterator);
 195         }
 196         return true;
 197     }
 198
 199 };
 200
 201 template<>
 202 inline bool Deserialization::deserialize<bool>(
 203     DBusMessageIter* responseIterator,
 204     bool* arg)
 205 {
 206     unsigned int value;
 207     if (dbus_message_iter_get_arg_type(responseIterator)
 208         != SimpleType<bool>::value) {
 209         return false;
 210     }
 211     dbus_message_iter_get_basic(responseIterator, &value);
 212     *arg = static_cast<bool>(value);
 213     return true;
 214 }
 215
 216 } // namespace DBus
 217 } // namespace DPL
 218
 219 #endif // DPL_DBUS_DBUS_DESERIALIZATION_H_