QxOrm  1.4.5
C++ Object Relational Mapping library
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 namespace qx {
00103 namespace cvt {
00104 namespace detail {
00105 namespace helper {
00106 
00107 struct QxConvertHelper_Generic { };
00108 struct QxConvertHelper_Ptr { };
00109 struct QxConvertHelper_Registered { };
00110 struct QxConvertHelper_Persistable { };
00111 struct QxConvertHelper_Container { };
00112 struct QxConvertHelper_Enum { };
00113 
00114 inline bool checkConvertQVariantToString(const QVariant & v) { return ((v.type() == QVariant::List) || (v.type() == QVariant::Map) || (v.type() == QVariant::Hash) || (v.type() == QVariant::StringList)); }
00115 
00116 } // namespace helper
00117 
00118 template <typename T, typename H>
00119 struct QxConvertHelper_ToString
00120 {
00121    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00122    { 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(); }
00123 };
00124 
00125 template <typename T, typename H>
00126 struct QxConvertHelper_FromString
00127 {
00128    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00129    { 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(); }
00130 };
00131 
00132 template <typename T, typename H>
00133 struct QxConvertHelper_ToVariant
00134 {
00135    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00136    { 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(); }
00137 };
00138 
00139 template <typename T, typename H>
00140 struct QxConvertHelper_FromVariant
00141 {
00142    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00143    { 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(); }
00144 };
00145 
00146 #ifndef _QX_NO_JSON
00147 
00148 template <typename T, typename H>
00149 struct QxConvertHelper_ToJson
00150 {
00151    static inline QJsonValue toJson(const T & t, const QString & format)
00152    { qAssertMsg(false, "qx::cvt::detail::QxConvertHelper_ToJson", "template must be specialized"); Q_UNUSED(t); Q_UNUSED(format); return QJsonValue(); }
00153 };
00154 
00155 template <typename T, typename H>
00156 struct QxConvertHelper_FromJson
00157 {
00158    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
00159    { qAssertMsg(false, "qx::cvt::detail::QxConvertHelper_FromJson", "template must be specialized"); Q_UNUSED(j); Q_UNUSED(t); Q_UNUSED(format); return qx_bool(); }
00160 };
00161 
00162 #endif // _QX_NO_JSON
00163 
00164 template <typename T>
00165 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
00166 {
00167 
00168    enum { qx_need_to_specialize_template_convert_to_string_from_string = 0 };
00169 
00170    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00171    {
00172       Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
00173       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 >'
00174       return QString();
00175    }
00176 
00177 };
00178 
00179 template <typename T>
00180 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
00181 {
00182 
00183    enum { qx_need_to_specialize_template_convert_to_string_from_string = 0 };
00184 
00185    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00186    {
00187       Q_UNUSED(s); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
00188       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 >'
00189       return qx_bool(true);
00190    }
00191 
00192 };
00193 
00194 template <typename T>
00195 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
00196 {
00197 
00198    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00199    { return cvtQVariant<qx::trait::is_qt_variant_compatible<T>::value, 0>::toVariant(t, format, index, ctx); }
00200 
00201 private:
00202 
00203    template <bool isQVariantCompatible /* = false */, int dummy>
00204    struct cvtQVariant
00205    { 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); }; };
00206 
00207    template <int dummy>
00208    struct cvtQVariant<true, dummy>
00209    { 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); }; };
00210 
00211 };
00212 
00213 template <typename T>
00214 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
00215 {
00216 
00217    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00218    { return cvtQVariant<qx::trait::is_qt_variant_compatible<T>::value, 0>::fromVariant(v, t, format, index, ctx); }
00219 
00220 private:
00221 
00222    template <bool isQVariantCompatible /* = false */, int dummy>
00223    struct cvtQVariant
00224    { 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); }; };
00225 
00226    template <int dummy>
00227    struct cvtQVariant<true, dummy>
00228    { 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); }; };
00229 
00230 };
00231 
00232 #ifndef _QX_NO_JSON
00233 
00234 template <typename T>
00235 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
00236 {
00237    static inline QJsonValue toJson(const T & t, const QString & format)
00238    { 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)); }
00239 };
00240 
00241 template <typename T>
00242 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Generic>
00243 {
00244    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
00245    { 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); }
00246 };
00247 
00248 #endif // _QX_NO_JSON
00249 
00250 template <typename T>
00251 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
00252 {
00253 
00254    enum { qx_need_to_specialize_template_convert_to_string_from_string = 0 };
00255 
00256    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00257    {
00258       Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
00259 #ifndef _QX_NO_JSON
00260       return t.toJson(format);
00261 #else // _QX_NO_JSON
00262       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 >'
00263       return QString();
00264 #endif // _QX_NO_JSON
00265    }
00266 
00267 };
00268 
00269 template <typename T>
00270 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
00271 {
00272 
00273    enum { qx_need_to_specialize_template_convert_to_string_from_string = 0 };
00274 
00275    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00276    {
00277       Q_UNUSED(s); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
00278 #ifndef _QX_NO_JSON
00279       return t.fromJson(s, format);
00280 #else // _QX_NO_JSON
00281       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 >'
00282       return qx_bool(true);
00283 #endif // _QX_NO_JSON
00284    }
00285 
00286 };
00287 
00288 template <typename T>
00289 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
00290 {
00291 
00292    enum { qx_need_to_specialize_template_convert_to_variant_from_variant = 0 };
00293 
00294    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00295    {
00296       Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
00297 #ifndef _QX_NO_JSON
00298       return QVariant(t.toJson(format));
00299 #else // _QX_NO_JSON
00300       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 >'
00301       return QVariant();
00302 #endif // _QX_NO_JSON
00303    }
00304 
00305 };
00306 
00307 template <typename T>
00308 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
00309 {
00310 
00311    enum { qx_need_to_specialize_template_convert_to_variant_from_variant = 0 };
00312 
00313    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00314    {
00315       Q_UNUSED(v); Q_UNUSED(t); Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx);
00316 #ifndef _QX_NO_JSON
00317       return t.fromJson(v.toString(), format);
00318 #else // _QX_NO_JSON
00319       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 >'
00320       return qx_bool(true);
00321 #endif // _QX_NO_JSON
00322    }
00323 
00324 };
00325 
00326 #ifndef _QX_NO_JSON
00327 
00328 template <typename T>
00329 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
00330 {
00331    static inline QJsonValue toJson(const T & t, const QString & format)
00332    { const qx::IxPersistable * p = static_cast<const qx::IxPersistable *>(& t); return qx::cvt::to_json((* p), format); }
00333 };
00334 
00335 template <typename T>
00336 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Persistable>
00337 {
00338    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
00339    { qx::IxPersistable * p = static_cast<qx::IxPersistable *>(& t); return qx::cvt::from_json(j, (* p), format); }
00340 };
00341 
00342 #endif // _QX_NO_JSON
00343 
00344 template <typename T>
00345 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
00346 {
00347    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00348    { return (t ? qx::cvt::to_string((* t), format, index, ctx) : ""); }
00349 };
00350 
00351 template <typename T>
00352 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
00353 {
00354    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00355    { if (! t) { qx::trait::construct_ptr<T>::get(t); }; return (t ? qx::cvt::from_string(s, (* t), format, index, ctx) : qx_bool(false)); }
00356 };
00357 
00358 template <typename T>
00359 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
00360 {
00361    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00362    { return (t ? qx::cvt::to_variant((* t), format, index, ctx) : QVariant()); }
00363 };
00364 
00365 template <typename T>
00366 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
00367 {
00368    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00369    { if (! t && ! v.isNull()) { qx::trait::construct_ptr<T>::get(t); }; return (t ? qx::cvt::from_variant(v, (* t), format, index, ctx) : qx_bool(false)); }
00370 };
00371 
00372 #ifndef _QX_NO_JSON
00373 
00374 template <typename T>
00375 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
00376 {
00377    static inline QJsonValue toJson(const T & t, const QString & format)
00378    { return (t ? qx::cvt::to_json((* t), format) : QJsonValue()); }
00379 };
00380 
00381 template <typename T>
00382 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Ptr>
00383 {
00384    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
00385    { if (! t && ! j.isNull()) { qx::trait::construct_ptr<T>::get(t); }; return (t ? qx::cvt::from_json(j, (* t), format) : qx_bool(false)); }
00386 };
00387 
00388 #endif // _QX_NO_JSON
00389 
00390 template <typename T>
00391 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
00392 {
00393    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00394    {
00395       if (ctx != qx::cvt::context::e_serialize_registered)
00396       { qx::IxDataMember * pId = qx::QxClass<T>::getSingleton()->getDataMemberX()->getId_WithDaoStrategy(); return (pId ? pId->toVariant((& t), format, index, ctx).toString() : QString()); }
00397       return qx::serialization::qt::to_string<T>(t);
00398    }
00399 };
00400 
00401 template <typename T>
00402 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
00403 {
00404    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00405    {
00406       if (ctx != qx::cvt::context::e_serialize_registered)
00407       { 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)); }
00408       return qx::serialization::qt::from_string<T>(t, s);
00409    }
00410 };
00411 
00412 template <typename T>
00413 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
00414 {
00415    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00416    {
00417       if (ctx != qx::cvt::context::e_serialize_registered)
00418       { qx::IxDataMember * pId = qx::QxClass<T>::getSingleton()->getDataMemberX()->getId_WithDaoStrategy(); return (pId ? pId->toVariant((& t), format, index, ctx) : QVariant()); }
00419       return qx::serialization::qt::to_byte_array<T>(t);
00420    }
00421 };
00422 
00423 template <typename T>
00424 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
00425 {
00426    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00427    {
00428       if (ctx != qx::cvt::context::e_serialize_registered)
00429       { qx::IxDataMember * pId = qx::QxClass<T>::getSingleton()->getDataMemberX()->getId_WithDaoStrategy(); return (pId ? pId->fromVariant((& t), v, format, index, ctx) : qx_bool(false)); }
00430       return qx::serialization::qt::from_byte_array<T>(t, v.toByteArray());
00431    }
00432 };
00433 
00434 #ifndef _QX_NO_JSON
00435 
00436 template <typename T>
00437 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
00438 {
00439    static inline QJsonValue toJson(const T & t, const QString & format)
00440    { return qx::cvt::detail::QxSerializeJsonRegistered<T>::save(t, format); }
00441 };
00442 
00443 template <typename T>
00444 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Registered>
00445 {
00446    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
00447    { return qx::cvt::detail::QxSerializeJsonRegistered<T>::load(j, t, format); }
00448 };
00449 
00450 #endif // _QX_NO_JSON
00451 
00452 template <typename T>
00453 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Container>
00454 {
00455    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00456    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::to_string(t); }
00457 };
00458 
00459 template <typename T>
00460 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Container>
00461 {
00462    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00463    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::from_string(t, s); }
00464 };
00465 
00466 template <typename T>
00467 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Container>
00468 {
00469    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00470    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::to_string(t); }
00471 };
00472 
00473 template <typename T>
00474 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Container>
00475 {
00476    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00477    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QX_CVT_DEFAULT_ARCHIVE::from_string(t, v.toString()); }
00478 };
00479 
00480 #ifndef _QX_NO_JSON
00481 
00482 template <typename T>
00483 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Container>
00484 {
00485    static inline QJsonValue toJson(const T & t, const QString & format)
00486    { 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)); }
00487 };
00488 
00489 template <typename T>
00490 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Container>
00491 {
00492    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
00493    { 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); }
00494 };
00495 
00496 #endif // _QX_NO_JSON
00497 
00498 template <typename T>
00499 struct QxConvertHelper_ToString<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
00500 {
00501    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00502    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QString::number(static_cast<long>(t)); }
00503 };
00504 
00505 template <typename T>
00506 struct QxConvertHelper_FromString<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
00507 {
00508    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00509    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); bool bOk = false; t = static_cast<T>(static_cast<long>(s.toLongLong(& bOk))); return bOk; }
00510 };
00511 
00512 template <typename T>
00513 struct QxConvertHelper_ToVariant<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
00514 {
00515    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00516    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); return QVariant(static_cast<qlonglong>(t)); }
00517 };
00518 
00519 template <typename T>
00520 struct QxConvertHelper_FromVariant<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
00521 {
00522    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00523    { Q_UNUSED(format); Q_UNUSED(index); Q_UNUSED(ctx); bool bOk = false; t = static_cast<T>(static_cast<long>(v.toLongLong(& bOk))); return bOk; }
00524 };
00525 
00526 #ifndef _QX_NO_JSON
00527 
00528 template <typename T>
00529 struct QxConvertHelper_ToJson<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
00530 {
00531    static inline QJsonValue toJson(const T & t, const QString & format)
00532    { Q_UNUSED(format); return QJsonValue(static_cast<int>(t)); }
00533 };
00534 
00535 template <typename T>
00536 struct QxConvertHelper_FromJson<T, qx::cvt::detail::helper::QxConvertHelper_Enum>
00537 {
00538    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
00539    { Q_UNUSED(format); t = static_cast<T>(static_cast<long>(qRound(j.toDouble()))); return qx_bool(true); }
00540 };
00541 
00542 #endif // _QX_NO_JSON
00543 
00544 template <typename T>
00545 struct QxConvertHelper
00546 {
00547 
00548 private:
00549 
00550    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;
00551    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;
00552    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;
00553    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;
00554    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;
00555    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;
00556 
00557 public:
00558 
00559    typedef typename QxConvertHelper<T>::type_str_cvt_helper_5 type;
00560 
00561 };
00562 
00563 template <typename T>
00564 struct QxConvert_ToString
00565 {
00566    static inline QString toString(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00567    { return qx::cvt::detail::QxConvertHelper_ToString<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::toString(t, format, index, ctx); }
00568 };
00569 
00570 template <typename T>
00571 struct QxConvert_FromString
00572 {
00573    static inline qx_bool fromString(const QString & s, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00574    { return qx::cvt::detail::QxConvertHelper_FromString<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::fromString(s, t, format, index, ctx); }
00575 };
00576 
00577 template <typename T>
00578 struct QxConvert_ToVariant
00579 {
00580    static inline QVariant toVariant(const T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00581    { return qx::cvt::detail::QxConvertHelper_ToVariant<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::toVariant(t, format, index, ctx); }
00582 };
00583 
00584 template <typename T>
00585 struct QxConvert_FromVariant
00586 {
00587    static inline qx_bool fromVariant(const QVariant & v, T & t, const QString & format, int index, qx::cvt::context::ctx_type ctx)
00588    { return qx::cvt::detail::QxConvertHelper_FromVariant<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::fromVariant(v, t, format, index, ctx); }
00589 };
00590 
00591 #ifndef _QX_NO_JSON
00592 
00593 template <typename T>
00594 struct QxConvert_ToJson
00595 {
00596    static inline QJsonValue toJson(const T & t, const QString & format)
00597    { return qx::cvt::detail::QxConvertHelper_ToJson<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::toJson(t, format); }
00598 };
00599 
00600 template <typename T>
00601 struct QxConvert_FromJson
00602 {
00603    static inline qx_bool fromJson(const QJsonValue & j, T & t, const QString & format)
00604    { return qx::cvt::detail::QxConvertHelper_FromJson<T, typename qx::cvt::detail::QxConvertHelper<T>::type>::fromJson(j, t, format); }
00605 };
00606 
00607 #endif // _QX_NO_JSON
00608 
00609 } // namespace detail
00610 } // namespace cvt
00611 } // namespace qx
00612 
00613 #include "../../inl/QxConvert/QxConvert_WithIndex.inl"
00614 #include "../../inl/QxConvert/QxConvert_ToString.inl"
00615 #include "../../inl/QxConvert/QxConvert_FromString.inl"
00616 #include "../../inl/QxConvert/QxConvert_ToVariant.inl"
00617 #include "../../inl/QxConvert/QxConvert_FromVariant.inl"
00618 #include "../../inl/QxConvert/QxConvert_ToJson.inl"
00619 #include "../../inl/QxConvert/QxConvert_FromJson.inl"
00620 #include "../../inl/QxConvert/QxConvert_Qt.inl"
00621 
00622 #endif // _QX_CONVERT_IMPL_H_