File indexing completed on 2024-05-12 04:39:28

 /*
     SPDX-FileCopyrightText: 2007 Aleix Pol <aleixpol@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "cmakecachemodel.h"
 #include <QFile>
 #include <KLocalizedString>
 
 #include "cmakecachereader.h"
 #include <debug.h>
 
 //4 columns: name, type, value, comment
 //name:type=value - comment
 CMakeCacheModel::CMakeCacheModel(QObject *parent, const KDevelop::Path &path)
     : QStandardItemModel(parent), m_filePath(path)
 {
     read();
 }
 
 void CMakeCacheModel::reset()
 {
     beginResetModel();
     clear();
     m_internal.clear();
     m_modifiedRows.clear();
     read();
     endResetModel();
 }
 
 void CMakeCacheModel::read()
 {
     // Set headers
     const QStringList labels{
         i18nc("@title:column", "Name"),
         i18nc("@title:column", "Type"),
         i18nc("@title:column", "Value"),
         i18nc("@title:column", "Comment"),
         i18nc("@title:column", "Advanced"),
         i18nc("@title:column", "Strings"),
     };
     setHorizontalHeaderLabels(labels);
 
     QFile file(m_filePath.toLocalFile());
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
     {
         qCDebug(CMAKE) << "error. Could not find the file";
         return;
     }
 
     int currentIdx=0;
     QStringList currentComment;
     QTextStream in(&file);
     QHash<QString, int> variablePos;
     while (!in.atEnd())
     {
         QString line = in.readLine().trimmed();
         if(line.startsWith(QLatin1String("//")))
         {
             line.remove(0, 2);
             currentComment += line;
         } else if(!line.isEmpty() && !line.startsWith(QLatin1Char('#'))) //it is a variable
         {
             CacheLine c;
             c.readLine(line);
 
             if(c.isCorrect())
             {
                 QString name=c.name(), flag=c.flag();
 
                 QString type=c.type();
                 QString value=c.value();
 
                 const QList<QStandardItem*> lineItems{
                     new QStandardItem(name),
                     new QStandardItem(type),
                     new QStandardItem(value),
                     new QStandardItem(currentComment.join(QLatin1Char('\n'))),
                 };
 
                 if(flag==QLatin1String("INTERNAL"))
                 {
                     m_internal.insert(name);
                 } else if(flag==QLatin1String("ADVANCED") || flag==QLatin1String("STRINGS"))
                 {
                     const auto posIt = variablePos.constFind(name);
                     if (posIt != variablePos.constEnd()) {
                         const int pos = *posIt;
                         
                         // if the flag is not ADVANCED, it's STRINGS.
                         // The latter is stored in column 5
                         int column = flag==QLatin1String("ADVANCED") ? 4 : 5;
                         QStandardItem *p = item(pos, column);
                         if(!p)
                         {
                             p=new QStandardItem(value);
                             setItem(pos, column, p);
                         }
                         else
                         {
                             p->setText(value);
                         }
                     }
                     else
                     {
                         qCDebug(CMAKE) << "Flag for an unknown variable";
                     }
                 }
 
                 if(!flag.isEmpty())
                 {
                     lineItems[0]->setText(lineItems[0]->text() + QLatin1Char('-') + flag);
                 }
                 insertRow(currentIdx, lineItems);
                 if (!variablePos.contains(name)) {
                     variablePos[name]=currentIdx;
                 }
                 currentIdx++;
                 currentComment.clear();
             }
         }
         else if(line.startsWith(QLatin1Char('#')) && line.contains(QLatin1String("INTERNAL")))
         {
             m_internalBegin=currentIdx;
 //                 qCDebug(CMAKE) << "Comment: " << line << " -.- " << currentIdx;
         }
     }
 }
 
 bool CMakeCacheModel::setData(const QModelIndex& index, const QVariant& value, int role)
 {
     bool ret = QStandardItemModel::setData(index, value, role);
     if (ret) {
         const auto i = index.row();
         m_modifiedRows.insert(i);
         emit valueChanged(item(i, 0)->text(), item(i, 2)->text());
     }
     return ret;
 }
 
 QVariantMap CMakeCacheModel::changedValues() const
 {
     QVariantMap ret;
     for(int i=0; i<rowCount(); i++)
     {
         if (!m_modifiedRows.contains(i))
             continue;
 
         QStandardItem* name = item(i, 0);
         QStandardItem* type = item(i, 1);
         QStandardItem* valu = item(i, 2);
 //         QStandardItem* comment = item(i, 3);
         ret.insert(name->text()+QLatin1Char(':')+type->text(), valu->text());
 
     }
     return ret;
 }
 
 QString CMakeCacheModel::value(const QString & varName) const
 {
     for(int i=0; i<rowCount(); i++)
     {
         QStandardItem* name = item(i, 0);
         if(name->text()==varName) {
             QStandardItem* valu = item(i, 2);
             return valu->text();
         }
     }
     return QString();
 }
 
 bool CMakeCacheModel::isAdvanced(int i) const
 {
     QStandardItem *p=item(i, 4);
     bool isAdv= (p!=nullptr) || i>m_internalBegin;
     if(!isAdv)
     {
         p=item(i, 1);
         isAdv = p->text()==QLatin1String("INTERNAL") || p->text()==QLatin1String("STATIC");
     }
 
     return isAdv || m_internal.contains(item(i,0)->text());
 }
 
 bool CMakeCacheModel::isInternal(int i) const
 {
     bool isInt= i>m_internalBegin;
     return isInt;
 }
 
 QList< QModelIndex > CMakeCacheModel::persistentIndices() const
 {
     QList< QModelIndex > ret;
     for(int i=0; i<rowCount(); i++)
     {
         QStandardItem* type = item(i, 1);
         if(type->text()==QLatin1String("BOOL"))
         {
             QStandardItem* valu = item(i, 2);
             ret.append(valu->index());
         }
     }
     return ret;
 }
 
 KDevelop::Path CMakeCacheModel::filePath() const
 {
     return m_filePath;
 }
 
 #include "moc_cmakecachemodel.cpp"