hdt 3.1.1 → 3.2.1

package/deps/hdt-it/sparqlform.hpp

@@ -0,0 +1,28 @@
+#ifndef JOINFORM_HPP
+#define JOINFORM_HPP
+
+#include <QMainWindow>
+
+#include "sparqlmodel.hpp"
+
+namespace Ui {
+    class SparqlForm;
+}
+
+class SparqlForm : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+    explicit SparqlForm(QWidget *parent = 0);
+    ~SparqlForm();
+
+private slots:
+    void on_pushButton_clicked();
+
+private:
+    Ui::SparqlForm *ui;
+    SparqlModel *sparqlModel;
+};
+
+#endif // JOINFORM_HPP

package/deps/hdt-it/sparqlform.ui

@@ -0,0 +1,112 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>SparqlForm</class>
+ <widget class="QMainWindow" name="SparqlForm">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>603</width>
+    <height>664</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>SPARQL Search</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <property name="sizePolicy">
+    <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+     <horstretch>0</horstretch>
+     <verstretch>0</verstretch>
+    </sizepolicy>
+   </property>
+   <layout class="QHBoxLayout" name="horizontalLayout_2">
+    <item>
+     <widget class="QSplitter" name="splitter_2">
+      <property name="orientation">
+       <enum>Qt::Vertical</enum>
+      </property>
+      <widget class="QGroupBox" name="groupBox">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="title">
+        <string>SPARQL</string>
+       </property>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QTextEdit" name="sparqlTextEdit">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+            <horstretch>0</horstretch>
+            <verstretch>1</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="html">
+           <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
+&lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
+p, li { white-space: pre-wrap; }
+&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Lucida Grande'; font-size:13pt; font-weight:400; font-style:normal;&quot;&gt;
+&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;SELECT ?x ?y ?z WHERE {?x ?y ?z . }&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="pushButton">
+          <property name="text">
+           <string>Search</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QSplitter" name="splitter">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <widget class="QTableView" name="sparqlResultTable">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>0</horstretch>
+          <verstretch>4</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="alternatingRowColors">
+         <bool>true</bool>
+        </property>
+        <property name="textElideMode">
+         <enum>Qt::ElideMiddle</enum>
+        </property>
+        <attribute name="horizontalHeaderDefaultSectionSize">
+         <number>300</number>
+        </attribute>
+        <attribute name="horizontalHeaderMinimumSectionSize">
+         <number>50</number>
+        </attribute>
+        <attribute name="verticalHeaderDefaultSectionSize">
+         <number>20</number>
+        </attribute>
+       </widget>
+      </widget>
+     </widget>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>603</width>
+     <height>22</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

package/deps/hdt-it/sparqlmodel.cpp

@@ -0,0 +1,155 @@
+#include "sparqlmodel.hpp"
+#include <sstream>
+
+#include <SingleTriple.hpp>
+
+#include <QFont>
+
+SparqlModel::SparqlModel(HDTController *controller) :
+    hdtController(controller),
+    binding(NULL),
+    currentIndex(0),
+    numresults(0)
+{
+}
+
+void SparqlModel::find(unsigned int index) {
+    if(currentIndex>index) {
+        currentIndex=0;
+        binding->goToStart();
+        binding->findNext();
+    }
+    while(currentIndex<index) {
+        if(binding->findNext()) {
+            currentIndex++;
+        } else {
+	    numresults = currentIndex+1;
+            emit layoutChanged();
+            break;
+        }
+    }
+}
+
+SparqlModel::~SparqlModel()
+{
+
+}
+
+class SparqlQuery {
+public:
+        set<string> vars;
+        vector<hdt::TripleString> patterns;
+};
+
+SparqlQuery parseSparql(string query) {
+        struct SparqlQuery output;
+        string word;
+        unsigned int phase = 0;
+        vector<string> pattern;
+
+        stringstream in(query, ios::in);
+
+        while(in >> word) {
+                cout << word << endl;
+                if(word.size()==0) {
+                        continue;
+                }
+                if(phase==0) {
+                        if(word.at(0)=='?') {
+                                output.vars.insert(word);
+                        } else if(word=="WHERE") {
+                                phase++;
+                        }
+                } else {
+                        if(word.at(0)=='.') {
+                                if(pattern.size()!=3) {
+                                        throw "Pattern should have 3 components";
+                                }
+                                hdt::TripleString trip(pattern[0], pattern[1], pattern[2]);
+                                output.patterns.push_back(trip);
+                                pattern.clear();
+                        } else {
+				if(word.at(0)=='{') {
+
+				} else if(word.at(0)!='.'){
+				   cout << "**"<< word << "**" << endl;
+				    pattern.push_back(word);
+                                }
+                        }
+                }
+        }
+        return output;
+}
+
+void SparqlModel::setQuery(QString queryTxt)
+{
+    throw "Not implemented";
+#if 0
+    SparqlQuery query = parseSparql(string(queryTxt.toAscii()));
+
+    if(binding) {
+        delete binding;
+    }
+
+    binding = hdtManager->getHDT()->searchJoin(query.patterns, query.vars);
+    binding->findNext();
+    numresults = binding->estimatedNumResults();
+    currentIndex = 0;
+
+    emit layoutChanged();
+#endif
+}
+
+int SparqlModel::rowCount(const QModelIndex &parent) const {
+    return numresults;
+}
+int SparqlModel::columnCount(const QModelIndex &parent) const {
+    if(binding==NULL) {
+        return 0;
+    }
+    return binding->getNumVars();
+}
+QVariant SparqlModel::data(const QModelIndex &index, int role) const {
+    if(binding == NULL) {
+        return QVariant();
+    }
+
+    switch(role) {
+    case Qt::ToolTipRole:
+    case Qt::DisplayRole:
+    {
+        // Compiler complains that by calling findTriple we are modifying internal
+        // state, which is illegal due to this function being const. But we need to
+        // modify the currentIndex and currentTriple, so we can avoid it.
+	SparqlModel *noConstThis = const_cast<SparqlModel *>(this);
+        noConstThis->find(index.row());
+
+        return binding->getVar(index.column()).c_str();
+    }
+    case Qt::FontRole:
+    {
+        static QFont font;
+        font.setPointSize(10);
+        return font;
+    }
+
+    }
+    return QVariant();
+}
+QVariant SparqlModel::headerData(int section, Qt::Orientation orientation, int role) const {
+    if(binding==NULL) {
+        return QVariant();
+    }
+    switch(role) {
+    case Qt::DisplayRole:
+    {
+        if(orientation == Qt::Horizontal) {
+            return binding->getVarName(section);
+        } else {
+            return QString::number(section+1);
+        }
+        break;
+    }
+    }
+    return QVariant();
+}

package/deps/hdt-it/sparqlmodel.hpp

@@ -0,0 +1,32 @@
+#ifndef JOINMODEL_HPP
+#define JOINMODEL_HPP
+
+#include <QAbstractTableModel>
+
+#include <SingleTriple.hpp>
+
+#include "hdtcontroller.hpp"
+
+class SparqlModel : public QAbstractTableModel {
+   Q_OBJECT
+private:
+   HDTController *hdtController;
+
+   hdt::VarBindingString *binding;
+   unsigned int currentIndex;
+   unsigned int numresults;
+   void find(unsigned int index);
+public:
+   SparqlModel(HDTController *controller);
+   virtual ~SparqlModel();
+
+   void setQuery(QString query);
+
+   int rowCount(const QModelIndex &parent = QModelIndex()) const ;
+   int columnCount(const QModelIndex &parent = QModelIndex()) const;
+   QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+   QVariant headerData(int section, Qt::Orientation orientation, int role) const;
+signals:
+};
+
+#endif // JOINMODEL_HPP

package/deps/hdt-it/stringutils.cpp

@@ -0,0 +1,48 @@
+#include <QRegExp>
+
+#include <StopWatch.hpp>
+#include "stringutils.hpp"
+
+QString stringutils::sizeHuman(unsigned long long size)
+{
+    static const char     *sizes[]   = { "EB", "PB", "TB", "GB", "MB", "KB", "B" };
+    static const quint64 exbibytes = 1024ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL;
+
+    quint64 multiplier = exbibytes;
+
+    if(size==0) {
+        return QString("0");
+    }
+
+    for (unsigned int i = 0; i < 7; i++, multiplier /= 1024)
+    {
+        if (size < multiplier) {
+            continue;
+        }
+
+        return QString("%1 %2")
+                .arg(QString::number((double)size / multiplier, 'f', 1))
+                .arg(sizes[i]);
+    }
+    return QString("0");
+}
+
+QString stringutils::toQString(const char *str)
+{
+
+    QString out = QString::fromUtf8(str);
+
+    return out;
+}
+
+QString stringutils::escapeHTML(QString in)
+{
+    return in.replace("<", "&lt;").replace(">", "&gt;");
+}
+
+void stringutils::cut(QString &in, int size)
+{
+    if(in.length()>size) {
+        in = in.left(size)+"...";
+    }
+}

package/deps/hdt-it/stringutils.hpp

@@ -0,0 +1,18 @@
+#ifndef STRINGUTILS_HPP
+#define STRINGUTILS_HPP
+
+#include <QString>
+#include <string>
+
+class stringutils
+{
+public:
+    static QString sizeHuman(unsigned long long size);
+    static QString toQString(const char *str);
+    static QString escapeHTML(QString in);
+    static void cut(QString &in, int size);
+};
+
+
+
+#endif // STRINGUTILS_HPP

package/deps/hdt-it/triplecomponentmodel.cpp

@@ -0,0 +1,146 @@
+
+#include <QFont>
+
+#include "triplecomponentmodel.hpp"
+
+#include "stringutils.hpp"
+
+TripleComponentModel::TripleComponentModel(HDTController *view, hdt::TripleComponentRole compRole) :
+    hdtController(view), tripleComponentRole(compRole)
+{
+
+}
+
+int TripleComponentModel::rowCount(const QModelIndex &parent) const
+{
+    size_t numResults = 0;
+
+    Q_UNUSED(parent);
+    if(hdtController->getHDT() != NULL) {
+        hdt::Dictionary *dict = hdtController->getHDT()->getDictionary();
+        switch(tripleComponentRole) {
+        case hdt::SUBJECT:
+            numResults = dict->getNsubjects();
+            break;
+        case hdt::PREDICATE:
+            numResults = dict->getNpredicates();
+            break;
+        case hdt::OBJECT:
+            numResults = dict->getNobjects();
+            break;
+        }
+    }
+
+    // FIXME: QTableView crashes when returning more than 100 Million rows :(
+    return (int)(numResults > 100000000 ? 100000000 : numResults);
+}
+
+int TripleComponentModel::columnCount(const QModelIndex &parent) const
+{
+    return 1;
+}
+
+QVariant TripleComponentModel::data(const QModelIndex &index, int role) const
+{
+    if(!hdtController->hasHDT()) {
+        return QVariant();
+    }
+
+    switch(role) {
+    case Qt::ToolTipRole:
+    case Qt::DisplayRole:
+    {
+        //cerr << "Data: " << index.row() << " role: " << role << " type: " << tripleComponentRole << endl;
+        hdt::Dictionary *d = hdtController->getHDT()->getDictionary();
+        try {
+        return stringutils::toQString(d->idToString(index.row()+1, tripleComponentRole).c_str());
+        } catch (char *e) {
+            cerr << "Error accessing dictionary: " << e << endl;
+        } catch (const char *e) {
+            cerr << "Error accessing dictionary: " << e << endl;
+        }
+        return QVariant();
+    }
+    case Qt::FontRole:
+    {
+        QFont font;
+        font.setPointSize(10);
+        return font;
+    }
+    case Qt::CheckStateRole:
+        if(tripleComponentRole==hdt::PREDICATE) {
+            return hdtController->getPredicateStatus()->isPredicateActive(index.row()) ? Qt::Checked : Qt::Unchecked;
+        }
+        break;
+    case Qt::DecorationRole:
+        if(tripleComponentRole==hdt::PREDICATE) {
+            HDTCachedInfo *info = hdtController->getHDTCachedInfo();
+            Color *color = info->getPredicateColor(index.row());
+            return color->asQColor();
+        }
+        break;
+    }
+    return QVariant();
+}
+
+bool TripleComponentModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+    if(hdtController->getHDT() == NULL) {
+        return false;
+    }
+
+    switch(role) {
+        case Qt::CheckStateRole:
+        if(tripleComponentRole==hdt::PREDICATE) {
+            hdtController->getPredicateStatus()->setPredicateActive(index.row(), value.toBool());
+        }
+    }
+    return true;
+}
+
+QVariant TripleComponentModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+
+    switch(role) {
+    case Qt::DisplayRole:
+    {
+        if(orientation == Qt::Horizontal) {
+            switch(tripleComponentRole) {
+            case hdt::SUBJECT:
+                return tr("Subject");
+            case hdt::PREDICATE:
+                return tr("Predicate");
+            case hdt::OBJECT:
+                return tr("Object");
+            }
+        } else {
+            return QString::number(section+1);
+        }
+        break;
+    }
+    }
+
+    return QVariant();
+}
+
+Qt::ItemFlags TripleComponentModel::flags(const QModelIndex &index) const
+{
+    Q_UNUSED(index);
+    if(tripleComponentRole == hdt::PREDICATE) {
+        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable;
+    } else {
+        return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
+    }
+}
+
+void TripleComponentModel::itemsChanged(unsigned int ini, unsigned int fin)
+{
+    QModelIndex first = createIndex(ini, 1);
+    QModelIndex last = createIndex(fin, 1);
+    emit dataChanged(first, last);
+}
+
+void TripleComponentModel::notifyLayoutChanged()
+{
+    emit layoutChanged();
+}

package/deps/hdt-it/triplecomponentmodel.hpp

@@ -0,0 +1,33 @@
+#ifndef TRIPLECOMPONENTMODEL_HPP
+#define TRIPLECOMPONENTMODEL_HPP
+
+#include <QAbstractTableModel>
+
+#include <HDTEnums.hpp>
+
+#include "hdtcontroller.hpp"
+
+class HDTController;
+
+class TripleComponentModel : public QAbstractTableModel {
+    Q_OBJECT
+private:
+    HDTController *hdtController;
+    hdt::TripleComponentRole tripleComponentRole;
+public:
+    TripleComponentModel(HDTController *view, hdt::TripleComponentRole compRole);
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const ;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    bool setData(const QModelIndex & index, const QVariant & value, int role);
+    QVariant headerData(int section, Qt::Orientation orientation, int role) const;
+    Qt::ItemFlags flags(const QModelIndex &index) const;
+
+public slots:
+    void itemsChanged(unsigned int ini, unsigned int fin);
+    void notifyLayoutChanged();
+signals:
+};
+
+#endif // TRIPLECOMPONENTMODEL_HPP