Warning, file /office/calligra/libs/rdf/KoSopranoTableModel.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /* This file is part of the KDE project
    Copyright (C) 2010 KO GmbH <ben.martin@kogmbh.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KoSopranoTableModel.h"
 
 #include "KoDocumentRdf.h"
 #include "KoRdfPrefixMapping.h"
 // KF5
 #include <kdebug.h>
 #include <klocalizedstring.h>
 
 #include <algorithm>
 
 KoSopranoTableModel::KoSopranoTableModel(KoDocumentRdf *rdf)
         : m_rdf(rdf)
 {
     Soprano::StatementIterator siter = model()->listStatements();
     while (siter.next()) {
         m_statementIndex << *siter;
     }
 }
 
 QSharedPointer<Soprano::Model> KoSopranoTableModel::model() const
 {
     return m_rdf->model();
 }
 
 QString KoSopranoTableModel::URItoPrefexedLocalname(const QString &uri) const
 {
     return m_rdf->prefixMapping()->URItoPrefexedLocalname(uri);
 }
 QString KoSopranoTableModel::PrefexedLocalnameToURI(const QString &pname)
 {
     return m_rdf->prefixMapping()->PrefexedLocalnameToURI(pname);
 }
 
 QVariant KoSopranoTableModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
     Soprano::Statement st = m_statementIndex[index.row()];
     if (index.column() == ColIsValid && role == Qt::CheckStateRole) {
         return st.isValid();
     }
     if (role == Qt::BackgroundRole) {
         if (!m_statementIndex[index.row()].isValid()) {
             return QColor("#BB0000");
         }
     }
     if (role != Qt::DisplayRole && role != Qt::EditRole) {
         return QVariant();
     }
     switch (index.column()) {
     case ColIsValid:
         return QVariant();
     case ColSubj:
         return URItoPrefexedLocalname(st.subject().toString());
     case ColPred:
         return URItoPrefexedLocalname(st.predicate().toString());
     case ColObj:
         if (st.object().type() == Soprano::Node::ResourceNode)
             return URItoPrefexedLocalname(st.object().toString());
         return st.object().toString();
     case ColObjType:
         switch (st.object().type()) {
         case Soprano::Node::EmptyNode:
             return i18n("Empty");
         case Soprano::Node::ResourceNode:
             return i18n("URI");
         case Soprano::Node::LiteralNode:
             return i18n("Literal");
         case Soprano::Node::BlankNode:
             return i18n("Blank");
         }
         return QString();
     case ColObjXsdType:
         return st.object().dataType().toString();
     case ColCtx: {
         QString ctx = st.context().toString();
         QString RdfPathContextPrefix = m_rdf->RDF_PATH_CONTEXT_PREFIX;
         QString InternalContext = m_rdf->inlineRdfContext().toString();
 
         kDebug(30015) << "InternalContext:" << InternalContext;
         kDebug(30015) << "ctx:" << ctx;
 
         if (ctx.startsWith(RdfPathContextPrefix)) {
             ctx.remove(0, RdfPathContextPrefix.size());
         }
         if (isInlineRdf(st)) {
             ctx = "inline";
         }
         return ctx;
     }
     }
     return QVariant();
 }
 
 int KoSopranoTableModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return model()->statementCount();
 }
 
 int KoSopranoTableModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return ColCount;
 }
 
 QVariant KoSopranoTableModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
         switch (section) {
         case ColIsValid:
             return i18n("Valid");
         case ColSubj:
             return i18n("Subject");
         case ColPred:
             return i18n("Predicate");
         case ColObj:
             return i18n("Object");
         case ColObjType:
             return i18n("Obj Type");
         case ColObjXsdType:
             return i18n("DataType");
         case ColCtx:
             return i18n("Stored In");
         }
     }
     return QVariant();
 }
 
 bool KoSopranoTableModel::isInlineRdf(const Soprano::Statement &st) const
 {
     return (st.context().toString() == m_rdf->inlineRdfContext().toString());
 }
 
 Qt::ItemFlags KoSopranoTableModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags ret = QAbstractTableModel::flags(index) | Qt::ItemIsEditable;
     if (index.column() == ColIsValid) {
         ret |= Qt::ItemIsUserCheckable;
     }
     if (index.row() >= 0) {
         Soprano::Statement st = m_statementIndex[index.row()];
         if (isInlineRdf(st)) {
             if (index.column() == ColSubj
                     || index.column() == ColObjType
                     || index.column() == ColCtx) {
                 ret &= (~Qt::ItemIsEditable);
             }
         }
     }
     return ret;
 }
 
 /**
  * You MUST use this method if you want to change a Statement.
  *
  * Used by setData() to remove the old statement and replace it with the new 'n' one.
  * The internal m_statementIndex int->statement is updated
  * as well as the dataChanged signal emitted
  */
 bool KoSopranoTableModel::setDataUpdateTriple(const QModelIndex &index, const Soprano::Statement &old, const Soprano::Statement &n)
 {
     model()->addStatement(n);
     model()->removeStatement(old);
     m_statementIndex[index.row()] = n;
     emit dataChanged(index, index);
     return true;
 }
 
 bool KoSopranoTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     Q_UNUSED(role);
     if (!index.isValid()) {
         return false;
     }
     int r = index.row();
     Soprano::Statement st = m_statementIndex[r];
     QString uri = PrefexedLocalnameToURI(value.toString());
     Soprano::Statement n(st.subject(), st.predicate(), st.object(), st.context());
     switch (index.column()) {
     case ColSubj:
         n.setSubject(Soprano::Node(QUrl(uri)));
         return setDataUpdateTriple(index, st, n);
     case ColPred:
         n.setPredicate(Soprano::Node(QUrl(uri)));
         return setDataUpdateTriple(index, st, n);
     case ColObj: {
         if (st.object().isLiteral()) {
             n.setObject(
                 Soprano::Node(
                     Soprano::LiteralValue(value.toString())));
         } else {
             n.setObject(Soprano::Node(QUrl(uri)));
         }
         return setDataUpdateTriple(index, st, n);
     }
     case ColObjType: {
         QString v = value.toString();
         if (v == "URI") {
             n.setObject(Soprano::Node(QUrl(st.object().toString())));
         } else if (v == "Literal") {
             n.setObject(
                 Soprano::Node(
                     Soprano::LiteralValue(st.object().toString())));
         } else {
             n.setObject(Soprano::Node(QString(st.object().toString())));
         }
         return setDataUpdateTriple(index, st, n);
     }
     case ColCtx: {
         QString v = value.toString();
         if (v == "inline") {
             QString InternalContext = m_rdf->rdfInternalMetadataWithoutSubjectURI();
             n.setContext(Soprano::Node(QUrl(InternalContext)));
         } else {
             if (!v.endsWith(".rdf"))
                 v = v + ".rdf";
             n.setContext(Soprano::Node(QUrl(m_rdf->RDF_PATH_CONTEXT_PREFIX + v)));
         }
         return setDataUpdateTriple(index, st, n);
     }
     }
     return false;
 }
 
 /**
  * Add the statement 'st' to the model as the new last row.
  */
 int KoSopranoTableModel::insertStatement(const Soprano::Statement &st)
 {
     QModelIndex parent;
     int newRowNumber = rowCount();
     kDebug(30015) << "insert, newrow:" << newRowNumber << endl;
     beginInsertRows(parent, newRowNumber, newRowNumber);
     model()->addStatement(st);
     m_statementIndex << st;
     endInsertRows();
     return newRowNumber;
 }
 
 /**
  * Copy all the triples in srclist to be new rows in the model.
  * Note that the object value is modified to contain a unique
  * postfix so that the new triple copies can be inserted into
  * the Rdf model. It is a copy in a looser sense of the word.
  */
 QModelIndexList KoSopranoTableModel::copyTriples(const QModelIndexList &srclist)
 {
     QModelIndexList ret;
     int FirstNewRowNumber = rowCount();
     int LastNewRowNumber = FirstNewRowNumber + srclist.size() - 1;
     int currentNewRowNum = FirstNewRowNumber;
     beginInsertRows(QModelIndex(), FirstNewRowNumber, LastNewRowNumber);
     kDebug(30015) << " m_statementIndex.sz:" << m_statementIndex.size();
     kDebug(30015) << " srclist.size():" << srclist.size();
     kDebug(30015) << " first:" << FirstNewRowNumber;
     kDebug(30015) << " last:" << LastNewRowNumber;
     foreach (const QModelIndex &src, srclist) {
         int r = src.row();
         kDebug(30015) << "r:" << r;
         Soprano::Statement st = m_statementIndex[ r ];
         //
         // Append a bnode to the object to ensure the "copy"
         // is unique relative to the original.
         //
         Soprano::Node obj(QUrl(st.object().toString() + '-'
                                + model()->createBlankNode().toString()));
         Soprano::Statement n(st.subject(), st.predicate(),
                              obj, st.context());
         model()->addStatement(n);
         m_statementIndex << n;
         QModelIndex newIdx = index(currentNewRowNum, ColSubj);
         ret << newIdx;
         ++currentNewRowNum;
     }
     endInsertRows();
     return ret;
 }
 
 /**
  * Delete all the triples in srclist from the model.
  */
 void KoSopranoTableModel::deleteTriples(const QModelIndexList &srclist)
 {
     //
     // Because items after a row are shuffled back to fill
     // it's position, it is easiest to remove each item
     // starting at the largest row number and working
     // down by descending row number.
     //
     QList<int> rowsToRemoveDesc;
     foreach (const QModelIndex &src, srclist) {
         int r = src.row();
         rowsToRemoveDesc << r;
     }
     std:sort(rowsToRemoveDesc.begin(), rowsToRemoveDesc.end(), std::greater<int>());
     int r;
     foreach (r, rowsToRemoveDesc) {
         Soprano::Statement st = m_statementIndex[ r ];
         int firstRow =  r;
         int lastRow = r;
         beginRemoveRows(QModelIndex(), firstRow, lastRow);
         model()->removeStatement(st);
         // m_statementIndex[ r ] = Soprano::Statement();
         for (int i = r; i < m_statementIndex.size() - 1; ++i) {
             m_statementIndex[ i ] = m_statementIndex[ i + 1 ];
         }
         m_statementIndex.removeLast();
         endRemoveRows();
     }
 }
 
 Soprano::Statement KoSopranoTableModel::statementAtIndex(const QModelIndex &index) const
 {
     return m_statementIndex[index.row()];
 }
 
 int KoSopranoTableModel::invalidStatementCount() const
 {
     return invalidStatementList().size();
 }
 
 QModelIndexList KoSopranoTableModel::invalidStatementList() const
 {
     QModelIndexList ret;
     for (int r = 0; r < m_statementIndex.size(); ++r)  {
         const Soprano::Statement &s = m_statementIndex.at(r);
         if (!s.isValid()) {
             int col = ColSubj;
             if (!s.subject().isValid()) {
                 col = ColSubj;
             }
             if (!s.predicate().isValid()) {
                 col = ColPred;
             }
             if (!s.object().isValid()) {
                 col = ColObj;
             }
             QModelIndex idx = index(r, col);
             ret << idx;
         }
     }
     return ret;
 }