accounts-qt  1.15
utils.cpp
00001 /* vi: set et sw=4 ts=4 cino=t0,(0: */
00002 /*
00003  * This file is part of libaccounts-qt
00004  *
00005  * Copyright (C) 2012-2016 Canonical Ltd.
00006  *
00007  * Contact: Alberto Mardegan <alberto.mardegan@canonical.com>
00008  *
00009  * This library is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU Lesser General Public License
00011  * version 2.1 as published by the Free Software Foundation.
00012  *
00013  * This library is distributed in the hope that it will be useful, but
00014  * WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with this library; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
00021  * 02110-1301 USA
00022  */
00023 
00024 #include "accountscommon.h"
00025 #include "utils.h"
00026 
00027 #include <QStringList>
00028 
00029 namespace Accounts {
00030 
00031 static QVariantMap gVariantToQVariantMap(GVariant *variant)
00032 {
00033     QVariantMap ret;
00034     GVariantIter iter;
00035     gchar *key;
00036     GVariant *value;
00037 
00038     g_variant_iter_init (&iter, variant);
00039     while (g_variant_iter_next (&iter, "{sv}", &key, &value)) {
00040         ret.insert(UTF8(key), gVariantToQVariant(value));
00041         g_variant_unref(value);
00042         g_free(key);
00043     }
00044 
00045     return ret;
00046 }
00047 
00048 static GVariant *qStringListToGVariant(const QStringList &stringList)
00049 {
00050     GVariantBuilder builder;
00051 
00052     g_variant_builder_init(&builder, G_VARIANT_TYPE_STRING_ARRAY);
00053     Q_FOREACH (const QString &string, stringList) {
00054         g_variant_builder_add(&builder, "s", string.toUtf8().constData());
00055     }
00056     return g_variant_builder_end(&builder);
00057 }
00058 
00059 static QStringList gVariantToQStringList(GVariant *variant)
00060 {
00061     QStringList ret;
00062 
00063     gsize length;
00064     const gchar **strings = g_variant_get_strv(variant, &length);
00065     ret.reserve(length);
00066     for (gsize i = 0; i < length; i++) {
00067         ret.append(UTF8(strings[i]));
00068     }
00069 
00070     g_free(strings);
00071     return ret;
00072 }
00073 
00074 QVariant gVariantToQVariant(GVariant *value)
00075 {
00076     GVariantClass variantClass = g_variant_classify(value);
00077 
00078     QVariant variant;
00079 
00080     switch (variantClass)
00081     {
00082     case G_VARIANT_CLASS_STRING:
00083         variant = UTF8(g_variant_get_string(value, NULL));
00084         break;
00085     case G_VARIANT_CLASS_INT32:
00086         variant = g_variant_get_int32(value);
00087         break;
00088     case G_VARIANT_CLASS_UINT32:
00089         variant = g_variant_get_uint32(value);
00090         break;
00091     case G_VARIANT_CLASS_INT64:
00092         variant = qint64(g_variant_get_int64(value));
00093         break;
00094     case G_VARIANT_CLASS_UINT64:
00095         variant = quint64(g_variant_get_uint64(value));
00096         break;
00097     case G_VARIANT_CLASS_BOOLEAN:
00098         variant = bool(g_variant_get_boolean(value));
00099         break;
00100     case G_VARIANT_CLASS_ARRAY:
00101         if (g_variant_is_of_type(value, G_VARIANT_TYPE_VARDICT)) {
00102             variant = gVariantToQVariantMap(value);
00103             break;
00104         } else if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING_ARRAY)) {
00105             variant = gVariantToQStringList(value);
00106             break;
00107         }
00108         // fall through
00109     default:
00110         qWarning() << "Unsupported type" << UTF8(g_variant_get_type_string(value));
00111         break;
00112     }
00113 
00114     return variant;
00115 }
00116 
00117 GVariant *qVariantToGVariant(const QVariant &variant)
00118 {
00119     GVariant *ret = 0;
00120     QByteArray tmpvalue;
00121 
00122     switch (variant.type())
00123     {
00124     case QVariant::String:
00125         tmpvalue = variant.toString().toUtf8();
00126         ret = g_variant_new_string(tmpvalue.constData());
00127         break;
00128     case QVariant::Int:
00129         ret = g_variant_new_int32(variant.toInt());
00130         break;
00131     case QVariant::UInt:
00132         ret = g_variant_new_uint32(variant.toUInt());
00133         break;
00134     case QVariant::LongLong:
00135         ret = g_variant_new_int64(variant.toLongLong());
00136         break;
00137     case QVariant::ULongLong:
00138         ret = g_variant_new_uint64(variant.toULongLong());
00139         break;
00140     case QVariant::Bool:
00141         ret = g_variant_new_boolean(variant.toBool());
00142         break;
00143     case QVariant::StringList:
00144         ret = qStringListToGVariant(variant.toStringList());
00145         break;
00146     default:
00147         qWarning() << "Unsupported datatype" << variant.typeName();
00148     }
00149 
00150     return ret;
00151 }
00152 
00153 }; // namespace