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_