VariantConverter.h

/*
 * Copyright (C) 2014 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef VARIANTCONVERTER_H
#define VARIANTCONVERTER_H

#include <QDebug>
#include <QJsonObject>
#include <QPointF>
#include <QString>
#include <QVariant>

template <typename T>
class VariantConverterBase {
public:
    QVariant toVariant(const T& value) {
        return QVariant(value);
    }
};

template <typename T>
class VariantConverter : public VariantConverterBase<T> {
};

template <>
class VariantConverter<int> : public VariantConverterBase<int> {
public:
    int fromVariant(const QVariant& value) {
        return value.toInt();
    }
};

template <>
class VariantConverter<QString> : public VariantConverterBase<QString> {
public:
    QString fromVariant(const QVariant& value) {
        return value.toString();
    }
};

template <>
class VariantConverter<QJsonObject> : public VariantConverterBase<QJsonObject> {
public:
    QJsonObject fromVariant(const QVariant& value) {
        if (value.canConvert(QMetaType::QVariantMap)) {
            return QJsonObject::fromVariantMap(value.toMap());
        } else {
            return value.toJsonObject();
        }
    }
};

template <>
class VariantConverter<QPointF> : public VariantConverterBase<QPointF> {
public:
    QPointF fromVariant(const QVariant& value) {
        if (value.canConvert(QMetaType::QVariantList)) {
            QVariantList floatList = value.toList();
            float x = floatList.size() >= 1 ? floatList[0].toFloat() : 0.0f;
            float y = floatList.size() >= 2 ? floatList[1].toFloat() : 0.0f;
            return QPointF(x, y);
        } else {
            return value.toPointF();
        }
    }
};

template <typename T>
class VariantConverter<QMap<QString, T>> {
public:
    QMap<QString, T> fromVariant(const QVariant& value) {
        QMap<QString, T> convertedMap;
        VariantConverter<T> converter;
        QVariantMap map = value.toMap();
        for (auto it = map.cbegin(); it != map.cend(); ++it) {
            convertedMap.insert(it.key(), converter.fromVariant(it.value()));
        }
        return convertedMap;
    }

    QVariant toVariant(const QMap<QString, T>& value) {
        QVariantMap map;
        VariantConverter<T> converter;
        for (auto it = value.cbegin(); it != value.cend(); ++it) {
            map.insert(it.key(), converter.toVariant(it.value()));
        }
        return QVariant(map);
    }
};

template <typename T>
class VariantConverter<QSet<T>> {
public:
    QSet<T> fromVariant(const QVariant& value) {
        QSet<T> convertedSet;
        VariantConverter<T> converter;
        for (const QVariant& var : value.toList()) {
            convertedSet.insert(converter.fromVariant(var));
        }
        return convertedSet;
    }

    QVariant toVariant(const QSet<T>& value) {
        QVariantList list;
        list.reserve(value.size());
        VariantConverter<T> converter;
        for (const T& val : value) {
            list.append(converter.toVariant(val));
        }
        return QVariant(list);
    }
};

#endif // VARIANTCONVERTER_H