diff options
Diffstat (limited to 'lib/converters.h')
| -rw-r--r-- | lib/converters.h | 622 |
1 files changed, 332 insertions, 290 deletions
diff --git a/lib/converters.h b/lib/converters.h index 68a841cf..3ba65c22 100644 --- a/lib/converters.h +++ b/lib/converters.h @@ -31,343 +31,385 @@ #include <unordered_map> #include <vector> #if 0 // Waiting for C++17 -#include <experimental/optional> +# include <experimental/optional> template <typename T> using optional = std::experimental::optional<T>; #endif // Enable std::unordered_map<QString, T> -namespace std { - template <> struct hash<QString> { - size_t operator()(const QString& s) const Q_DECL_NOEXCEPT - { - return qHash(s +namespace std +{ +template <> +struct hash<QString> +{ + size_t operator()(const QString& s) const Q_DECL_NOEXCEPT + { + return qHash(s #if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)) - , - uint(qGlobalQHashSeed()) + , + uint(qGlobalQHashSeed()) #endif - ); - } - }; -} + ); + } +}; +} // namespace std class QVariant; -namespace QMatrixClient { - template <typename T> struct JsonObjectConverter { - static void dumpTo(QJsonObject& jo, const T& pod) { jo = pod; } - static void fillFrom(const QJsonObject& jo, T& pod) { pod = jo; } - }; - - template <typename T> struct JsonConverter { - static QJsonObject dump(const T& pod) - { - QJsonObject jo; - JsonObjectConverter<T>::dumpTo(jo, pod); - return jo; - } - static T doLoad(const QJsonObject& jo) - { - T pod; - JsonObjectConverter<T>::fillFrom(jo, pod); - return pod; - } - static T load(const QJsonValue& jv) { return doLoad(jv.toObject()); } - static T load(const QJsonDocument& jd) { return doLoad(jd.object()); } - }; +namespace QMatrixClient +{ +template <typename T> +struct JsonObjectConverter +{ + static void dumpTo(QJsonObject& jo, const T& pod) { jo = pod; } + static void fillFrom(const QJsonObject& jo, T& pod) { pod = jo; } +}; - template <typename T> inline auto toJson(const T& pod) +template <typename T> +struct JsonConverter +{ + static QJsonObject dump(const T& pod) { - return JsonConverter<T>::dump(pod); + QJsonObject jo; + JsonObjectConverter<T>::dumpTo(jo, pod); + return jo; } - - template <typename T> inline auto fillJson(QJsonObject& json, const T& data) + static T doLoad(const QJsonObject& jo) { - JsonObjectConverter<T>::dumpTo(json, data); + T pod; + JsonObjectConverter<T>::fillFrom(jo, pod); + return pod; } + static T load(const QJsonValue& jv) { return doLoad(jv.toObject()); } + static T load(const QJsonDocument& jd) { return doLoad(jd.object()); } +}; + +template <typename T> +inline auto toJson(const T& pod) +{ + return JsonConverter<T>::dump(pod); +} + +template <typename T> +inline auto fillJson(QJsonObject& json, const T& data) +{ + JsonObjectConverter<T>::dumpTo(json, data); +} + +template <typename T> +inline auto fromJson(const QJsonValue& jv) +{ + return JsonConverter<T>::load(jv); +} + +template <typename T> +inline T fromJson(const QJsonDocument& jd) +{ + return JsonConverter<T>::load(jd); +} + +template <typename T> +inline void fromJson(const QJsonValue& jv, T& pod) +{ + if (!jv.isUndefined()) + pod = fromJson<T>(jv); +} + +template <typename T> +inline void fromJson(const QJsonDocument& jd, T& pod) +{ + pod = fromJson<T>(jd); +} + +// Unfolds Omittable<> +template <typename T> +inline void fromJson(const QJsonValue& jv, Omittable<T>& pod) +{ + if (jv.isUndefined()) + pod = none; + else + pod = fromJson<T>(jv); +} + +template <typename T> +inline void fillFromJson(const QJsonValue& jv, T& pod) +{ + if (jv.isObject()) + JsonObjectConverter<T>::fillFrom(jv.toObject(), pod); +} - template <typename T> inline auto fromJson(const QJsonValue& jv) +// JsonConverter<> specialisations + +template <typename T> +struct TrivialJsonDumper +{ + // Works for: QJsonValue (and all things it can consume), + // QJsonObject, QJsonArray + static auto dump(const T& val) { return val; } +}; + +template <> +struct JsonConverter<bool> : public TrivialJsonDumper<bool> +{ + static auto load(const QJsonValue& jv) { return jv.toBool(); } +}; + +template <> +struct JsonConverter<int> : public TrivialJsonDumper<int> +{ + static auto load(const QJsonValue& jv) { return jv.toInt(); } +}; + +template <> +struct JsonConverter<double> : public TrivialJsonDumper<double> +{ + static auto load(const QJsonValue& jv) { return jv.toDouble(); } +}; + +template <> +struct JsonConverter<float> : public TrivialJsonDumper<float> +{ + static auto load(const QJsonValue& jv) { return float(jv.toDouble()); } +}; + +template <> +struct JsonConverter<qint64> : public TrivialJsonDumper<qint64> +{ + static auto load(const QJsonValue& jv) { return qint64(jv.toDouble()); } +}; + +template <> +struct JsonConverter<QString> : public TrivialJsonDumper<QString> +{ + static auto load(const QJsonValue& jv) { return jv.toString(); } +}; + +template <> +struct JsonConverter<QDateTime> +{ + static auto dump(const QDateTime& val) = delete; // not provided yet + static auto load(const QJsonValue& jv) { - return JsonConverter<T>::load(jv); + return QDateTime::fromMSecsSinceEpoch(fromJson<qint64>(jv), Qt::UTC); } +}; - template <typename T> inline T fromJson(const QJsonDocument& jd) +template <> +struct JsonConverter<QDate> +{ + static auto dump(const QDate& val) = delete; // not provided yet + static auto load(const QJsonValue& jv) { - return JsonConverter<T>::load(jd); + return fromJson<QDateTime>(jv).date(); } - - template <typename T> inline void fromJson(const QJsonValue& jv, T& pod) +}; + +template <> +struct JsonConverter<QJsonArray> : public TrivialJsonDumper<QJsonArray> +{ + static auto load(const QJsonValue& jv) { return jv.toArray(); } +}; + +template <> +struct JsonConverter<QByteArray> +{ + static QString dump(const QByteArray& ba) { return ba.constData(); } + static auto load(const QJsonValue& jv) { - if (!jv.isUndefined()) - pod = fromJson<T>(jv); + return fromJson<QString>(jv).toLatin1(); } - - template <typename T> inline void fromJson(const QJsonDocument& jd, T& pod) +}; + +template <> +struct JsonConverter<QVariant> +{ + static QJsonValue dump(const QVariant& v); + static QVariant load(const QJsonValue& jv); +}; + +template <typename VectorT, typename T = typename VectorT::value_type> +struct JsonArrayConverter +{ + static void dumpTo(QJsonArray& ar, const VectorT& vals) { - pod = fromJson<T>(jd); + for (const auto& v : vals) + ar.push_back(toJson(v)); } - - // Unfolds Omittable<> - template <typename T> - inline void fromJson(const QJsonValue& jv, Omittable<T>& pod) + static auto dump(const VectorT& vals) { - if (jv.isUndefined()) - pod = none; - else - pod = fromJson<T>(jv); + QJsonArray ja; + dumpTo(ja, vals); + return ja; } - - template <typename T> inline void fillFromJson(const QJsonValue& jv, T& pod) + static auto load(const QJsonArray& ja) { - if (jv.isObject()) - JsonObjectConverter<T>::fillFrom(jv.toObject(), pod); + VectorT vect; + vect.reserve(typename VectorT::size_type(ja.size())); + for (const auto& i : ja) + vect.push_back(fromJson<T>(i)); + return vect; } + static auto load(const QJsonValue& jv) { return load(jv.toArray()); } + static auto load(const QJsonDocument& jd) { return load(jd.array()); } +}; - // JsonConverter<> specialisations - - template <typename T> struct TrivialJsonDumper { - // Works for: QJsonValue (and all things it can consume), - // QJsonObject, QJsonArray - static auto dump(const T& val) { return val; } - }; - - template <> struct JsonConverter<bool> : public TrivialJsonDumper<bool> { - static auto load(const QJsonValue& jv) { return jv.toBool(); } - }; - - template <> struct JsonConverter<int> : public TrivialJsonDumper<int> { - static auto load(const QJsonValue& jv) { return jv.toInt(); } - }; - - template <> - struct JsonConverter<double> : public TrivialJsonDumper<double> { - static auto load(const QJsonValue& jv) { return jv.toDouble(); } - }; - - template <> struct JsonConverter<float> : public TrivialJsonDumper<float> { - static auto load(const QJsonValue& jv) { return float(jv.toDouble()); } - }; +template <typename T> +struct JsonConverter<std::vector<T>> : public JsonArrayConverter<std::vector<T>> +{}; - template <> - struct JsonConverter<qint64> : public TrivialJsonDumper<qint64> { - static auto load(const QJsonValue& jv) { return qint64(jv.toDouble()); } - }; +template <typename T> +struct JsonConverter<QVector<T>> : public JsonArrayConverter<QVector<T>> +{}; - template <> - struct JsonConverter<QString> : public TrivialJsonDumper<QString> { - static auto load(const QJsonValue& jv) { return jv.toString(); } - }; +template <typename T> +struct JsonConverter<QList<T>> : public JsonArrayConverter<QList<T>> +{}; - template <> struct JsonConverter<QDateTime> { - static auto dump(const QDateTime& val) = delete; // not provided yet - static auto load(const QJsonValue& jv) - { - return QDateTime::fromMSecsSinceEpoch(fromJson<qint64>(jv), - Qt::UTC); - } - }; +template <> +struct JsonConverter<QStringList> : public JsonConverter<QList<QString>> +{ + static auto dump(const QStringList& sl) + { + return QJsonArray::fromStringList(sl); + } +}; - template <> struct JsonConverter<QDate> { - static auto dump(const QDate& val) = delete; // not provided yet - static auto load(const QJsonValue& jv) - { - return fromJson<QDateTime>(jv).date(); - } - }; +template <> +struct JsonObjectConverter<QSet<QString>> +{ + static void dumpTo(QJsonObject& json, const QSet<QString>& s) + { + for (const auto& e : s) + json.insert(toJson(e), QJsonObject {}); + } + static auto fillFrom(const QJsonObject& json, QSet<QString>& s) + { + s.reserve(s.size() + json.size()); + for (auto it = json.begin(); it != json.end(); ++it) + s.insert(it.key()); + return s; + } +}; - template <> - struct JsonConverter<QJsonArray> : public TrivialJsonDumper<QJsonArray> { - static auto load(const QJsonValue& jv) { return jv.toArray(); } - }; +template <typename HashMapT> +struct HashMapFromJson +{ + static void dumpTo(QJsonObject& json, const HashMapT& hashMap) + { + for (auto it = hashMap.begin(); it != hashMap.end(); ++it) + json.insert(it.key(), toJson(it.value())); + } + static void fillFrom(const QJsonObject& jo, HashMapT& h) + { + h.reserve(jo.size()); + for (auto it = jo.begin(); it != jo.end(); ++it) + h[it.key()] = fromJson<typename HashMapT::mapped_type>(it.value()); + } +}; - template <> struct JsonConverter<QByteArray> { - static QString dump(const QByteArray& ba) { return ba.constData(); } - static auto load(const QJsonValue& jv) - { - return fromJson<QString>(jv).toLatin1(); - } - }; +template <typename T> +struct JsonObjectConverter<std::unordered_map<QString, T>> + : public HashMapFromJson<std::unordered_map<QString, T>> +{}; - template <> struct JsonConverter<QVariant> { - static QJsonValue dump(const QVariant& v); - static QVariant load(const QJsonValue& jv); - }; +template <typename T> +struct JsonObjectConverter<QHash<QString, T>> + : public HashMapFromJson<QHash<QString, T>> +{}; + +// We could use std::conditional<> below but QT_VERSION* macros in C++ code +// cause (kinda valid but useless and noisy) compiler warnings about +// bitwise operations on signed integers; so use the preprocessor for now. +using variant_map_t = +#if (QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)) + QVariantHash; +#else + QVariantMap; +#endif +template <> +struct JsonConverter<variant_map_t> +{ + static QJsonObject dump(const variant_map_t& vh); + static QVariantHash load(const QJsonValue& jv); +}; + +// Conditional insertion into a QJsonObject + +namespace _impl +{ + template <typename ValT> + inline void addTo(QJsonObject& o, const QString& k, ValT&& v) + { + o.insert(k, toJson(v)); + } - template <typename VectorT, typename T = typename VectorT::value_type> - struct JsonArrayConverter { - static void dumpTo(QJsonArray& ar, const VectorT& vals) - { - for (const auto& v : vals) - ar.push_back(toJson(v)); - } - static auto dump(const VectorT& vals) - { - QJsonArray ja; - dumpTo(ja, vals); - return ja; - } - static auto load(const QJsonArray& ja) - { - VectorT vect; - vect.reserve(typename VectorT::size_type(ja.size())); - for (const auto& i : ja) - vect.push_back(fromJson<T>(i)); - return vect; - } - static auto load(const QJsonValue& jv) { return load(jv.toArray()); } - static auto load(const QJsonDocument& jd) { return load(jd.array()); } - }; + template <typename ValT> + inline void addTo(QUrlQuery& q, const QString& k, ValT&& v) + { + q.addQueryItem(k, QStringLiteral("%1").arg(v)); + } - template <typename T> - struct JsonConverter<std::vector<T>> - : public JsonArrayConverter<std::vector<T>> { - }; + // OpenAPI is entirely JSON-based, which means representing bools as + // textual true/false, rather than 1/0. + inline void addTo(QUrlQuery& q, const QString& k, bool v) + { + q.addQueryItem(k, v ? QStringLiteral("true") : QStringLiteral("false")); + } - template <typename T> - struct JsonConverter<QVector<T>> : public JsonArrayConverter<QVector<T>> { - }; + inline void addTo(QUrlQuery& q, const QString& k, const QStringList& vals) + { + for (const auto& v : vals) + q.addQueryItem(k, v); + } - template <typename T> - struct JsonConverter<QList<T>> : public JsonArrayConverter<QList<T>> { - }; + inline void addTo(QUrlQuery& q, const QString&, const QJsonObject& vals) + { + for (auto it = vals.begin(); it != vals.end(); ++it) + q.addQueryItem(it.key(), it.value().toString()); + } - template <> - struct JsonConverter<QStringList> : public JsonConverter<QList<QString>> { - static auto dump(const QStringList& sl) + // This one is for types that don't have isEmpty() + template <typename ValT, bool Force = true, typename = bool> + struct AddNode + { + template <typename ContT, typename ForwardedT> + static void impl(ContT& container, const QString& key, + ForwardedT&& value) { - return QJsonArray::fromStringList(sl); + addTo(container, key, std::forward<ForwardedT>(value)); } }; - template <> struct JsonObjectConverter<QSet<QString>> { - static void dumpTo(QJsonObject& json, const QSet<QString>& s) - { - for (const auto& e : s) - json.insert(toJson(e), QJsonObject {}); - } - static auto fillFrom(const QJsonObject& json, QSet<QString>& s) + // This one is for types that have isEmpty() + template <typename ValT> + struct AddNode<ValT, false, decltype(std::declval<ValT>().isEmpty())> + { + template <typename ContT, typename ForwardedT> + static void impl(ContT& container, const QString& key, + ForwardedT&& value) { - s.reserve(s.size() + json.size()); - for (auto it = json.begin(); it != json.end(); ++it) - s.insert(it.key()); - return s; + if (!value.isEmpty()) + AddNode<ValT>::impl(container, key, + std::forward<ForwardedT>(value)); } }; - template <typename HashMapT> struct HashMapFromJson { - static void dumpTo(QJsonObject& json, const HashMapT& hashMap) - { - for (auto it = hashMap.begin(); it != hashMap.end(); ++it) - json.insert(it.key(), toJson(it.value())); - } - static void fillFrom(const QJsonObject& jo, HashMapT& h) + // This is a special one that unfolds Omittable<> + template <typename ValT, bool Force> + struct AddNode<Omittable<ValT>, Force> + { + template <typename ContT, typename OmittableT> + static void impl(ContT& container, const QString& key, + const OmittableT& value) { - h.reserve(jo.size()); - for (auto it = jo.begin(); it != jo.end(); ++it) - h[it.key()] = - fromJson<typename HashMapT::mapped_type>(it.value()); + if (!value.omitted()) + AddNode<ValT>::impl(container, key, value.value()); + else if (Force) // Edge case, no value but must put something + AddNode<ValT>::impl(container, key, QString {}); } }; - template <typename T> - struct JsonObjectConverter<std::unordered_map<QString, T>> - : public HashMapFromJson<std::unordered_map<QString, T>> { - }; - - template <typename T> - struct JsonObjectConverter<QHash<QString, T>> - : public HashMapFromJson<QHash<QString, T>> { - }; - - // We could use std::conditional<> below but QT_VERSION* macros in C++ code - // cause (kinda valid but useless and noisy) compiler warnings about - // bitwise operations on signed integers; so use the preprocessor for now. - using variant_map_t = -#if (QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)) - QVariantHash; -#else - QVariantMap; -#endif - template <> struct JsonConverter<variant_map_t> { - static QJsonObject dump(const variant_map_t& vh); - static QVariantHash load(const QJsonValue& jv); - }; - - // Conditional insertion into a QJsonObject - - namespace _impl { - template <typename ValT> - inline void addTo(QJsonObject& o, const QString& k, ValT&& v) - { - o.insert(k, toJson(v)); - } - - template <typename ValT> - inline void addTo(QUrlQuery& q, const QString& k, ValT&& v) - { - q.addQueryItem(k, QStringLiteral("%1").arg(v)); - } - - // OpenAPI is entirely JSON-based, which means representing bools as - // textual true/false, rather than 1/0. - inline void addTo(QUrlQuery& q, const QString& k, bool v) - { - q.addQueryItem( - k, v ? QStringLiteral("true") : QStringLiteral("false")); - } - - inline void addTo(QUrlQuery& q, const QString& k, - const QStringList& vals) - { - for (const auto& v : vals) - q.addQueryItem(k, v); - } - - inline void addTo(QUrlQuery& q, const QString&, const QJsonObject& vals) - { - for (auto it = vals.begin(); it != vals.end(); ++it) - q.addQueryItem(it.key(), it.value().toString()); - } - - // This one is for types that don't have isEmpty() - template <typename ValT, bool Force = true, typename = bool> - struct AddNode { - template <typename ContT, typename ForwardedT> - static void impl(ContT& container, const QString& key, - ForwardedT&& value) - { - addTo(container, key, std::forward<ForwardedT>(value)); - } - }; - - // This one is for types that have isEmpty() - template <typename ValT> - struct AddNode<ValT, false, decltype(std::declval<ValT>().isEmpty())> { - template <typename ContT, typename ForwardedT> - static void impl(ContT& container, const QString& key, - ForwardedT&& value) - { - if (!value.isEmpty()) - AddNode<ValT>::impl(container, key, - std::forward<ForwardedT>(value)); - } - }; - - // This is a special one that unfolds Omittable<> - template <typename ValT, bool Force> - struct AddNode<Omittable<ValT>, Force> { - template <typename ContT, typename OmittableT> - static void impl(ContT& container, const QString& key, - const OmittableT& value) - { - if (!value.omitted()) - AddNode<ValT>::impl(container, key, value.value()); - else if (Force) // Edge case, no value but must put something - AddNode<ValT>::impl(container, key, QString {}); - } - }; - #if 0 // This is a special one that unfolds optional<> template <typename ValT, bool Force> @@ -385,14 +427,14 @@ namespace QMatrixClient { }; #endif - } // namespace _impl +} // namespace _impl - static constexpr bool IfNotEmpty = false; +static constexpr bool IfNotEmpty = false; - template <bool Force = true, typename ContT, typename ValT> - inline void addParam(ContT& container, const QString& key, ValT&& value) - { - _impl::AddNode<std::decay_t<ValT>, Force>::impl( - container, key, std::forward<ValT>(value)); - } +template <bool Force = true, typename ContT, typename ValT> +inline void addParam(ContT& container, const QString& key, ValT&& value) +{ + _impl::AddNode<std::decay_t<ValT>, Force>::impl(container, key, + std::forward<ValT>(value)); +} } // namespace QMatrixClient |