Added support for QAbstractListModel

lib/include/DOtherSide/DOtherSide.h

@@ -372,6 +372,42 @@ DOS_API void DOS_CALL dos_qmetaobject_delete(DosQMetaObject *vptr);
 
 /// @}
 
+/// \defgroup QAbstractListModel QAbstractItemModel
+/// \brief Functions related to the QAbstractListModel class
+/// @{
+
+/// \brief Return QMetaObject associated to the QAbstractListModel class
+/// \return The QMetaObject of the QAbstractListModel class
+/// \note The returned QMetaObject should be freed using dos_qmetaobject_delete().
+DOS_API DosQMetaObject *DOS_CALL dos_qabstractlistmmodel_qmetaobject();
+
+/// \brief Create a new QAbstractListModel
+/// \param callbackObject The pointer of QAbstractListModel in the binded language
+/// \param metaObject The QMetaObject for this QAbstractListModel
+/// \param dObjectCallback The callback for handling the properties read/write and slots execution
+/// \param rowCountCallback The callback for handling the QAbstractItemModel::rowCount() execution
+/// \param columnCountCallback The callback for handling the QAbstractItemModel::columnCount() execution
+/// \param dataCallback The callback for handling the QAbstractItemModel::data() execution
+/// \param setDataCallback The callback for handling the QAbstractItemModel::setData() execution
+/// \param roleNamesCallback The callback for handling the QAbstractItemModel::roleNames() execution
+/// \param flagsCallback The callback for handling the QAbstractItemModel::flags() execution
+/// \param headerDataCallback The callback for handling the QAbstractItemModel::headerData() execution
+/// \param indexCallback The callback for handling the QAbstractItemModel::index() execution
+/// \param parentCallback The callback for handling the QAbstractItemModel::parent() execution
+DOS_API DosQAbstractListModel *DOS_CALL dos_qabstractlistmodel_create(void *callbackObject,
+                                                                      DosQMetaObject *metaObject,
+                                                                      DObjectCallback dObjectCallback,
+                                                                      RowCountCallback rowCountCallback,
+                                                                      ColumnCountCallback columnCountCallback,
+                                                                      DataCallback dataCallback,
+                                                                      SetDataCallback setDataCallback,
+                                                                      RoleNamesCallback roleNamesCallback,
+                                                                      FlagsCallback flagsCallback,
+                                                                      HeaderDataCallback headerDataCallback,
+                                                                      IndexCallback indexCallback,
+                                                                      ParentCallback parentCallback);
+/// @}
+
 /// \defgroup QAbstractItemModel QAbstractItemModel
 /// \brief Functions related to the QAbstractItemModel class
 /// @{

lib/include/DOtherSide/DOtherSideTypes.h

@@ -34,6 +34,9 @@ typedef void DosQModelIndex;
 /// A pointer to a QAbstractItemModel
 typedef void DosQAbstractItemModel;
 
+/// A pointer to a QAbstractListModel
+typedef void DosQAbstractListModel;
+
 /// A pointer to a QQmlApplicationEngine
 typedef void DosQQmlApplicationEngine;
 

lib/include/DOtherSide/DosQAbstractItemModel.h

@@ -9,11 +9,12 @@
 
 namespace DOS {
 
-class DosQAbstractItemModel : public QAbstractItemModel, public DosIQAbstractItemModelImpl
+template<class T>
+class DosQAbstractGenericModel : public T, public DosIQAbstractItemModelImpl
 {
 public:
     /// Constructor
-    DosQAbstractItemModel(void *modelObject,
+    DosQAbstractGenericModel(void *modelObject,
                              DosIQMetaObjectPtr metaObject,
                              OnSlotExecuted onSlotExecuted,
                              RowCountCallback rowCountCallback,
@@ -117,4 +118,9 @@ private:
     ParentCallback m_parentCallback;
 };
 
+
+using DosQAbstractItemModel = DosQAbstractGenericModel<QAbstractItemModel>;
+using DosQAbstractListModel = DosQAbstractGenericModel<QAbstractListModel>;
+using DosQAbstractTableModel = DosQAbstractGenericModel<QAbstractTableModel>;
+
 } // namespace DOS

lib/include/DOtherSide/DosQMetaObject.h

@@ -9,6 +9,8 @@
 #include <QtCore/QString>
 #include <QtCore/QHash>
 #include <QtCore/QMetaMethod>
+#include <QtCore/QAbstractItemModel>
+#include <QtCore/QAbstractListModel>
 // DOtherSide
 #include "DOtherSide/DOtherSideTypesCpp.h"
 
@@ -50,12 +52,16 @@ public:
 };
 
 /// This is the DosQMetaObject for a QAbstractItemModel
-class DosQAbstractItemModelMetaObject : public BaseDosQMetaObject
+template<class T>
+class DosQAbstractGenericModelMetaObject : public BaseDosQMetaObject
 {
 public:
-    DosQAbstractItemModelMetaObject();
+    DosQAbstractGenericModelMetaObject();
 };
 
+using DosQAbstractItemModelMetaObject = DosQAbstractGenericModelMetaObject<QAbstractItemModel>;
+using DosQAbstractListModelMetaObject = DosQAbstractGenericModelMetaObject<QAbstractListModel>;
+
 /// This the generic version used by subclasses of QObject or QAbstractItemModels
 class DosQMetaObject : public BaseDosQMetaObject
 {

lib/src/DOtherSide.cpp

@@ -588,6 +588,41 @@ void dos_qmetaobject_delete(::DosQMetaObject *vptr)
     delete factory;
 }
 
+::DosQMetaObject *dos_qabstractlistmodel_qmetaobject()
+{
+    return new DOS::DosIQMetaObjectHolder(std::make_shared<DOS::DosQAbstractListModelMetaObject>());
+}
+
+::DosQAbstractListModel *dos_qabstractlistmodel_create(void *dObjectPointer,
+                                                       ::DosQMetaObject *metaObjectPointer,
+                                                       ::DObjectCallback dObjectCallback,
+                                                       ::RowCountCallback rowCountCallback,
+                                                       ::ColumnCountCallback columnCountCallback,
+                                                       ::DataCallback dataCallback,
+                                                       ::SetDataCallback setDataCallback,
+                                                       ::RoleNamesCallback roleNamesCallaback,
+                                                       ::FlagsCallback flagsCallback,
+                                                       ::HeaderDataCallback headerDataCallback,
+                                                       ::IndexCallback indexCallback,
+                                                       ::ParentCallback parentCallback)
+{
+    auto metaObjectHolder = static_cast<DOS::DosIQMetaObjectHolder *>(metaObjectPointer);
+    auto model = new DOS::DosQAbstractListModel(dObjectPointer,
+                                                metaObjectHolder->data(),
+                                                DOS::OnSlotExecutedHandler(dObjectPointer, dObjectCallback),
+                                                rowCountCallback,
+                                                columnCountCallback,
+                                                dataCallback,
+                                                setDataCallback,
+                                                roleNamesCallaback,
+                                                flagsCallback,
+                                                headerDataCallback,
+                                                indexCallback,
+                                                parentCallback);
+    QQmlEngine::setObjectOwnership(model, QQmlEngine::CppOwnership);
+    return static_cast<QObject *>(model);
+}
+
 ::DosQMetaObject *dos_qabstractitemmodel_qmetaobject()
 {
     return new DOS::DosIQMetaObjectHolder(std::make_shared<DOS::DosQAbstractItemModelMetaObject>());

lib/src/DosQAbstractItemModel.cpp

@@ -2,17 +2,21 @@
 #include "DOtherSide/DosQObjectImpl.h"
 
 namespace {
-DOS::DosQObjectImpl::ParentMetaCall createParentMetaCall(QAbstractItemModel *parent)
+
+template<class T>
+DOS::DosQObjectImpl::ParentMetaCall createParentMetaCall(DOS::DosQAbstractGenericModel<T> *parent)
 {
     return [parent](QMetaObject::Call callType, int index, void **args)->int {
-        return parent->QAbstractItemModel::qt_metacall(callType, index, args);
+        return parent->T::qt_metacall(callType, index, args);
     };
 }
+
 }
 
 namespace DOS {
 
-DosQAbstractItemModel::DosQAbstractItemModel(void *modelObject,
+template<class T>
+DosQAbstractGenericModel<T>::DosQAbstractGenericModel(void *modelObject,
                                                       DosIQMetaObjectPtr metaObject,
                                                       OnSlotExecuted onSlotExecuted,
                                                       RowCountCallback rowCountCallback,
@@ -37,150 +41,179 @@ DosQAbstractItemModel::DosQAbstractItemModel(void *modelObject,
     , m_parentCallback(std::move(parentCallback))
 {}
 
-bool DosQAbstractItemModel::emitSignal(QObject *emitter, const QString &name, const std::vector<QVariant> &argumentsValues)
+template<class T>
+bool DosQAbstractGenericModel<T>::emitSignal(QObject *emitter, const QString &name, const std::vector<QVariant> &argumentsValues)
 {
     Q_ASSERT(m_impl);
     return m_impl->emitSignal(emitter, name, argumentsValues);
 }
 
-const QMetaObject *DosQAbstractItemModel::metaObject() const
+template<class T>
+const QMetaObject *DosQAbstractGenericModel<T>::metaObject() const
 {
     Q_ASSERT(m_impl);
     return m_impl->metaObject();
 }
 
-int DosQAbstractItemModel::qt_metacall(QMetaObject::Call call, int index, void **args)
+template<class T>
+int DosQAbstractGenericModel<T>::qt_metacall(QMetaObject::Call call, int index, void **args)
 {
     Q_ASSERT(m_impl);
     return m_impl->qt_metacall(call, index, args);
 }
 
-int DosQAbstractItemModel::rowCount(const QModelIndex &parent) const
+template<class T>
+int DosQAbstractGenericModel<T>::rowCount(const QModelIndex &parent) const
 {
     int result;
     m_rowCountCallback(m_modelObject, &parent, &result);
     return result;
 }
 
-int DosQAbstractItemModel::columnCount(const QModelIndex &parent) const
+template<class T>
+int DosQAbstractGenericModel<T>::columnCount(const QModelIndex &parent) const
 {
     int result;
     m_columnCountCallback(m_modelObject, &parent, &result);
     return result;
 }
 
-QVariant DosQAbstractItemModel::data(const QModelIndex &index, int role) const
+template<class T>
+QVariant DosQAbstractGenericModel<T>::data(const QModelIndex &index, int role) const
 {
     QVariant result;
     m_dataCallback(m_modelObject, &index, role, &result);
     return result;
 }
 
-bool DosQAbstractItemModel::setData(const QModelIndex &index, const QVariant &value, int role)
+template<class T>
+bool DosQAbstractGenericModel<T>::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     bool result = false;
     m_setDataCallback(m_modelObject, &index, &value, role, &result);
     return result;
 }
 
-Qt::ItemFlags DosQAbstractItemModel::flags(const QModelIndex &index) const
+template<class T>
+Qt::ItemFlags DosQAbstractGenericModel<T>::flags(const QModelIndex &index) const
 {
     int result;
     m_flagsCallback(m_modelObject, &index, &result);
     return Qt::ItemFlags(result);
 }
 
-QVariant DosQAbstractItemModel::headerData(int section, Qt::Orientation orientation, int role) const
+template<class T>
+QVariant DosQAbstractGenericModel<T>::headerData(int section, Qt::Orientation orientation, int role) const
 {
     QVariant result;
     m_headerDataCallback(m_modelObject, section, orientation, role, &result);
     return result;
 }
 
-QModelIndex DosQAbstractItemModel::index(int row, int column, const QModelIndex &parent) const
+template<class T>
+QModelIndex DosQAbstractGenericModel<T>::index(int row, int column, const QModelIndex &parent) const
 {
     QModelIndex result;
     m_indexCallback(m_modelObject, row, column, &parent, &result);
     return result;
 }
 
-QModelIndex DosQAbstractItemModel::parent(const QModelIndex &child) const
+template<class T>
+QModelIndex DosQAbstractGenericModel<T>::parent(const QModelIndex &child) const
 {
     QModelIndex result;
     m_parentCallback(m_modelObject, &child, &result);
     return result;
 }
 
-void *DosQAbstractItemModel::modelObject()
+template<class T>
+void *DosQAbstractGenericModel<T>::modelObject()
 {
     return m_modelObject;
 }
 
-QHash<int, QByteArray> DosQAbstractItemModel::roleNames() const
+template<class T>
+QHash<int, QByteArray> DosQAbstractGenericModel<T>::roleNames() const
 {
     QHash<int, QByteArray> result;
     m_roleNamesCallback(m_modelObject, &result);
     return result;
 }
 
-void DOS::DosQAbstractItemModel::publicBeginInsertColumns(const QModelIndex &index, int first, int last)
+template<class T>
+void DosQAbstractGenericModel<T>::publicBeginInsertColumns(const QModelIndex &index, int first, int last)
 {
-    beginInsertColumns(index, first, last);
+    T::beginInsertColumns(index, first, last);
 }
 
-void DOS::DosQAbstractItemModel::publicEndInsertColumns()
+template<class T>
+void DosQAbstractGenericModel<T>::publicEndInsertColumns()
 {
-    endInsertColumns();
+    T::endInsertColumns();
 }
 
-void DOS::DosQAbstractItemModel::publicBeginRemoveColumns(const QModelIndex &index, int first, int last)
+template<class T>
+void DosQAbstractGenericModel<T>::publicBeginRemoveColumns(const QModelIndex &index, int first, int last)
 {
-    beginRemoveColumns(index, first, last);
+    T::beginRemoveColumns(index, first, last);
 }
 
-void DOS::DosQAbstractItemModel::publicEndRemoveColumns()
+template<class T>
+void DosQAbstractGenericModel<T>::publicEndRemoveColumns()
 {
-    endRemoveColumns();
+    T::endRemoveColumns();
+}
+template<class T>
+void DosQAbstractGenericModel<T>::publicBeginInsertRows(const QModelIndex &index, int first, int last)
+{
+    T::beginInsertRows(index, first, last);
 }
 
-void DOS::DosQAbstractItemModel::publicBeginInsertRows(const QModelIndex &index, int first, int last)
+template<class T>
+void DosQAbstractGenericModel<T>::publicEndInsertRows()
 {
-    beginInsertRows(index, first, last);
+    T::endInsertRows();
 }
 
-void DOS::DosQAbstractItemModel::publicEndInsertRows()
+template<class T>
+void DosQAbstractGenericModel<T>::publicBeginRemoveRows(const QModelIndex &index, int first, int last)
 {
-    endInsertRows();
+    T::beginRemoveRows(index, first, last);
 }
 
-void DOS::DosQAbstractItemModel::publicBeginRemoveRows(const QModelIndex &index, int first, int last)
+template<class T>
+void DosQAbstractGenericModel<T>::publicEndRemoveRows()
 {
-    beginRemoveRows(index, first, last);
+    T::endRemoveRows();
 }
 
-void DOS::DosQAbstractItemModel::publicEndRemoveRows()
+template<class T>
+void DosQAbstractGenericModel<T>::publicBeginResetModel()
 {
-    endRemoveRows();
+    T::beginResetModel();
 }
 
-void DOS::DosQAbstractItemModel::publicBeginResetModel()
+template<class T>
+void DosQAbstractGenericModel<T>::publicEndResetModel()
 {
-    beginResetModel();
+    T::endResetModel();
 }
 
-void DOS::DosQAbstractItemModel::publicEndResetModel()
+template<class T>
+void DosQAbstractGenericModel<T>::publicDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
 {
-    endResetModel();
+    emit T::dataChanged(topLeft, bottomRight, roles);
 }
 
-void DOS::DosQAbstractItemModel::publicDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
+template<class T>
+QModelIndex DosQAbstractGenericModel<T>::publicCreateIndex(int row, int column, void *data) const
 {
-    emit dataChanged(topLeft, bottomRight, roles);
+    return T::createIndex(row, column, data);
-}
-
-QModelIndex DOS::DosQAbstractItemModel::publicCreateIndex(int row, int column, void *data) const
-{
-    return createIndex(row, column, data);
 }
 
 } // namespace DOS
+
+// Force instantiation
+template class DOS::DosQAbstractGenericModel<QAbstractItemModel>;
+template class DOS::DosQAbstractGenericModel<QAbstractListModel>;
+template class DOS::DosQAbstractGenericModel<QAbstractTableModel>;

lib/src/DosQMetaObject.cpp

@@ -41,19 +41,17 @@ Value valueOrDefault(std::unordered_map<Key, Value> const &map, const Key &k, Va
     return it != std::end(map) ? it->second : std::move(value);
 }
 
-QMetaObject *createDynamicQObjectMetaObject()
+template<class T> const char* className();
-{
+template<> const char* className<QObject>() { return "DosQObject"; }
-    QMetaObjectBuilder builder;
+template<> const char* className<QAbstractItemModel>() { return "DosQAbstractItemModel"; }
-    builder.setClassName("DosQObject");
+template<> const char* className<QAbstractListModel>() { return "DosQAbstractListModel"; }
-    builder.setSuperClass(&QObject::staticMetaObject);
-    return builder.toMetaObject();
-}
 
-QMetaObject *createDynamicQAbstractItemModelMetaObject()
+template <class T>
+QMetaObject *createDynamicMetaObject()
 {
     QMetaObjectBuilder builder;
-    builder.setClassName("DosQAbstractItemModel");
+    builder.setClassName(className<T>());
-    builder.setSuperClass(&QAbstractItemModel::staticMetaObject);
+    builder.setSuperClass(&T::staticMetaObject);
     return builder.toMetaObject();
 }
 
@@ -91,13 +89,19 @@ const DosIQMetaObject *BaseDosQMetaObject::superClassDosMetaObject() const
 }
 
 DosQObjectMetaObject::DosQObjectMetaObject()
-    : BaseDosQMetaObject(::createDynamicQObjectMetaObject())
+    : BaseDosQMetaObject(::createDynamicMetaObject<QObject>())
 {}
 
-DosQAbstractItemModelMetaObject::DosQAbstractItemModelMetaObject()
+template<class T>
-    : BaseDosQMetaObject(::createDynamicQAbstractItemModelMetaObject())
+DosQAbstractGenericModelMetaObject<T>::DosQAbstractGenericModelMetaObject()
+    : BaseDosQMetaObject(::createDynamicMetaObject<T>())
 {}
 
+// Force template instantations
+template class DosQAbstractGenericModelMetaObject<QAbstractItemModel>;
+template class DosQAbstractGenericModelMetaObject<QAbstractListModel>;
+
+
 DosQMetaObject::DosQMetaObject(DosIQMetaObjectPtr superClassMetaObject,
                                const QString &className,
                                const SignalDefinitions &signalDefinitions,