Creating tree kind of model from QAbstractItemModel or QAbstractListModel

As per the below code, I need to create a model which will have N number of "System", and each "System" will have N number of "SytemDatabase" and each "SytemDatabase" will have N number of "CoresData". This N number will come to know during the launch time of application.

Code:

---

struct CoresData {
    int m_iCoreSpeed;
    bool m_bCoreAvailable;
};
 
class SytemDatabase {
public:
    SytemDatabase();
    bool  m_bDatabaseVisible;
    int m_iDatabaseNumber;
    QList<CoresData> m_listCoresData;
};
 
class Sytem {
public:
    Sytem();
    bool  m_bSystemAvailable;
    int m_iSystemNumber;
    QList<SytemDatabase> m_listSytemDatabase;
};
 
 
 
class SytemTree : public QAbstractItemModel {
    Q_OBJECT
public:
    explicit SytemTree( QObject *parent = nullptr);
    ~SytemTree();
    QVariant data(const QModelIndex &index, int role) const override;
    Qt::ItemFlags flags(const QModelIndex &index) const override;
    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
    QModelIndex parent(const QModelIndex &index) const override;
    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
 
private:
    void addSytemDatabase(Sytem &data);
    QList<Sytem> m_listSystem;
};

---

Currently I have designed this model using a ListModel and its working fine. Now for some reason i need to move this model to cpp side and pass that model to qml. Below is the QML code for just a reference

Code:

---

SytemTree.append({ "iSystemNumber": systemNumber, "bSystemAvailable": false, "SytemDatabase":[{ "iDatabaseNumber": databaseNumber, "bDatabaseVisible": false,"CoresData": []}]})
 
        for( var lp = 0; lp < totalcoreData; ++lp) {
                SytemTree.get(systemNumber).SytemDatabase.get(iDatabaseNumber).CoresData.append({ "bCoreAvailable": true, "bCoreAvailable": true, "iCoreNumber": coreNumber})
                }

---

In qml side i want to use this model as like below

Code:

---

Repeater {
                id: repeaterRootSystem
                model: SytemTree
                delegate: Rectangle {--
                ----
            }
             Repeater {
                id: repeaterDatabase
                model: SytemTree.get(index).SytemDatabase
                delegate: Rectangle {---
                ---
            }
            Repeater {
                id: repeaterCoresData
                model: SytemTree.get(index).SytemDatabase.get(index).CoresData
                delegate: Rectangle {--
                ----
            }

---

I have gone through concepts QAbstractListModel, QAbstractItemModel and QAbstractTableModel. But am looking for a model like one list model, and each list element will contain a tree like structure as mentioned above in the classes. Requesting anyone to suggest how to create a model which will have tree like structure. and which QAbstractxxxxxmodel will be correct to implement this concept. and in QML side i want to access the data through the index untill coresData , same like above QML code.

Thanks in advance.

Since you want a tree it should be obvious that a QListModel and QTableModel can not work. You have to go with a QAbstractItemModel. For a simple tree model see here: https://doc.qt.io/qt-5/qtwidgets-ite...l-example.html

Thank you very much for the reply.
I have gone through the link you have shared. But really is it possible to implement the model like below qml code consider the model is developed in cpp side with reference to above cpp classes Sytem, SytemDatabase and CoresData.

Code:

---

Repeater {
                id: repeaterRootSystem
                model: SytemTree
                delegate: customRectangle {---
					visible: systemAvailable
					value: systemNumber
					----
					Repeater {
						id: repeaterDatabase
						model: SytemTree.get(index).SytemDatabase
						delegate: customRectangle {---
							visible: databaseVisible
							value: databaseNumber
							---
							Repeater {
								id: repeaterCoresData
								model: SytemTree.get(index).SytemDatabase.get(index).CoresData
								delegate: customRectangle {--
									visible: coreAvailable
									value: coreNumber
									speed: coreSpeed
									----
								}
							}
						}
					}
				}
			}

---

Quote:

---

But really is it possible to implement the model like below qml code consider the model is developed in cpp side with reference to above cpp classes Sytem, SytemDatabase and CoresData.

---

Yes. The QAbstractItemModel is simply a wrapper for your internal data structure that allows the tree to be displayed in a QTreeView or filtered by proxies, etc.

So if you already have a C++ tree-shaped data structure, then you must derive a class from QAbstractItemModel that is a mirror for that structure. In your model's data(), rowCount(), columnCount(), and other virtual methods you must implement, you will return whatever information is appropriate for that level in the tree.

Implementing a tree model is not always easy, especially when different levels of the tree represent different C++ data structures. But it can be done.

I have 2 doubts ,
1. Do I need to derive my all classes system,SytemDatabase and CoresData from QAbstractItemModel .
2. Or Do i need to write like here in the example https://doc.qt.io/qt-5/qtwidgets-ite...l-example.html. please find the below code as per the example

Code:

---

class CoresData {
public:
	CoresData();
	~CoresData();
 
    void appendChild(CoresData *child);
    CoresData *child(int row);
    int childCount() const;
    int columnCount() const;
    QVariant data(int column) const;
    int row() const;
    CoresData *parentItem();
 
    int m_iCoreSpeed;
    bool m_bCoreAvailable;
	int m_iCoreNumber;
private:
	CoresData *m_parentItem;
};
 
class SytemDatabase {
public:
    SytemDatabase();
	~SytemDatabase();
 
    void appendChild(SytemDatabase *child);
    SytemDatabase *child(int row);
    int childCount() const;
    int columnCount() const;
    QVariant data(int column) const;
    int row() const;
    SytemDatabase *parentItem();
 
	bool  m_bDatabaseVisible;
    int m_iDatabaseNumber;
private:
	QVector<SytemDatabase*> m_childItems;
	SytemDatabase *m_parentItem;    
    QList<CoresData> m_listCoresData;
};
 
class Sytem {
public:
    Sytem();
	~Sytem();
 
    void appendChild(Sytem *child);
    Sytem *child(int row);
    int childCount() const;
    int columnCount() const;
    QVariant data(int column) const;
    int row() const;
    Sytem *parentItem();
 
	bool  m_bSystemAvailable;
    int m_iSystemNumber;
private:
	QVector<Sytem*> m_childItems;
	Sytem *m_parentItem;
    QList<SytemDatabase> m_listSytemDatabase;	
};
 
 
 
class SytemTree : public QAbstractItemModel {
    Q_OBJECT
public:
    explicit SytemTree( QObject *parent = nullptr);
    ~SytemTree();
	QVariant data(const QModelIndex &index, int role) const override;
    Qt::ItemFlags flags(const QModelIndex &index) const override;
    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
    QModelIndex parent(const QModelIndex &index) const override;
    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
 
private:
	void addSytemDatabase(Sytem &data);
    QList<Sytem> m_listSystem;
};

---

because i need to consider this model usage in qml i.e

Code:

---

--
model: System
-----
model: SytemTree.get(index).SytemDatabase 
-----
model: SytemTree.get(index).SytemDatabase.get(index).CoresData
----

---

and also in the 2nd doubt, how to handle this pointer m_parentItem?? Since different level of tree is having different structure

Quote:

---

1. Do I need to derive my all classes system,SytemDatabase and CoresData from QAbstractItemModel .

---

No. You probably do not have to change any of your existing classes. What you need is to derive a QAbstractItemModel that -uses- those classes (and the hierarchy you have built with them) to retrieve the information that will be displayed in your UI.

Quote:

---

2. Or Do i need to write like here in the example

---

Also no, because your tree does not have a hierarchy like TreeItem -> TreeItem -> TreeItem... where all entries at any level of the tree are the same. In your case, you have System -> SystemDatabase -> CoresData. So, the "parent" item pointer for CoresData should point to the instance of SystemDatabase that owns it, SystemDatabase's parent is System, etc.

And it makes no sense to have a CoresData:: appendChild() method, since those are the leaves of your tree and can't have children. Likewise, SystemDatabase:: appendChild() should add a CoresData child, not a SystemDatabase child. Same for the System class - it has SystemDatabase children.

Your SystemTree class looks good, except I would add the System list as QList< System * > instead of QList< System >. If you define it as QList< System >, then the lifetime of the list entries is defined by the lifetime of the SystemTree - when the SystemTree goes out of scope, the QList and its contents will be deleted. If you define it as QList< System * >, then you can create and manage the System instances independently of the tree model. When the SystemTree goes out of scope, only the QList will be destroyed, not the pointers stored in it.