Continues migration with DDS, Common

Lts/Common/LtsWidgets/lts_abstract_table_model.h

@@ -0,0 +1,286 @@
+
+
+
+#pragma once
+
+#include "lts_base.h"
+
+#include <LtsUtilsCore/data_modification_enum.h>
+
+#include <QVector>
+#include <QAbstractTableModel>
+
+#include <memory>
+#include <algorithm>
+
+
+namespace LtsWidgets
+{
+
+template<class T>
+class LtsAbstractTableModel : public QAbstractTableModel
+{
+public:
+  LtsAbstractTableModel(const QVector<QString> &header, QObject *parent)
+    : QAbstractTableModel(parent)
+    , m_vecColumns(header)
+  {}
+
+  QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override
+  {
+    if (role == Qt::DisplayRole && orientation == Qt::Horizontal && section>= 0 && section < m_vecColumns.size())
+      return m_vecColumns[section];
+
+    return QAbstractTableModel::headerData(section, orientation, role);
+  }
+
+  bool isEmpty(const QModelIndex &parent = QModelIndex())
+  {
+    return parent.isValid() ? true : m_vecData.isEmpty();
+  }
+
+  int rowCount(const QModelIndex &parent = QModelIndex()) const override
+  {
+    return parent.isValid() ? 0 : m_vecData.size();
+  }
+
+  int columnCount(const QModelIndex &parent = QModelIndex()) const override
+  {
+    return parent.isValid() ? 0 : m_vecColumns.size();
+  }
+
+  void clear()
+  {
+    beginResetModel();
+    m_vecData.clear();
+    endResetModel();
+  }
+
+  bool indexIsValid(const QModelIndex &idx) const
+  {
+    if (!idx.isValid())
+      return false;
+    if (idx.row() < 0 || idx.row() >= m_vecData.size())
+      return false;
+    return true;
+  }
+
+  virtual bool removeRow(int row)
+  {
+    return removeRows(row, 1);
+  }
+
+  bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex()) override
+  {
+    if (parent.isValid())
+      return false;
+
+    if (row < 0 || row >= m_vecData.size())
+      return false;
+
+    int range = std::min(row + count, m_vecData.size());
+
+    beginRemoveRows(QModelIndex(), row, range - 1);
+    m_vecData.erase(m_vecData.begin() + row, m_vecData.begin() + range);
+    endRemoveRows();
+
+    return true;
+  }
+
+  virtual bool insertRow(const T &item)
+  {
+    if (isFiltered(item, DataModification::eAdded) || isDeletedInternal(item))
+      return false;
+    beginInsertRows(QModelIndex(), m_vecData.size(), m_vecData.size());
+    m_vecData.append(item);
+    endInsertRows();
+    return true;
+  }
+
+  template <typename CONT>
+  void insertRows(const CONT &items)
+  {
+    if (items.isEmpty())
+      return;
+    const int cntBefore = m_vecData.size();
+    for (const auto &item : items)
+    {
+      if (isFiltered(item, DataModification::eAdded) || isDeletedInternal(item))
+        continue;
+      m_vecData += item;
+    }
+    const int cntAfter = m_vecData.size();
+    if (cntBefore == cntAfter)
+      return;
+    beginInsertRows(QModelIndex(), cntBefore, cntAfter - 1);
+    endInsertRows();
+  }
+
+  void setData(const QVector<T> &vecData)
+  {
+    clear();
+    insertRows(vecData);
+  }
+
+  
+
+  void update()
+  {
+    if (!m_vecData.isEmpty())
+      emit dataChanged(index(0, 0), index(m_vecData.size() - 1, columnCount() - 1));
+  }
+
+  T getRowData(int row) const
+  {
+    if (row < 0 || row >= m_vecData.size())
+      return T();
+    return m_vecData.at(row);
+  }
+
+  bool setRowData(int row, const T &data)
+  {
+    if (row < 0 || row >= m_vecData.size())
+      return false;
+
+    m_vecData[row] = data;
+    emit dataChanged(index(row, 0), index(row, columnCount() - 1));
+    return true;
+  }
+
+  QModelIndex findIndexForId(int id, int column = 0) const
+  {
+    const int row = findRowForId(id);
+    if (row < 0)
+      return QModelIndex();
+    return index(row, column);
+  }
+
+  int getId(const QModelIndex &mi) const
+  {
+    if (!indexIsValid(mi))
+      return -1;
+    return getIdInternal(m_vecData.at(mi.row()));
+  }
+
+protected:
+  template <class C>
+  class HasId
+  {
+    template <class CLS>
+    static std::true_type testSignature(const int &(CLS::*)() const);
+    template <class CLS>
+    static std::true_type testSignature(int (CLS::*)() const);
+
+    template <class CLS>
+    static decltype(testSignature(&CLS::id)) test(std::nullptr_t);
+
+    template <class CLS>
+    static std::false_type test(...);
+
+  public:
+    using type = decltype(test<C>(nullptr));
+    static const bool value = type::value;
+  };
+
+  
+  template <typename F = T, typename std::enable_if<HasId<F>::value, int>::type = 0>
+  int getIdInternal(const F &data) const
+  {
+    return data.id();
+  }
+  
+  
+  virtual int getId(const T &data) const
+  {
+    Q_ASSERT(false);
+    Q_UNUSED(data);
+    return -1;
+  }
+
+  template < typename F = T, typename std::enable_if < !HasId<F>::value, int>::type = 0>
+  int getIdInternal(const F &data) const
+  {
+    return getId(data);
+  }
+
+  template <class C>
+  class HasIsDeleted
+  {
+    template <class CLS>
+    static std::true_type testSignature(const bool &(CLS::*)() const);
+    template <class CLS>
+    static std::true_type testSignature(bool (CLS::*)() const);
+
+    template <class CLS>
+    static decltype(testSignature(&CLS::isDeleted)) test(std::nullptr_t);
+
+    template <class CLS>
+    static std::false_type test(...);
+
+  public:
+    using type = decltype(test<C>(nullptr));
+    static const bool value = type::value;
+  };
+  
+  template <typename F = T, typename std::enable_if<HasIsDeleted<F>::value, int>::type = 0>
+  bool isDeletedInternal(const F &data) const
+  {
+    return data.isDeleted();
+  }
+  
+  virtual int isDeleted(const T &data) const
+  {
+    Q_UNUSED(data);
+    return false;
+  }
+  template < typename F = T, typename std::enable_if < !HasIsDeleted<F>::value, int>::type = 0>
+  bool isDeletedInternal(const F &data) const
+  {
+    return isDeleted(data);
+  }
+
+  
+  virtual bool isFiltered(const T &data, DataModification modType) const
+  {
+    Q_UNUSED(data);
+    Q_UNUSED(modType);
+    return false;
+  }
+
+  
+  virtual bool onDataChanged(const T &data, DataModification modType)
+  {
+    if (isFiltered(data, modType))
+      return false;
+
+    const int id = getIdInternal(data);
+    const int row = findRowForId(id);
+
+    
+    if (modType == DataModification::eRemoved || isDeletedInternal(data))
+    {
+      if (row >= 0)
+        return removeRow(row);
+      return false;
+    }
+
+    if (modType == DataModification::eAdded && row < 0)
+      return insertRow(data);
+
+    return setRowData(row, data);
+  }
+
+  int findRowForId(int id) const
+  {
+    for (int i = 0; i < m_vecData.size(); ++i)
+    {
+      if (getIdInternal(m_vecData.at(i)) == id)
+        return i;
+    }
+    return -1;
+  }
+
+  QVector<T> m_vecData;
+  QVector<QString> m_vecColumns;
+};
+}