File indexing completed on 2024-05-19 16:31:38

 /*
  * SPDX-FileCopyrightText: 2015 Dominik Haumann <dhaumann@kde.org>
  *
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 #include "QuotaListModel.h"
 
 #include <QDebug>
 
 QuotaListModel::QuotaListModel(QObject *parent)
     : QAbstractListModel(parent)
 {
 }
 
 namespace
 {
 /**
  * QML data roles.
  */
 enum {
     DetailsRole = Qt::UserRole,
     IconRole,
     FreeStringRole,
     UsedStringRole,
     MountPointRole,
     UsageRole,
 };
 }
 
 QHash<int, QByteArray> QuotaListModel::roleNames() const
 {
     QHash<int, QByteArray> roles;
     roles[DetailsRole] = "details";
     roles[IconRole] = "icon";
     roles[FreeStringRole] = "free";
     roles[UsedStringRole] = "used";
     roles[MountPointRole] = "mountPoint";
     roles[UsageRole] = "usage";
 
     return roles;
 }
 
 QVariant QuotaListModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.row() >= m_items.size()) {
         return QVariant();
     }
 
     const auto item = m_items[index.row()];
 
     switch (role) {
     case DetailsRole:
         return item.mountString();
     case IconRole:
         return item.iconName();
     case FreeStringRole:
         return item.freeString();
     case UsedStringRole:
         return item.usedString();
     case MountPointRole:
         return item.mountPoint();
     case UsageRole:
         return item.usage();
     }
 
     return QVariant();
 }
 
 int QuotaListModel::rowCount(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return m_items.size();
     }
 
     return 0;
 }
 
 bool QuotaListModel::setData(const QModelIndex &index, const QVariant &variant, int role)
 {
     Q_UNUSED(role)
 
     const int row = index.row();
     if (index.isValid() && row < m_items.size()) {
         const QuotaItem item = variant.value<QuotaItem>();
 
         // This assert makes sure that changing items modify the correct item:
         // therefore, the unique identifier 'mountPoint()' is used. If that
         // is not the case, the newly inserted row must have an empty mountPoint().
         Q_ASSERT(item.mountPoint() == m_items[row].mountPoint() || m_items[row].mountPoint().isEmpty());
 
         if (m_items[row] != item) {
             m_items[row] = item;
             Q_EMIT dataChanged(index, index);
             return true;
         }
     }
 
     return false;
 }
 
 bool QuotaListModel::insertRows(int row, int count, const QModelIndex &parent)
 {
     // only top-level items are supported
     if (parent.isValid()) {
         return false;
     }
 
     beginInsertRows(QModelIndex(), row, row + count - 1);
     m_items.insert(row, count, QuotaItem());
     endInsertRows();
 
     return true;
 }
 
 bool QuotaListModel::removeRows(int row, int count, const QModelIndex &parent)
 {
     // only top-level items are valid
     if (parent.isValid() || (row + count) >= m_items.size()) {
         return false;
     }
 
     beginRemoveRows(QModelIndex(), row, row + count - 1);
     m_items.remove(row, count);
     endRemoveRows();
 
     return true;
 }
 
 void QuotaListModel::clear()
 {
     beginResetModel();
     m_items.clear();
     endResetModel();
 }
 
 namespace
 {
 QStringList mountPoints(const QVector<QuotaItem> &items)
 {
     QStringList list;
     for (auto &item : items) {
         list.append(item.mountPoint());
     }
     return list;
 }
 
 int indexOfMountPoint(const QString &mountPoint, const QVector<QuotaItem> &items)
 {
     for (int i = 0; i < items.size(); ++i) {
         if (mountPoint == items[i].mountPoint()) {
             return i;
         }
     }
     return -1;
 }
 }
 
 void QuotaListModel::updateItems(const QVector<QuotaItem> &items)
 {
     QStringList unusedMountPoints = mountPoints(m_items);
 
     // merge existing and new mount points
     for (auto &item : items) {
         // remove still used item from unused list
         unusedMountPoints.removeOne(item.mountPoint());
 
         // insert or modify m_items
         int row = indexOfMountPoint(item.mountPoint(), m_items);
         if (row < 0) {
             // new item: append on end
             row = m_items.size();
             insertRow(row);
         }
         setData(createIndex(row, 0), QVariant::fromValue(item));
     }
 
     // remove mount points, that do not exist anymore
     for (const auto &mountPoint : unusedMountPoints) {
         const int row = indexOfMountPoint(mountPoint, m_items);
         Q_ASSERT(row >= 0);
         removeRow(row);
     }
 }