modules/dbus/include/dpl/dbus/dbus_server_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_server_deserialization.h
  18  * @author      Tomasz Swierczek (t.swierczek@samsung.com)
  19  * @version     1.0
  20  * @brief       Header file for DBus data deserialization from GVariant
  21  */
  22
  23 #ifndef DPL_DBUS_DBUS_SERVER_DESERIALIZATION_H_
  24 #define DPL_DBUS_DBUS_SERVER_DESERIALIZATION_H_
  25
  26 #include <string>
  27 #include <vector>
  28 #include <list>
  29 #include <map>
  30 #include <gio/gio.h>
  31 #include <dpl/assert.h>
  32
  33 namespace DPL {
  34 namespace DBus {
  35
  36 struct ServerDeserialization {
  37
  38     template<typename T, typename ...Args>
  39     static bool deserialize(GVariant* g, T* arg1, Args... args)
  40     {
  41         Assert(NULL != g);
  42         Assert(NULL != arg1);
  43         GVariantIter* iterator = g_variant_iter_new(g);
  44         if (NULL == iterator) {
  45             return false;
  46         }
  47         if (!deserializeIterator(iterator, arg1)) {
  48             g_variant_iter_free(iterator);
  49             return false;
  50         }
  51         if (!deserializeIterator(iterator, args...)) {
  52             g_variant_iter_free(iterator);
  53             return false;
  54         }
  55         g_variant_iter_free(iterator);
  56         return true;
  57     }
  58
  59     template<typename T>
  60     static bool deserialize(GVariant* g, T* arg1)
  61     {
  62         Assert(NULL != g);
  63         Assert(NULL != arg1);
  64         GVariantIter* iterator = g_variant_iter_new(g);
  65         if (NULL == iterator) {
  66             return false;
  67         }
  68         if (!deserializeIterator(iterator, arg1)) {
  69             g_variant_iter_free(iterator);
  70             return false;
  71         }
  72         g_variant_iter_free(iterator);
  73         return true;
  74     }
  75
  76     // deserialization from GVariant tuple iterator
  77     template<typename T, typename ...Args>
  78     static bool deserializeIterator(GVariantIter* g, T* arg1, Args... args)
  79     {
  80         Assert(NULL != g);
  81         Assert(NULL != arg1);
  82         GVariant* elem = g_variant_iter_next_value(g);
  83         if (NULL == elem) {
  84             return false;
  85         }
  86         if (!deserializeElem(elem, arg1)) {
  87             return false;
  88         }
  89         if (!deserializeIterator(g, args...)) {
  90             return false;
  91         }
  92         return true;
  93     }
  94
  95     template<typename T>
  96     static bool deserializeIterator(GVariantIter* g, T* arg1)
  97     {
  98         Assert(NULL != g);
  99         Assert(NULL != arg1);
 100         GVariant* elem = g_variant_iter_next_value(g);
 101         if (NULL == elem) {
 102             return false;
 103         }
 104         if (!deserializeElem(elem, arg1)) {
 105             return false;
 106         }
 107         g_variant_unref(elem);
 108         return true;
 109     }
 110
 111     // type specialization
 112     static bool deserializeElem(GVariant* parameters, std::string* outStr)
 113     {
 114         const gchar* arg = g_variant_get_string(parameters, NULL);
 115         *outStr = std::string(arg);
 116         return true;
 117     }
 118
 119     static bool deserializeElem(GVariant* parameters, int* outInt)
 120     {
 121         gint32 arg = g_variant_get_int32(parameters);
 122         *outInt = arg;
 123         return true;
 124     }
 125
 126     static bool deserializeElem(GVariant* parameters, unsigned* outInt)
 127     {
 128         guint32 arg = g_variant_get_uint32(parameters);
 129         *outInt = arg;
 130         return true;
 131     }
 132
 133     static bool deserializeElem(GVariant* parameters, bool* outInt)
 134     {
 135         gboolean arg = g_variant_get_boolean(parameters);
 136         *outInt = arg;
 137         return true;
 138     }
 139
 140     static bool deserializeElem(GVariant* parameters, float* outInt)
 141     {
 142         gdouble arg = g_variant_get_double(parameters);
 143         *outInt = static_cast<float>(arg);
 144         return true;
 145     }
 146
 147     static bool deserializeElem(GVariant* parameters,
 148                             std::vector<std::string>* outArray)
 149     {
 150         unsigned int i = 0;
 151         gsize length = 0;
 152         const gchar** args = g_variant_get_strv(
 153                 parameters,
 154                 &length);
 155         for (i = 0; i < length; ++i) {
 156             outArray->push_back(std::string(args[i]));
 157         }
 158         g_free(args);
 159         return true;
 160     }
 161
 162     static bool deserializeElem(GVariant* parameters,
 163                                 std::list<std::string>* outArray)
 164     {
 165         unsigned int i = 0;
 166         gsize length = 0;
 167         const gchar** args = g_variant_get_strv(
 168                 parameters,
 169                 &length);
 170         for (i = 0; i < length; ++i) {
 171             outArray->push_back(std::string(args[i]));
 172         }
 173         g_free(args);
 174         return true;
 175     }
 176 };
 177
 178 } // namespace DBus
 179 } // namespace DPL
 180
 181 #endif // DPL_DBUS_DBUS_SERVER_DESERIALIZATION_H_