QxOrm  1.2.8
C++ Object Relational Mapping library
QxNestedModel.h
Go to the documentation of this file.
00001 /****************************************************************************
00002 **
00003 ** http://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_NESTED_MODEL_H_
00033 #define _QX_NESTED_MODEL_H_
00034 
00035 #ifdef _MSC_VER
00036 #pragma once
00037 #endif
00038 
00046 #include <boost/static_assert.hpp>
00047 #include <boost/mpl/if.hpp>
00048 #include <boost/mpl/logical.hpp>
00049 #include <boost/type_traits/is_pointer.hpp>
00050 #include <boost/type_traits/is_same.hpp>
00051 
00052 #include <QxCommon/QxStringCvt.h>
00053 
00054 #include <QxCollection/QxCollection.h>
00055 
00056 #include <QxTraits/is_qx_registered.h>
00057 #include <QxTraits/is_container.h>
00058 #include <QxTraits/is_smart_ptr.h>
00059 #include <QxTraits/get_base_class.h>
00060 #include <QxTraits/get_class_name_primitive.h>
00061 #include <QxTraits/construct_ptr.h>
00062 #include <QxTraits/generic_container.h>
00063 #include <QxTraits/is_valid_primary_key.h>
00064 
00065 #include <QxModelView/IxModel.h>
00066 #include <QxModelView/QxModel.h>
00067 
00068 namespace qx {
00069 namespace model_view {
00070 
00071 template <class T>
00072 qx::IxModel * create_nested_model(qx::IxModel * pParent, const QModelIndex & idxParent, T & t);
00073 
00074 } // namespace model_view
00075 } // namespace qx
00076 
00077 namespace qx {
00078 namespace model_view {
00079 namespace detail {
00080 
00081 template <class T>
00082 struct QxNestedModel;
00083 
00084 template <class T>
00085 struct QxNestedModel_Generic
00086 {
00087 
00088    enum { is_valid = qx::trait::is_qx_registered<T>::value };
00089 
00090    static inline qx::IxModel * create(qx::IxModel * pParent, const QModelIndex & idxParent, T & t)
00091    {
00092       typedef typename qx::QxModel<T>::type_collection type_collection;
00093       typedef typename qx::QxModel<T>::type_primary_key type_primary_key;
00094       typedef typename qx::QxModel<T>::type_ptr type_ptr;
00095 
00096       BOOST_STATIC_ASSERT(is_valid);
00097       qx::QxModel<T> * pModel = new qx::QxModel<T>(pParent);
00098       pModel->setParentModel(pParent);
00099       type_collection & model = pModel->m_model;
00100       long & idx = pModel->m_lManualInsertIndex;
00101       type_primary_key key;
00102       type_ptr ptr;
00103 
00104       pModel->beginInsertRows(idxParent, 0, 0);
00105       ptr = type_ptr(new T());
00106       (* ptr) = t;
00107       qx::IxDataMember * pDataMemberId = pModel->m_pDataMemberId;
00108       if (! pDataMemberId) { qAssert(false); pModel->endInsertRows(); return pModel; }
00109       QVariant value = pDataMemberId->toVariant(& t);
00110       if (! qx::trait::is_valid_primary_key(value))
00111       { idx--; value = QVariant(static_cast<qlonglong>(idx)); }
00112       qx::cvt::from_variant(value, key);
00113       model.insert(0, key, ptr);
00114       pModel->endInsertRows();
00115       return pModel;
00116    }
00117 
00118 };
00119 
00120 template <class T>
00121 struct QxNestedModel_Container
00122 {
00123 
00124    typedef qx::trait::generic_container<T> type_generic_container;
00125    typedef typename type_generic_container::type_value_qx type_data;
00126 
00127    enum { is_valid = qx::trait::is_qx_registered<type_data>::value };
00128 
00129    static inline qx::IxModel * create(qx::IxModel * pParent, const QModelIndex & idxParent, T & t)
00130    {
00131       int iCurrRow = 0;
00132       BOOST_STATIC_ASSERT(is_valid);
00133       qx::QxModel<type_data> * pModel = new qx::QxModel<type_data>(pParent);
00134       pModel->setParentModel(pParent);
00135       long lCount = static_cast<long>(qx::trait::generic_container<T>::size(t));
00136       if (lCount <= 0) { return pModel; }
00137 
00138       pModel->beginInsertRows(idxParent, 0, (lCount - 1));
00139       for (typename T::iterator it = t.begin(); it != t.end(); ++it)
00140       { insertItem(pModel, (* it), iCurrRow); iCurrRow++; }
00141       pModel->endInsertRows();
00142       return pModel;
00143    }
00144 
00145    template <typename U>
00146    static inline bool insert(qx::IxModel * pModel, U & item, int iRow)
00147    {
00148       typedef typename qx::QxModel<U>::type_collection type_collection;
00149       typedef typename qx::QxModel<U>::type_primary_key type_primary_key;
00150       typedef typename qx::QxModel<U>::type_ptr type_ptr;
00151 
00152       if (! pModel) { qAssert(false); return false; }
00153       qx::QxModel<U> * pModelWrk = static_cast<qx::QxModel<U> *>(pModel);
00154       type_collection & model = pModelWrk->m_model;
00155       long & idx = pModelWrk->m_lManualInsertIndex;
00156       type_primary_key key;
00157       type_ptr ptr;
00158 
00159       ptr = type_ptr(new U());
00160       (* ptr) = item;
00161       qx::IxDataMember * pDataMemberId = pModelWrk->m_pDataMemberId;
00162       if (! pDataMemberId) { qAssert(false); return false; }
00163       QVariant value = pDataMemberId->toVariant(& item);
00164       if (! qx::trait::is_valid_primary_key(value))
00165       { idx--; value = QVariant(static_cast<qlonglong>(idx)); }
00166       qx::cvt::from_variant(value, key);
00167       model.insert(iRow, key, ptr);
00168       return true;
00169    }
00170 
00171 private:
00172 
00173    template <typename U>
00174    static inline bool insertItem(qx::IxModel * pModel, U & item, int iRow)
00175    { return insertItem_Helper<U, boost::is_pointer<U>::value || qx::trait::is_smart_ptr<U>::value>::insert(pModel, item, iRow); }
00176 
00177    template <typename U, bool bIsPointer /* = true */>
00178    struct insertItem_Helper
00179    {
00180       static inline bool insert(qx::IxModel * pModel, U & item, int iRow)
00181       { return (item ? qx::model_view::detail::QxNestedModel_Container<T>::insertItem(pModel, (* item), iRow) : true); }
00182    };
00183 
00184    template <typename U1, typename U2>
00185    struct insertItem_Helper<std::pair<U1, U2>, false>
00186    {
00187       static inline bool insert(qx::IxModel * pModel, std::pair<U1, U2> & item, int iRow)
00188       { return qx::model_view::detail::QxNestedModel_Container<T>::insertItem(pModel, item.second, iRow); }
00189    };
00190 
00191    template <typename U1, typename U2>
00192    struct insertItem_Helper<const std::pair<U1, U2>, false>
00193    {
00194       static inline bool insert(qx::IxModel * pModel, const std::pair<U1, U2> & item, int iRow)
00195       { return qx::model_view::detail::QxNestedModel_Container<T>::insertItem(pModel, item.second, iRow); }
00196    };
00197 
00198    template <typename U1, typename U2>
00199    struct insertItem_Helper<QPair<U1, U2>, false>
00200    {
00201       static inline bool insert(qx::IxModel * pModel, QPair<U1, U2> & item, int iRow)
00202       { return qx::model_view::detail::QxNestedModel_Container<T>::insertItem(pModel, item.second, iRow); }
00203    };
00204 
00205    template <typename U1, typename U2>
00206    struct insertItem_Helper<const QPair<U1, U2>, false>
00207    {
00208       static inline bool insert(qx::IxModel * pModel, const QPair<U1, U2> & item, int iRow)
00209       { return qx::model_view::detail::QxNestedModel_Container<T>::insertItem(pModel, item.second, iRow); }
00210    };
00211 
00212    template <typename U>
00213    struct insertItem_Helper<U, false>
00214    {
00215       enum { is_same_type = boost::is_same<qx::model_view::detail::QxNestedModel_Container<T>::type_data, U>::value };
00216       static bool insert(qx::IxModel * pModel, U & item, int iRow)
00217       { BOOST_STATIC_ASSERT(is_same_type); return qx::model_view::detail::QxNestedModel_Container<T>::insert(pModel, item, iRow); }
00218    };
00219 
00220 };
00221 
00222 template <class T>
00223 struct QxNestedModel_Ptr
00224 {
00225 
00226    static inline qx::IxModel * create(qx::IxModel * pParent, const QModelIndex & idxParent, T & t)
00227    { return (t ? create_Helper(pParent, idxParent, (* t)) : create_NullHelper(pParent, idxParent)); }
00228 
00229 private:
00230 
00231    template <class U>
00232    static inline qx::IxModel * create_Helper(qx::IxModel * pParent, const QModelIndex & idxParent, U & u)
00233    { return qx::model_view::detail::QxNestedModel<U>::create(pParent, idxParent, u); }
00234 
00235    static inline qx::IxModel * create_NullHelper(qx::IxModel * pParent, const QModelIndex & idxParent)
00236    {
00237       T t; qx::trait::construct_ptr<T>::get(t);
00238       if (! t) { qAssert(false); return NULL; }
00239       qx::IxModel * pModel = qx::model_view::create_nested_model(pParent, idxParent, (* t));
00240       if (pModel) { pModel->clear(); } qAssert(pModel != NULL);
00241       return pModel;
00242    }
00243 
00244 };
00245 
00246 template <class T>
00247 struct QxNestedModel
00248 {
00249 
00250    static inline qx::IxModel * create(qx::IxModel * pParent, const QModelIndex & idxParent, T & t)
00251    {
00252       typedef typename boost::mpl::if_c< boost::is_pointer<T>::value, qx::model_view::detail::QxNestedModel_Ptr<T>, qx::model_view::detail::QxNestedModel_Generic<T> >::type type_model_view_1;
00253       typedef typename boost::mpl::if_c< qx::trait::is_smart_ptr<T>::value, qx::model_view::detail::QxNestedModel_Ptr<T>, type_model_view_1 >::type type_model_view_2;
00254       typedef typename boost::mpl::if_c< qx::trait::is_container<T>::value, qx::model_view::detail::QxNestedModel_Container<T>, type_model_view_2 >::type type_model_view_3;
00255 
00256       return type_model_view_3::create(pParent, idxParent, t);
00257    }
00258 
00259 };
00260 
00261 } // namespace detail
00262 } // namespace model_view
00263 } // namespace qx
00264 
00265 namespace qx {
00266 namespace model_view {
00267 
00275 template <class T>
00276 qx::IxModel * create_nested_model(qx::IxModel * pParent, const QModelIndex & idxParent, T & t)
00277 { return qx::model_view::detail::QxNestedModel<T>::create(pParent, idxParent, t); }
00278 
00279 } // namespace model_view
00280 } // namespace qx
00281 
00282 #endif // _QX_NESTED_MODEL_H_