| QxOrm 1.4.8 C++ Object Relational Mapping library

- Main Page
- Modules
- Namespaces
- Classes
- Files
- Directories

- File List
- File Members

QxConvert_Impl.h
Go to the documentation of this file.

    00001 /****************************************************************************
    00002 **
    00003 ** https://www.qxorm.com/
    00004 ** Copyright (C) 2013 Lionel Marty (contact@qxorm.com)
    00005 **
    00006 ** This file is part of the QxOrm library
    00007 **
    00008 ** This software is provided 'as-is', without any express or implied
    00009 ** warranty. In no event will the authors be held liable for any
    00010 ** damages arising from the use of this software
    00011 **
    00012 ** Commercial Usage
    00013 ** Licensees holding valid commercial QxOrm licenses may use this file in
    00014 ** accordance with the commercial license agreement provided with the
    00015 ** Software or, alternatively, in accordance with the terms contained in
    00016 ** a written agreement between you and Lionel Marty
    00017 **
    00018 ** GNU General Public License Usage
    00019 ** Alternatively, this file may be used under the terms of the GNU
    00020 ** General Public License version 3.0 as published by the Free Software
    00021 ** Foundation and appearing in the file 'license.gpl3.txt' included in the
    00022 ** packaging of this file. Please review the following information to
    00023 ** ensure the GNU General Public License version 3.0 requirements will be
    00024 ** met : http://www.gnu.org/copyleft/gpl.html
    00025 **
    00026 ** If you are unsure which license is appropriate for your use, or
    00027 ** if you have questions regarding the use of this file, please contact :
    00028 ** contact@qxorm.com
    00029 **
    00030 ****************************************************************************/
    00031
    00032 #ifndef _QX_CONVERT_IMPL_H_
    00033 #define _QX_CONVERT_IMPL_H_
    00034
    00035 #ifdef _MSC_VER
    00036 #pragma once
    00037 #endif
    00038
    00039 #include <QxConvert/QxConvert.h>
    00040 #include <QxCommon/QxBool.h>
    00041
    00042 #include <QxDao/QxDateNeutral.h>
    00043 #include <QxDao/QxTimeNeutral.h>
    00044 #include <QxDao/QxDateTimeNeutral.h>
    00045 #include <QxDao/QxSqlQuery.h>
    00046 #include <QxDao/IxPersistable.h>
    00047
    00048 #include <QxCollection/QxCollection.h>
    00049
    00050 #include <QxRegister/QxClass.h>
    00051
    00052 #include <QxSerialize/QxArchive.h>
    00053 #include <QxSerialize/QxSerializeQDataStream.h>
    00054 #include <QxSerialize/QDataStream/QxSerializeQDataStream_all_include.h>
    00055 #include <QxSerialize/QJson/QxSerializeQJson_qx_registered_class.h>
    00056
    00057 #include <QxValidator/QxInvalidValue.h>
    00058 #include <QxValidator/QxInvalidValueX.h>
    00059
    00060 #include <QxTraits/is_smart_ptr.h>
    00061 #include <QxTraits/is_container.h>
    00062 #include <QxTraits/is_qx_registered.h>
    00063 #include <QxTraits/is_qt_variant_compatible.h>
    00064 #include <QxTraits/get_class_name_primitive.h>
    00065 #include <QxTraits/construct_ptr.h>
    00066 #include <QxTraits/generic_container.h>
    00067
    00068 #define QX_STR_CVT_QDATE_FORMAT        "yyyyMMdd"
    00069 #define QX_STR_CVT_QTIME_FORMAT        "hhmmsszzz"
    00070 #define QX_STR_CVT_QDATETIME_FORMAT    "yyyyMMddhhmmsszzz"
    00071
    00072 #ifdef _QX_ENABLE_BOOST_SERIALIZATION
    00073 #if _QX_SERIALIZE_POLYMORPHIC
    00074 #define QX_CVT_DEFAULT_ARCHIVE         qx::serialization::polymorphic_xml
    00075 #elif _QX_SERIALIZE_XML
    00076 #define QX_CVT_DEFAULT_ARCHIVE         qx::serialization::xml
    00077 #elif _QX_SERIALIZE_TEXT
    00078 #define QX_CVT_DEFAULT_ARCHIVE         qx::serialization::text
    00079 #elif _QX_SERIALIZE_BINARY
    00080 #define QX_CVT_DEFAULT_ARCHIVE         qx::serialization::binary
    00081 #endif // _QX_SERIALIZE_XML
    00082 #else // _QX_ENABLE_BOOST_SERIALIZATION
    00083 #define QX_CVT_DEFAULT_ARCHIVE         qx::serialization::qt
    00084 #endif // _QX_ENABLE_BOOST_SERIALIZATION
    00085
    00086 #define QX_CVT_USING_ARCHIVE_IMPL(className) \
    00087 namespace qx { namespace cvt { namespace detail { \
    00088 template <> struct QxConvert_ToString< className > { \
    00089 static inline QString toString(const className & t, const QString & format, int index, qx::cvt::context::ctx_type ctx) \
    00090 { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::to_string(t); } }; \
    00091 template <> struct QxConvert_FromString< className > { \
    00092 static inline qx_bool fromString(const QString & s, className & t, const QString & format, int index, qx::cvt::context::ctx_type ctx) \
    00093 { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::from_string(t, s); } }; \
    00094 template <> struct QxConvert_ToVariant< className > { \
    00095 static inline QVariant toVariant(const className & t, const QString & format, int index, qx::cvt::context::ctx_type ctx) \
    00096 { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::to_string(t); } }; \
    00097 template <> struct QxConvert_FromVariant< className > { \
    00098 static inline qx_bool fromVariant(const QVariant & v, className & t, const QString & format, int index, qx::cvt::context::ctx_type ctx) \
    00099 { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); QString s = v.toString(); return QX_CVT_DEFAULT_ARCHIVE::from_string(t, s); } }; \
    00100 } } } // namespace qx::cvt::detail
    00101
    00102 #if (QT_VERSION >= 0x050800)
    00103 #define QX_JSON_DATE_TIME_FORMAT Qt::ISODateWithMs
    00104 #define QX_JSON_DATE_TIME_FORMAT_SIZE 23 // yyyy-MM-ddTHH:mm:ss.zzz
    00105 #else // (QT_VERSION >= 0x050800)
    00106 #define QX_JSON_DATE_TIME_FORMAT Qt::ISODate
    00107 #define QX_JSON_DATE_TIME_FORMAT_SIZE 19 // yyyy-MM-ddTHH:mm:ss
    00108 #endif // (QT_VERSION >= 0x050800)
    00109
    00110 namespace qx {
    00111 namespace cvt {
    00112 namespace detail {
    00113 namespace helper {
    00114
    00115 struct QxConvertHelper_Generic { };
    00116 struct QxConvertHelper_Ptr { };
    00117 struct QxConvertHelper_Registered { };
    00118 struct QxConvertHelper_Persistable { };
    00119 struct QxConvertHelper_Container { };
    00120 struct QxConvertHelper_Enum { };
    00121
    00122 inline bool checkConvertQVariantToString(const QVariant & v) { return ((v.type() == QVariant::List) || (v.type() == QVariant::Map) || (v.type() == QVariant::Hash) || (v.type() == QVariant::StringList)); }
    00123
    00124 } // namespace helper
    00125
    00126 template <typename T, typename H>
    00127 struct QxConvertHelper_ToString
    00128 {
    00129    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00130    { qAssertMsg(false, "qx::cvt::detail::QxConvertHelper_ToString", "template must be specialized"); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QString(); }
    00131 };
    00132
    00133 template <typename T, typename H>
    00134 struct QxConvertHelper_FromString
    00135 {
    00136    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00137    { qAssertMsg(false, "qx::cvt::detail::QxConvertHelper_FromString", "template must be specialized"); Q_UNUSED(s); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return qx_bool(); }
    00138 };
    00139
    00140 template <typename T, typename H>
    00141 struct QxConvertHelper_ToVariant
    00142 {
    00143    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00144    { qAssertMsg(false, "qx::cvt::detail::QxConvertHelper_ToVariant", "template must be specialized"); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QVariant(); }
    00145 };
    00146
    00147 template <typename T, typename H>
    00148 struct QxConvertHelper_FromVariant
    00149 {
    00150    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00151    { qAssertMsg(false, "qx::cvt::detail::QxConvertHelper_FromVariant", "template must be specialized"); Q_UNUSED(v); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return qx_bool(); }
    00152 };
    00153
    00154 #ifndef _QX_NO_JSON
    00155
    00156 template <typename T, typename H>
    00157 struct QxConvertHelper_ToJson
    00158 {
    00159    static inline QJsonValue toJson(const T & t, const QString & format)
    00160    { qAssertMsg(false, "qx::cvt::detail::QxConvertHelper_ToJson", "template must be specialized"); Q_UNUSED(t); Q_UNUSED(format); return QJsonValue(); }
    00161 };
    00162
    00163 template <typename T, typename H>
    00164 struct QxConvertHelper_FromJson
    00165 {
    00166    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
    00167    { qAssertMsg(false, "qx::cvt::detail::QxConvertHelper_FromJson", "template must be specialized"); Q_UNUSED(j); Q_UNUSED(t); Q_UNUSED(format); return qx_bool(); }
    00168 };
    00169
    00170 #endif // _QX_NO_JSON
    00171
    00172 template <typename T>
    00173 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
    00174 {
    00175
    00176    enum { qx_need_to_specialize_template_convert_to_string_from_string = 0 };
    00177
    00178    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00179    {
    00180       Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
    00181       static_assert(qx_need_to_specialize_template_convert_to_string_from_string, "qx_need_to_specialize_template_convert_to_string_from_string"); // If a compilation error occurred here : you have to specialize template 'qx::cvt::detail::QxConvert_ToString< MyType >'
    00182       return QString();
    00183    }
    00184
    00185 };
    00186
    00187 template <typename T>
    00188 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
    00189 {
    00190
    00191    enum { qx_need_to_specialize_template_convert_to_string_from_string = 0 };
    00192
    00193    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00194    {
    00195       Q_UNUSED(s); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
    00196       static_assert(qx_need_to_specialize_template_convert_to_string_from_string, "qx_need_to_specialize_template_convert_to_string_from_string"); // If a compilation error occurred here : you have to specialize template 'qx::cvt::detail::QxConvert_FromString< MyType >'
    00197       return qx_bool(true);
    00198    }
    00199
    00200 };
    00201
    00202 template <typename T>
    00203 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
    00204 {
    00205
    00206    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00207    { return cvtQVariant<qx::trait::is_qt_variant_compatible<T>::value, 0>::toVariant(t, format, index, ctx); }
    00208
    00209 private:
    00210
    00211    template <bool isQVariantCompatible /* = false */, int dummy>
    00212    struct cvtQVariant
    00213    { static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx) { return qx::cvt::to_string(t, format, index, ctx); }; };
    00214
    00215    template <int dummy>
    00216    struct cvtQVariant<true, dummy>
    00217    { static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx) { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QVariant(t); }; };
    00218
    00219 };
    00220
    00221 template <typename T>
    00222 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
    00223 {
    00224
    00225    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00226    { return cvtQVariant<qx::trait::is_qt_variant_compatible<T>::value, 0>::fromVariant(v, t, format, index, ctx); }
    00227
    00228 private:
    00229
    00230    template <bool isQVariantCompatible /* = false */, int dummy>
    00231    struct cvtQVariant
    00232    { static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx) { return qx::cvt::from_string(v.toString(), t, format, index, ctx); }; };
    00233
    00234    template <int dummy>
    00235    struct cvtQVariant<true, dummy>
    00236    { static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx) { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); t = v.value<T>(); return qx_bool(true); }; };
    00237
    00238 };
    00239
    00240 #ifndef _QX_NO_JSON
    00241
    00242 template <typename T>
    00243 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
    00244 {
    00245    static inline QJsonValue toJson(const T & t, const QString & format)
    00246    { return QJsonValue::fromVariant(qx::cvt::detail::QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Generic>::toVariant(t, format, -1, qx::cvt::context::e_no_context)); }
    00247 };
    00248
    00249 template <typename T>
    00250 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
    00251 {
    00252    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
    00253    { QVariant v = j.toVariant(); return qx::cvt::detail::QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Generic>::fromVariant(v, t, format, -1, qx::cvt::context::e_no_context); }
    00254 };
    00255
    00256 #endif // _QX_NO_JSON
    00257
    00258 template <typename T>
    00259 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
    00260 {
    00261
    00262    enum { qx_need_to_specialize_template_convert_to_string_from_string = 0 };
    00263
    00264    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00265    {
    00266       Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
    00267 #ifndef _QX_NO_JSON
    00268       return t.toJson(format);
    00269 #else // _QX_NO_JSON
    00270       static_assert(qx_need_to_specialize_template_convert_to_string_from_string, "qx_need_to_specialize_template_convert_to_string_from_string"); // If a compilation error occurred here : you have to specialize template 'qx::cvt::detail::QxConvert_ToString< MyType >'
    00271       return QString();
    00272 #endif // _QX_NO_JSON
    00273    }
    00274
    00275 };
    00276
    00277 template <typename T>
    00278 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
    00279 {
    00280
    00281    enum { qx_need_to_specialize_template_convert_to_string_from_string = 0 };
    00282
    00283    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00284    {
    00285       Q_UNUSED(s); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
    00286 #ifndef _QX_NO_JSON
    00287       return t.fromJson(s, format);
    00288 #else // _QX_NO_JSON
    00289       static_assert(qx_need_to_specialize_template_convert_to_string_from_string, "qx_need_to_specialize_template_convert_to_string_from_string"); // If a compilation error occurred here : you have to specialize template 'qx::cvt::detail::QxConvert_FromString< MyType >'
    00290       return qx_bool(true);
    00291 #endif // _QX_NO_JSON
    00292    }
    00293
    00294 };
    00295
    00296 template <typename T>
    00297 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
    00298 {
    00299
    00300    enum { qx_need_to_specialize_template_convert_to_variant_from_variant = 0 };
    00301
    00302    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00303    {
    00304       Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
    00305 #ifndef _QX_NO_JSON
    00306       return QVariant(t.toJson(format));
    00307 #else // _QX_NO_JSON
    00308       static_assert(qx_need_to_specialize_template_convert_to_variant_from_variant, "qx_need_to_specialize_template_convert_to_variant_from_variant"); // If a compilation error occurred here : you have to specialize template 'qx::cvt::detail::QxConvert_ToVariant< MyType >'
    00309       return QVariant();
    00310 #endif // _QX_NO_JSON
    00311    }
    00312
    00313 };
    00314
    00315 template <typename T>
    00316 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
    00317 {
    00318
    00319    enum { qx_need_to_specialize_template_convert_to_variant_from_variant = 0 };
    00320
    00321    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00322    {
    00323       Q_UNUSED(v); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
    00324 #ifndef _QX_NO_JSON
    00325       return t.fromJson(v.toString(), format);
    00326 #else // _QX_NO_JSON
    00327       static_assert(qx_need_to_specialize_template_convert_to_variant_from_variant, "qx_need_to_specialize_template_convert_to_variant_from_variant"); // If a compilation error occurred here : you have to specialize template 'qx::cvt::detail::QxConvert_FromVariant< MyType >'
    00328       return qx_bool(true);
    00329 #endif // _QX_NO_JSON
    00330    }
    00331
    00332 };
    00333
    00334 #ifndef _QX_NO_JSON
    00335
    00336 template <typename T>
    00337 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
    00338 {
    00339    static inline QJsonValue toJson(const T & t, const QString & format)
    00340    { const qx::IxPersistable * p = static_cast<const qx::IxPersistable *>(& t); return qx::cvt::to_json((* p), format); }
    00341 };
    00342
    00343 template <typename T>
    00344 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
    00345 {
    00346    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
    00347    { qx::IxPersistable * p = static_cast<qx::IxPersistable *>(& t); return qx::cvt::from_json(j, (* p), format); }
    00348 };
    00349
    00350 #endif // _QX_NO_JSON
    00351
    00352 template <typename T>
    00353 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
    00354 {
    00355    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00356    { return (t ? qx::cvt::to_string((* t), format, index, ctx) : ""); }
    00357 };
    00358
    00359 template <typename T>
    00360 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
    00361 {
    00362    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00363    { if (! t) { qx::trait::construct_ptr<T>::get(t); }; return (t ? qx::cvt::from_string(s, (* t), format, index, ctx) : qx_bool(false)); }
    00364 };
    00365
    00366 template <typename T>
    00367 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
    00368 {
    00369    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00370    { return (t ? qx::cvt::to_variant((* t), format, index, ctx) : QVariant()); }
    00371 };
    00372
    00373 template <typename T>
    00374 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
    00375 {
    00376    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00377    { if (! t && ! v.isNull()) { qx::trait::construct_ptr<T>::get(t); } else if (v.isNull()) { qx::trait::construct_ptr<T>::get(t, true); }; return (t ? qx::cvt::from_variant(v, (* t), format, index, ctx) : qx_bool(false)); }
    00378 };
    00379
    00380 #ifndef _QX_NO_JSON
    00381
    00382 template <typename T>
    00383 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
    00384 {
    00385    static inline QJsonValue toJson(const T & t, const QString & format)
    00386    { return (t ? qx::cvt::to_json((* t), format) : QJsonValue()); }
    00387 };
    00388
    00389 template <typename T>
    00390 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
    00391 {
    00392    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
    00393    { if (! t && ! j.isNull()) { qx::trait::construct_ptr<T>::get(t); } else if (j.isNull()) { qx::trait::construct_ptr<T>::get(t, true); }; return (t ? qx::cvt::from_json(j, (* t), format) : qx_bool(false)); }
    00394 };
    00395
    00396 #endif // _QX_NO_JSON
    00397
    00398 template <typename T>
    00399 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
    00400 {
    00401    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00402    {
    00403       if (ctx != qx::cvt::context::e_serialize_registered)
    00404       { qx::IxDataMember * pId = qx::QxClass<T>::getSingleton()->getDataMemberX()->getId_WithDaoStrategy(); return (pId ? pId->toVariant((& t), format, index, ctx).toString() : QString()); }
    00405       return qx::serialization::qt::to_string<T>(t);
    00406    }
    00407 };
    00408
    00409 template <typename T>
    00410 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
    00411 {
    00412    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00413    {
    00414       if (ctx != qx::cvt::context::e_serialize_registered)
    00415       { qx::IxDataMember * pId = qx::QxClass<T>::getSingleton()->getDataMemberX()->getId_WithDaoStrategy(); QVariant tmp(s); return (pId ? pId->fromVariant((& t), tmp, format, index, ctx) : qx_bool(false)); }
    00416       return qx::serialization::qt::from_string<T>(t, s);
    00417    }
    00418 };
    00419
    00420 template <typename T>
    00421 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
    00422 {
    00423    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00424    {
    00425       if (ctx != qx::cvt::context::e_serialize_registered)
    00426       { qx::IxDataMember * pId = qx::QxClass<T>::getSingleton()->getDataMemberX()->getId_WithDaoStrategy(); return (pId ? pId->toVariant((& t), format, index, ctx) : QVariant()); }
    00427       return qx::serialization::qt::to_byte_array<T>(t);
    00428    }
    00429 };
    00430
    00431 template <typename T>
    00432 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
    00433 {
    00434    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00435    {
    00436       if (ctx != qx::cvt::context::e_serialize_registered)
    00437       { qx::IxDataMember * pId = qx::QxClass<T>::getSingleton()->getDataMemberX()->getId_WithDaoStrategy(); return (pId ? pId->fromVariant((& t), v, format, index, ctx) : qx_bool(false)); }
    00438       return qx::serialization::qt::from_byte_array<T>(t, v.toByteArray());
    00439    }
    00440 };
    00441
    00442 #ifndef _QX_NO_JSON
    00443
    00444 template <typename T>
    00445 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
    00446 {
    00447    static inline QJsonValue toJson(const T & t, const QString & format)
    00448    { return qx::cvt::detail::QxSerializeJsonRegistered<T>::save(t, format); }
    00449 };
    00450
    00451 template <typename T>
    00452 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
    00453 {
    00454    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
    00455    { return qx::cvt::detail::QxSerializeJsonRegistered<T>::load(j, t, format); }
    00456 };
    00457
    00458 #endif // _QX_NO_JSON
    00459
    00460 template <typename T>
    00461 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Container>
    00462 {
    00463    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00464    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::to_string(t); }
    00465 };
    00466
    00467 template <typename T>
    00468 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Container>
    00469 {
    00470    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00471    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::from_string(t, s); }
    00472 };
    00473
    00474 template <typename T>
    00475 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Container>
    00476 {
    00477    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00478    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::to_string(t); }
    00479 };
    00480
    00481 template <typename T>
    00482 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Container>
    00483 {
    00484    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00485    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::from_string(t, v.toString()); }
    00486 };
    00487
    00488 #ifndef _QX_NO_JSON
    00489
    00490 template <typename T>
    00491 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Container>
    00492 {
    00493    static inline QJsonValue toJson(const T & t, const QString & format)
    00494    { return QJsonValue::fromVariant(qx::cvt::detail::QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Container>::toVariant(t, format, -1, qx::cvt::context::e_no_context)); }
    00495 };
    00496
    00497 template <typename T>
    00498 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Container>
    00499 {
    00500    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
    00501    { QVariant v = j.toVariant(); return qx::cvt::detail::QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Container>::fromVariant(v, t, format, -1, qx::cvt::context::e_no_context); }
    00502 };
    00503
    00504 #endif // _QX_NO_JSON
    00505
    00506 template <typename T>
    00507 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
    00508 {
    00509    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00510    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QString::number(static_cast<long>(t)); }
    00511 };
    00512
    00513 template <typename T>
    00514 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
    00515 {
    00516    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00517    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); bool bOk = false; t = static_cast<T>(static_cast<long>(s.toLongLong(& bOk))); return bOk; }
    00518 };
    00519
    00520 template <typename T>
    00521 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
    00522 {
    00523    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00524    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QVariant(static_cast<qlonglong>(t)); }
    00525 };
    00526
    00527 template <typename T>
    00528 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
    00529 {
    00530    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00531    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); bool bOk = false; t = static_cast<T>(static_cast<long>(v.toLongLong(& bOk))); return bOk; }
    00532 };
    00533
    00534 #ifndef _QX_NO_JSON
    00535
    00536 template <typename T>
    00537 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
    00538 {
    00539    static inline QJsonValue toJson(const T & t, const QString & format)
    00540    { Q_UNUSED(format); return QJsonValue(static_cast<int>(t)); }
    00541 };
    00542
    00543 template <typename T>
    00544 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
    00545 {
    00546    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
    00547    { Q_UNUSED(format); t = static_cast<T>(static_cast<long>(qRound(j.toDouble()))); return qx_bool(true); }
    00548 };
    00549
    00550 #endif // _QX_NO_JSON
    00551
    00552 template <typename T>
    00553 struct QxConvertHelper
    00554 {
    00555
    00556 private:
    00557
    00558    typedef typename std::conditional< qx::trait::is_ix_persistable<T>::value, qx::cvt::detail::helper::QxConvertHelper_Persistable, qx::cvt::detail::helper::QxConvertHelper_Generic >::type type_str_cvt_helper_0;
    00559    typedef typename std::conditional< std::is_pointer<T>::value, qx::cvt::detail::helper::QxConvertHelper_Ptr, type_str_cvt_helper_0 >::type type_str_cvt_helper_1;
    00560    typedef typename std::conditional< qx::trait::is_smart_ptr<T>::value, qx::cvt::detail::helper::QxConvertHelper_Ptr, type_str_cvt_helper_1 >::type type_str_cvt_helper_2;
    00561    typedef typename std::conditional< qx::trait::is_container<T>::value, qx::cvt::detail::helper::QxConvertHelper_Container, type_str_cvt_helper_2 >::type type_str_cvt_helper_3;
    00562    typedef typename std::conditional< qx::trait::is_qx_registered<T>::value, qx::cvt::detail::helper::QxConvertHelper_Registered, type_str_cvt_helper_3 >::type type_str_cvt_helper_4;
    00563    typedef typename std::conditional< std::is_enum<T>::value, qx::cvt::detail::helper::QxConvertHelper_Enum, type_str_cvt_helper_4 >::type type_str_cvt_helper_5;
    00564
    00565 public:
    00566
    00567    typedef typename QxConvertHelper<T>::type_str_cvt_helper_5 type;
    00568
    00569 };
    00570
    00571 template <typename T>
    00572 struct QxConvert_ToString
    00573 {
    00574    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00575    { return qx::cvt::detail::QxConvertHelper_ToString<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::toString(t, format, index, ctx); }
    00576 };
    00577
    00578 template <typename T>
    00579 struct QxConvert_FromString
    00580 {
    00581    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00582    { return qx::cvt::detail::QxConvertHelper_FromString<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::fromString(s, t, format, index, ctx); }
    00583 };
    00584
    00585 template <typename T>
    00586 struct QxConvert_ToVariant
    00587 {
    00588    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00589    { return qx::cvt::detail::QxConvertHelper_ToVariant<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::toVariant(t, format, index, ctx); }
    00590 };
    00591
    00592 template <typename T>
    00593 struct QxConvert_FromVariant
    00594 {
    00595    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
    00596    { return qx::cvt::detail::QxConvertHelper_FromVariant<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::fromVariant(v, t, format, index, ctx); }
    00597 };
    00598
    00599 #ifndef _QX_NO_JSON
    00600
    00601 template <typename T>
    00602 struct QxConvert_ToJson
    00603 {
    00604    static inline QJsonValue toJson(const T & t, const QString & format)
    00605    { return qx::cvt::detail::QxConvertHelper_ToJson<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::toJson(t, format); }
    00606 };
    00607
    00608 template <typename T>
    00609 struct QxConvert_FromJson
    00610 {
    00611    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
    00612    { return qx::cvt::detail::QxConvertHelper_FromJson<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::fromJson(j, t, format); }
    00613 };
    00614
    00615 #endif // _QX_NO_JSON
    00616
    00617 } // namespace detail
    00618 } // namespace cvt
    00619 } // namespace qx
    00620
    00621 #include "../../inl/QxConvert/QxConvert_WithIndex.inl"
    00622 #include "../../inl/QxConvert/QxConvert_ToString.inl"
    00623 #include "../../inl/QxConvert/QxConvert_FromString.inl"
    00624 #include "../../inl/QxConvert/QxConvert_ToVariant.inl"
    00625 #include "../../inl/QxConvert/QxConvert_FromVariant.inl"
    00626 #include "../../inl/QxConvert/QxConvert_ToJson.inl"
    00627 #include "../../inl/QxConvert/QxConvert_FromJson.inl"
    00628 #include "../../inl/QxConvert/QxConvert_Qt.inl"
    00629
    00630 #endif // _QX_CONVERT_IMPL_H_