third-party/XdlOrm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
bing
2026-04-03 11:32:07 +08:00
commit 003be19522
1142 changed files with 185854 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
inl/QxDataMember/QxDataMember.inl Normal file
View File

@@ -0,0 +1,35 @@
/****************************************************************************
**
** https://www.qxorm.com/
** Copyright (C) 2013 XDL Team (ic-east.com)
**
** This file is part of the QxOrm library
**
** This software is provided 'as-is', without any express or implied
** warranty. In no event will the authors be held liable for any
** damages arising from the use of this software
**
** Commercial Usage
** Licensees holding valid commercial QxOrm licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and XDL Team
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file 'license.gpl3.txt' included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met : http://www.gnu.org/copyleft/gpl.html
**
** If you are unsure which license is appropriate for your use, or
** if you have questions regarding the use of this file, please contact :
** ic-east.com
**
****************************************************************************/
namespace qx
{
} // namespace qx

463
inl/QxDataMember/QxDataMemberX.inl Normal file
View File

@@ -0,0 +1,463 @@
/****************************************************************************
**
** https://www.qxorm.com/
** Copyright (C) 2013 XDL Team (ic-east.com)
**
** This file is part of the QxOrm library
**
** This software is provided 'as-is', without any express or implied
** warranty. In no event will the authors be held liable for any
** damages arising from the use of this software
**
** Commercial Usage
** Licensees holding valid commercial QxOrm licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and XDL Team
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file 'license.gpl3.txt' included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met : http://www.gnu.org/copyleft/gpl.html
**
** If you are unsure which license is appropriate for your use, or
** if you have questions regarding the use of this file, please contact :
** ic-east.com
**
****************************************************************************/
namespace qx
{
template <class T>
IxDataMember *QxDataMemberX<T>::initId(IxDataMember *pId, long lVersion)
{
if (!pId)
{
qAssert(false);
return NULL;
}
qAssert(lVersion <= getVersion());
QString sKey = pId->getKey();
pId->setSqlType(qx::trait::get_sql_type<typename QxDataMemberX<T>::type_primary_key>::get());
pId->setAutoIncrement(std::is_integral<typename QxDataMemberX<T>::type_primary_key>::value);
pId->setNameParent(getName());
pId->setIsPrimaryKey(true);
pId->setNotNull(true);
pId->setVersion(lVersion);
pId->setParent(this);
this->setId(pId);
this->getListDataMemberRef().insert(sKey, pId);
return pId;
}
template <class T>
IxDataMember *QxDataMemberX<T>::initData(IxDataMember *pData, long lVersion)
{
if (!pData)
{
qAssert(false);
return NULL;
}
qAssert(lVersion <= getVersion());
QString sKey = pData->getKey();
pData->setVersion(lVersion);
pData->setNameParent(getName());
pData->setParent(this);
this->getListDataMemberRef().insert(sKey, pData);
return pData;
}
template <class T>
IxDataMember *QxDataMemberX<T>::initPImpl(IxDataMember *pImpl)
{
if (!pImpl)
{
qAssert(false);
return NULL;
}
QString sKey = pImpl->getKey();
if (this->getListPImplRef().exist(sKey))
{
qAssert(false);
return NULL;
}
pImpl->setNameParent(getName());
pImpl->setParent(this);
this->getListPImplRef().insert(sKey, pImpl);
return pImpl;
}
template <class T>
template <typename V, typename U>
IxDataMember *QxDataMemberX<T>::add(V U::*pData, const QString &sKey, long lVersion /* = 0 */, bool bSerialize /* = true */, bool bDao /* = true */)
{
typedef std::is_base_of<U, T> is_valid_class_tmp;
static_assert(is_valid_class_tmp::value, "is_valid_class_tmp::value");
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pNewDataMember = new QxDataMember<V, T>(pData, sKey, lVersion, bSerialize, bDao);
pNewDataMember->setSqlType(qx::trait::get_sql_type<V>::get());
return this->initData(pNewDataMember, lVersion);
}
template <class T>
IxDataMember *QxDataMemberX<T>::add(const QString &sKey, long lVersion)
{
if (!qx::trait::qt_meta_object<T>::is_valid)
{
qDebug("[QxOrm] qx::QxDataMemberX<T>::add() : '%s'", "Qt introspection engine works only with QObject class");
qAssert(false);
return NULL;
}
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
return this->initData(new QxDataMember_QObject(qx::trait::qt_meta_object<T>::get(), sKey), lVersion);
}
template <class T>
IxDataMember *QxDataMemberX<T>::id(typename QxDataMemberX<T>::type_primary_key T::*pDataMemberId, const QString &sKey, long lVersion /* = 0 */)
{
if (getId_WithDaoStrategy())
{
qDebug("[QxOrm] qx::QxDataMemberX<T> id (primary key) already defined '%s'", qPrintable(getId_WithDaoStrategy()->getName()));
}
if (exist_WithDaoStrategy(sKey) || getId_WithDaoStrategy())
{
qAssert(false);
return getId_WithDaoStrategy();
}
return this->initId(new QxDataMember<typename QxDataMemberX<T>::type_primary_key, T>(pDataMemberId, sKey, lVersion, true, true), lVersion);
}
template <class T>
IxDataMember *QxDataMemberX<T>::id(const QString &sKey, long lVersion)
{
if (!qx::trait::qt_meta_object<T>::is_valid)
{
qDebug("[QxOrm] qx::QxDataMemberX<T>::id() : '%s'", "Qt introspection engine works only with QObject class");
qAssert(false);
return NULL;
}
if (getId_WithDaoStrategy())
{
qDebug("[QxOrm] qx::QxDataMemberX<T> id (primary key) already defined '%s'", qPrintable(getId_WithDaoStrategy()->getName()));
}
if (exist_WithDaoStrategy(sKey) || getId_WithDaoStrategy())
{
qAssert(false);
return getId_WithDaoStrategy();
}
return this->initId(new QxDataMember_QObject(qx::trait::qt_meta_object<T>::get(), sKey), lVersion);
}
template <class T>
template <typename V, typename U>
IxSqlRelation *QxDataMemberX<T>::relationOneToOne(V U::*pData, const QString &sKey, long lVersion /* = 0 */)
{
typedef std::is_base_of<U, T> is_valid_class_tmp;
static_assert(is_valid_class_tmp::value, "is_valid_class_tmp::value");
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pDataMember = this->add(pData, sKey, lVersion);
IxSqlRelation *pSqlRelation = new QxSqlRelation_OneToOne<V, T>(pDataMember);
pDataMember->setSqlRelation(pSqlRelation);
return pSqlRelation;
}
template <class T>
template <typename V, typename U>
IxSqlRelation *QxDataMemberX<T>::relationManyToOne(V U::*pData, const QString &sKey, long lVersion /* = 0 */)
{
typedef std::is_base_of<U, T> is_valid_class_tmp;
static_assert(is_valid_class_tmp::value, "is_valid_class_tmp::value");
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pDataMember = this->add(pData, sKey, lVersion);
IxSqlRelation *pSqlRelation = new QxSqlRelation_ManyToOne<V, T>(pDataMember);
pDataMember->setSqlRelation(pSqlRelation);
return pSqlRelation;
}
template <class T>
template <typename V, typename U>
IxSqlRelation *QxDataMemberX<T>::relationOneToMany(V U::*pData, const QString &sKey, const QString &sForeignKey, long lVersion /* = 0 */)
{
typedef std::is_base_of<U, T> is_valid_class_tmp;
static_assert(is_valid_class_tmp::value, "is_valid_class_tmp::value");
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pDataMember = this->add(pData, sKey, lVersion);
IxSqlRelation *pSqlRelation = new QxSqlRelation_OneToMany<V, T>(pDataMember, sForeignKey);
pDataMember->setSqlRelation(pSqlRelation);
return pSqlRelation;
}
template <class T>
template <typename V, typename U>
IxSqlRelation *QxDataMemberX<T>::relationManyToMany(V U::*pData, const QString &sKey, const QString &sExtraTable, const QString &sForeignKeyOwner, const QString &sForeignKeyDataType, long lVersion /* = 0 */)
{
typedef std::is_base_of<U, T> is_valid_class_tmp;
static_assert(is_valid_class_tmp::value, "is_valid_class_tmp::value");
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pDataMember = this->add(pData, sKey, lVersion);
IxSqlRelation *pSqlRelation = new QxSqlRelation_ManyToMany<V, T>(pDataMember, sExtraTable, sForeignKeyOwner, sForeignKeyDataType);
pDataMember->setSqlRelation(pSqlRelation);
return pSqlRelation;
}
template <class T>
template <typename V, typename U>
IxDataMember *QxDataMemberX<T>::pimpl(V U::*pData, const QString &sKey)
{
IxDataMember *pNewDataMember = new QxDataMember_PImpl<V, U>(pData, sKey);
return this->initPImpl(pNewDataMember);
}
template <class T>
template <typename U>
IxDataMember *QxDataMemberX<T>::id(typename QxDataMemberX<T>::type_primary_key U::*pDataMemberId, const QString &sKey, long lVersion, IxDataMember *pImpl)
{
if (pImpl)
{
qAssert((pImpl->getParent()) && (pImpl->getParent()->getClass() == this->getClass()));
}
if (getId_WithDaoStrategy())
{
qDebug("[QxOrm] qx::QxDataMemberX<T> id (primary key) already defined '%s'", qPrintable(getId_WithDaoStrategy()->getName()));
}
if (exist_WithDaoStrategy(sKey) || getId_WithDaoStrategy())
{
qAssert(false);
return getId_WithDaoStrategy();
}
return this->initId(new QxDataMember<typename QxDataMemberX<T>::type_primary_key, U>(pDataMemberId, sKey, lVersion, true, true, pImpl), lVersion);
}
template <class T>
template <typename V, typename U>
IxDataMember *QxDataMemberX<T>::add(V U::*pData, const QString &sKey, long lVersion, bool bSerialize, bool bDao, IxDataMember *pImpl)
{
if (pImpl)
{
qAssert((pImpl->getParent()) && (pImpl->getParent()->getClass() == this->getClass()));
}
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pNewDataMember = new QxDataMember<V, U>(pData, sKey, lVersion, bSerialize, bDao, pImpl);
pNewDataMember->setSqlType(qx::trait::get_sql_type<V>::get());
return this->initData(pNewDataMember, lVersion);
}
template <class T>
template <typename V, typename U>
IxSqlRelation *QxDataMemberX<T>::relationOneToOne(V U::*pData, const QString &sKey, long lVersion, IxDataMember *pImpl)
{
if (pImpl)
{
qAssert((pImpl->getParent()) && (pImpl->getParent()->getClass() == this->getClass()));
}
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pDataMember = this->add(pData, sKey, lVersion, true, true, pImpl);
IxSqlRelation *pSqlRelation = new QxSqlRelation_OneToOne<V, T>(pDataMember);
pDataMember->setSqlRelation(pSqlRelation);
return pSqlRelation;
}
template <class T>
template <typename V, typename U>
IxSqlRelation *QxDataMemberX<T>::relationManyToOne(V U::*pData, const QString &sKey, long lVersion, IxDataMember *pImpl)
{
if (pImpl)
{
qAssert((pImpl->getParent()) && (pImpl->getParent()->getClass() == this->getClass()));
}
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pDataMember = this->add(pData, sKey, lVersion, true, true, pImpl);
IxSqlRelation *pSqlRelation = new QxSqlRelation_ManyToOne<V, T>(pDataMember);
pDataMember->setSqlRelation(pSqlRelation);
return pSqlRelation;
}
template <class T>
template <typename V, typename U>
IxSqlRelation *QxDataMemberX<T>::relationOneToMany(V U::*pData, const QString &sKey, const QString &sForeignKey, long lVersion, IxDataMember *pImpl)
{
if (pImpl)
{
qAssert((pImpl->getParent()) && (pImpl->getParent()->getClass() == this->getClass()));
}
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pDataMember = this->add(pData, sKey, lVersion, true, true, pImpl);
IxSqlRelation *pSqlRelation = new QxSqlRelation_OneToMany<V, T>(pDataMember, sForeignKey);
pDataMember->setSqlRelation(pSqlRelation);
return pSqlRelation;
}
template <class T>
template <typename V, typename U>
IxSqlRelation *QxDataMemberX<T>::relationManyToMany(V U::*pData, const QString &sKey, const QString &sExtraTable, const QString &sForeignKeyOwner, const QString &sForeignKeyDataType, long lVersion, IxDataMember *pImpl)
{
if (pImpl)
{
qAssert((pImpl->getParent()) && (pImpl->getParent()->getClass() == this->getClass()));
}
if (exist_WithDaoStrategy(sKey))
{
qAssert(false);
return NULL;
}
IxDataMember *pDataMember = this->add(pData, sKey, lVersion, true, true, pImpl);
IxSqlRelation *pSqlRelation = new QxSqlRelation_ManyToMany<V, T>(pDataMember, sExtraTable, sForeignKeyOwner, sForeignKeyDataType);
pDataMember->setSqlRelation(pSqlRelation);
return pSqlRelation;
}
#ifdef _QX_ENABLE_BOOST_SERIALIZATION
template <class T>
template <class Archive>
inline void QxDataMemberX<T>::toArchive(const T *pOwner, Archive &ar, const unsigned int file_version) const
{
Q_UNUSED(file_version);
const QxCollection<QString, IxDataMember *> &lstDataMember = this->getListDataMemberRef();
_foreach_if(IxDataMember * pDataMember, lstDataMember, (pDataMember->getSerialize()))
pDataMember->toArchive(pOwner, ar);
}
template <class T>
template <class Archive>
inline void QxDataMemberX<T>::fromArchive(T *pOwner, Archive &ar, const unsigned int file_version)
{
Q_UNUSED(file_version);
QxCollection<QString, IxDataMember *> &lstDataMember = this->getListDataMemberRef();
_foreach_if(IxDataMember * pDataMember, lstDataMember, (pDataMember->getSerialize() && (pDataMember->getVersion() <= static_cast<long>(file_version))))
pDataMember->fromArchive(pOwner, ar);
}
#endif // _QX_ENABLE_BOOST_SERIALIZATION
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE
QxDataMemberX<qx::trait::no_base_class_defined>::QxDataMemberX() : IxDataMemberX(), QxSingleton<QxDataMemberX<qx::trait::no_base_class_defined>>("qx::QxDataMemberX_no_base_class_defined") { ; }
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE
QxDataMemberX<QObject>::QxDataMemberX() : IxDataMemberX(), QxSingleton<QxDataMemberX<QObject>>("qx::QxDataMemberX_QObject") { ; }
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE long QxDataMemberX<qx::trait::no_base_class_defined>::count_WithDaoStrategy_Helper() const { return 0; }
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE bool QxDataMemberX<qx::trait::no_base_class_defined>::exist_WithDaoStrategy_Helper(const QString &sKey) const
{
Q_UNUSED(sKey);
return false;
}
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE IxDataMember *QxDataMemberX<qx::trait::no_base_class_defined>::get_WithDaoStrategy_Helper(long lIndex) const
{
Q_UNUSED(lIndex);
return NULL;
}
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE IxDataMember *QxDataMemberX<qx::trait::no_base_class_defined>::get_WithDaoStrategy_Helper(const QString &sKey) const
{
Q_UNUSED(sKey);
return NULL;
}
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE IxDataMember *QxDataMemberX<qx::trait::no_base_class_defined>::getId_WithDaoStrategy_Helper() const { return NULL; }
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE long QxDataMemberX<QObject>::count_WithDaoStrategy_Helper() const { return 0; }
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE bool QxDataMemberX<QObject>::exist_WithDaoStrategy_Helper(const QString &sKey) const
{
Q_UNUSED(sKey);
return false;
}
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE IxDataMember *QxDataMemberX<QObject>::get_WithDaoStrategy_Helper(long lIndex) const
{
Q_UNUSED(lIndex);
return NULL;
}
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE IxDataMember *QxDataMemberX<QObject>::get_WithDaoStrategy_Helper(const QString &sKey) const
{
Q_UNUSED(sKey);
return NULL;
}
template <>
QX_GCC_WORKAROUND_TEMPLATE_SPEC_INLINE IxDataMember *QxDataMemberX<QObject>::getId_WithDaoStrategy_Helper() const { return NULL; }
} // namespace qx