QAbstractListModel and QList Adapter

Question

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).

Answer 1

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. ...
};

Answer 2

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.