QAbstractListModel and QList Adapter
-
17-04-2021 - |
Pergunta
My application stores a few objects of a type that inherits from
QAbstractListModel
objects.
This generates quite a lot of duplicated code when wrapping a simple
std::vector<T>
or a QList<T>
into model with the general add,
delete and multi-selection functionality.
Is that the way QAbstractListModel
is supposed to be used or is there
some adapter class that can remove the duplicated code (at least for
containers that are part of Qt)?
Example: I want to wrap vector<ObjectA>
and vector<ObjectB>
into a model. The code for insertRows
, deleteRows
, columnCount
etc. is always going to be the same and I would like to consolidate that (with a little meta-programming that could even work for with tuple
and data
).
Solução
You have to do this in two separate classes because Qt's extensions to c++ (SIGNALS, SLOTS, etc.) do not play well with templates. The rationale and workaround for this can be found at: https://doc.qt.io/archives/qq/qq15-academic.html
Here is a rough outline of a solution. (This is based on code we are using in our application and that is working fine.)
1. Abstract list class that does Qt stuff
class FooListModelQt : public QAbstractTableModel {
Q_OBJECT
public:
// Non-template methods, signals, slots, etc. can be used here. For example...
QSet<int> SelectedRows() const;
// ... etc. ...
signals:
void SelectionChanged();
// ... etc. ...
protected:
explicit FooListModelQt(QObject *parent = NULL);
virtual ~FooListModelQt() = 0;
// ... etc. ...
};
2. Abstract class that does template stuff
template <typename T>
class FooListModel : public FooListModelQt {
public:
const T* at(int index) const { return items_.at(index); }
int count() const { return items_.count(); }
void Append(T *item);
// ... etc. ...
protected:
explicit FooListModel(QObject *parent = NULL);
virtual ~FooListModel();
private:
QList<T*> items_;
};
3. Actual list class
class BarListModel : public FooListModel<Bar> {
Q_OBJECT
public:
explicit BarListModel(QObject *parent = NULL);
int columnCount(const QModelIndex &parent) const;
QVariant data(const QModelIndex &index, int role) const;
// ... etc. ...
};
Outras dicas
Normally I would implement my own model inheriting from QAbstractItemModel
directly and provide my own implementation for the presentation functions such as data()
to handle the data storage container I give the model.
If you have code duplication for using QList<T>
and std::vector<T>
then I would suggest converting one to the other by doing either:
QList<T> list = QList::fromVector(QVector::fromStdVector(vector));
or the other way.
std::vector<T> vector = qlist.toVector().toStdVector();
I'd do the latter but you can choose either.
Based on your additional comments there are 2 paths of action you can take:
Path 1:
Implement objectA
and objectB
as follows:
class objectA : baseObject
and
class objectB : baseObject
where baseObject
is:
struct baseObject
{
virtual std::string toString() = 0;
};
Probably easier to convert to string then anything else.
Path 2 will basically involve inside the model using std::vector<boost::any>()
as your data storage container, this way you can implement a single model subclassing QAbstractListModel
.
The thing that you have to consider that if your data storage container you can probably make common the data presentation you are limited at what you can do because data()
function that will give your view the element has to return QVariant
and it's limited at what you can construct it from.