accounts-qt  1.13
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 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     for (gsize i = 0; i < length; i++) {
00066         ret.append(UTF8(strings[i]));
00067     }
00068 
00069     g_free(strings);
00070     return ret;
00071 }
00072 
00073 QVariant gVariantToQVariant(GVariant *value)
00074 {
00075     GVariantClass variantClass = g_variant_classify(value);
00076 
00077     QVariant variant;
00078 
00079     switch (variantClass)
00080     {
00081     case G_VARIANT_CLASS_STRING:
00082         variant = UTF8(g_variant_get_string(value, NULL));
00083         break;
00084     case G_VARIANT_CLASS_INT32:
00085         variant = g_variant_get_int32(value);
00086         break;
00087     case G_VARIANT_CLASS_UINT32:
00088         variant = g_variant_get_uint32(value);
00089         break;
00090     case G_VARIANT_CLASS_INT64:
00091         variant = qint64(g_variant_get_int64(value));
00092         break;
00093     case G_VARIANT_CLASS_UINT64:
00094         variant = quint64(g_variant_get_uint64(value));
00095         break;
00096     case G_VARIANT_CLASS_BOOLEAN:
00097         variant = bool(g_variant_get_boolean(value));
00098         break;
00099     case G_VARIANT_CLASS_ARRAY:
00100         if (g_variant_is_of_type(value, G_VARIANT_TYPE_VARDICT)) {
00101             variant = gVariantToQVariantMap(value);
00102             break;
00103         } else if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING_ARRAY)) {
00104             variant = gVariantToQStringList(value);
00105             break;
00106         }
00107         // fall through
00108     default:
00109         qWarning() << "Unsupported type" << UTF8(g_variant_get_type_string(value));
00110         break;
00111     }
00112 
00113     return variant;
00114 }
00115 
00116 GVariant *qVariantToGVariant(const QVariant &variant)
00117 {
00118     GVariant *ret = 0;
00119     QByteArray tmpvalue;
00120 
00121     switch (variant.type())
00122     {
00123     case QVariant::String:
00124         tmpvalue = variant.toString().toUtf8();
00125         ret = g_variant_new_string(tmpvalue.constData());
00126         break;
00127     case QVariant::Int:
00128         ret = g_variant_new_int32(variant.toInt());
00129         break;
00130     case QVariant::UInt:
00131         ret = g_variant_new_uint32(variant.toUInt());
00132         break;
00133     case QVariant::LongLong:
00134         ret = g_variant_new_int64(variant.toLongLong());
00135         break;
00136     case QVariant::ULongLong:
00137         ret = g_variant_new_uint64(variant.toULongLong());
00138         break;
00139     case QVariant::Bool:
00140         ret = g_variant_new_boolean(variant.toBool());
00141         break;
00142     case QVariant::StringList:
00143         ret = qStringListToGVariant(variant.toStringList());
00144         break;
00145     default:
00146         qWarning() << "Unsupported datatype" << variant.typeName();
00147     }
00148 
00149     return ret;
00150 }
00151 
00152 }; // namespace