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