hdt 3.2.0 → 3.2.1

package/deps/hdt-it/predicatestatus.cpp

@@ -0,0 +1,97 @@
+#include "predicatestatus.hpp"
+
+PredicateStatus::PredicateStatus(HDTController *manager) :
+    controller(manager), minPredicateCount(0), maxPredicateCount(0)
+{
+}
+
+size_t PredicateStatus::getMinimumPredicateCount()
+{
+    return minPredicateCount;
+}
+
+size_t PredicateStatus::getMaximumPredicateCount()
+{
+    return maxPredicateCount;
+}
+
+bool PredicateStatus::isPredicateActive(size_t i)
+{
+    return activePredicate[i];
+}
+
+void PredicateStatus::setPredicateActive(size_t i, bool b)
+{
+    if(activePredicate[i]!=b) {
+        activePredicate[i] = b;
+        setMinimumPredicateCountInternal(0);
+        emit predicatesChanged(i,i);
+    }
+}
+
+void PredicateStatus::refreshAll()
+{
+    activePredicate.clear();
+    if(controller->hasHDT()) {
+        activePredicate.resize(controller->getHDT()->getDictionary()->getNpredicates(), true);
+	this->maxPredicateCount = controller->getHDTCachedInfo()->getMaxPredicateCount();
+        setMinimumPredicateCountInternal(0);
+    }
+}
+
+void PredicateStatus::selectAllPredicates()
+{
+//    cout << "selectAllPredicates" << endl;
+    for(size_t i=0;i<activePredicate.size();i++) {
+        activePredicate[i] = true;
+    }
+    emit predicatesChanged(0, activePredicate.size());
+    setMinimumPredicateCountInternal(0);
+}
+
+void PredicateStatus::selectNonePredicates()
+{
+//    cout << "selectNonePredicates" << endl;
+    for(size_t i=0;i<activePredicate.size();i++) {
+        activePredicate[i] = false;
+    }
+    emit predicatesChanged(0, activePredicate.size());
+    setMinimumPredicateCountInternal(0);
+}
+
+void PredicateStatus::selectPredicate(size_t pred)
+{
+    if(pred==0) {
+        selectAllPredicates();
+        return;
+    }
+
+    for(size_t i=0;i<activePredicate.size();i++) {
+        activePredicate[i] = i==(pred-1);
+    }
+    emit predicatesChanged(0, activePredicate.size());
+    setMinimumPredicateCountInternal(0);
+    emit predicateSelected(pred-1);
+}
+
+// Private, just updates the value.
+void PredicateStatus::setMinimumPredicateCountInternal(int count)
+{
+    if(count!=minPredicateCount) {
+        minPredicateCount = count;
+        emit minimumPredicateCountChanged(count);
+    }
+}
+
+// Public, update all activePredicate, values.
+void PredicateStatus::setMinimumPredicateCount(int count)
+{
+    if(count!=minPredicateCount) {
+        minPredicateCount = count;
+        for(size_t i=0;i<activePredicate.size();i++) {
+        activePredicate[i] = controller->getHDTCachedInfo()->getPredicateUsages(i)>=(size_t)count;
+        }
+        emit predicatesChanged(0, activePredicate.size());
+        emit minimumPredicateCountChanged(count);
+    }
+}

package/deps/hdt-it/predicatestatus.hpp

@@ -0,0 +1,39 @@
+#ifndef PREDICATESTATUS_HPP
+#define PREDICATESTATUS_HPP
+
+#include <QObject>
+#include "hdtcontroller.hpp"
+
+class PredicateStatus : public QObject
+{
+    Q_OBJECT
+private:
+    vector<bool> activePredicate;
+    size_t minPredicateCount;
+    size_t maxPredicateCount;
+    HDTController *controller;
+
+    void setMinimumPredicateCountInternal(int count);
+public:
+    explicit PredicateStatus(HDTController *controller);
+
+    size_t getMinimumPredicateCount();
+    size_t getMaximumPredicateCount();
+
+    bool isPredicateActive(size_t i);
+    void setPredicateActive(size_t i, bool b);
+
+signals:
+    void predicatesChanged(size_t min, size_t max);
+    void minimumPredicateCountChanged(size_t newval);
+    void predicateSelected(size_t npred);
+
+public slots:
+    void refreshAll();
+    void selectPredicate(size_t pred);
+    void selectAllPredicates();
+    void selectNonePredicates();
+    void setMinimumPredicateCount(int count);
+};
+
+#endif // PREDICATESTATUS_HPP

package/deps/hdt-it/qclearlineedit.cpp

@@ -0,0 +1,48 @@
+#include "qclearlineedit.hpp"
+#include <QToolButton>
+#include <QStyle>
+
+QClearLineEdit::QClearLineEdit(QWidget *parent)
+    : QLineEdit(parent)
+{
+    clearButton = new QToolButton(this);
+    QPixmap pixmap(":/images/editreset.png");
+    clearButton->setIcon(QIcon(pixmap));
+    clearButton->setIconSize(pixmap.size());
+    clearButton->setCursor(Qt::ArrowCursor);
+    clearButton->setStyleSheet("QToolButton { border: none; padding: 0px; }");
+    clearButton->hide();
+    connect(clearButton, SIGNAL(clicked()), this, SLOT(clear()));
+    connect(this, SIGNAL(textChanged(const QString&)), this, SLOT(updateCloseButton(const QString&)));
+    int frameWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
+    setStyleSheet(QString("QLineEdit { padding-right: %1px; } ").arg(clearButton->sizeHint().width() + frameWidth + 1));
+    QSize msz = minimumSizeHint();
+    setMinimumSize(qMax(msz.width(), clearButton->sizeHint().height() + frameWidth * 2 + 2),
+                   qMax(msz.height(), clearButton->sizeHint().height() + frameWidth * 2 + 2));
+
+    suggestions = new DictionarySuggestions(this);
+}
+
+QClearLineEdit::~QClearLineEdit()
+{
+    delete suggestions;
+    delete clearButton;
+}
+
+void QClearLineEdit::resizeEvent(QResizeEvent *)
+{
+    QSize sz = clearButton->sizeHint();
+    int frameWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
+    clearButton->move(rect().right() - frameWidth - sz.width(),
+                      (rect().bottom() + 1 - sz.height())/2);
+}
+
+void QClearLineEdit::updateCloseButton(const QString& text)
+{
+    clearButton->setVisible(!text.isEmpty());
+}
+
+DictionarySuggestions * QClearLineEdit::getSuggestions()
+{
+    return suggestions;
+}

package/deps/hdt-it/qclearlineedit.hpp

@@ -0,0 +1,30 @@
+#ifndef QCLEARLINEEDIT_HPP
+#define QCLEARLINEEDIT_HPP
+
+#include <QLineEdit>
+
+#include "dictionarysuggestions.hpp"
+
+class QToolButton;
+
+class QClearLineEdit: public QLineEdit
+{
+    Q_OBJECT
+
+public:
+    QClearLineEdit(QWidget *parent = 0);
+    ~QClearLineEdit();
+    DictionarySuggestions *getSuggestions();
+
+protected:
+    void resizeEvent(QResizeEvent *);
+
+private slots:
+    void updateCloseButton(const QString &text);
+
+private:
+    QToolButton *clearButton;
+    DictionarySuggestions *suggestions;
+};
+
+#endif // QCLEARLINEEDIT_HPP

package/deps/hdt-it/regexmodel.cpp

@@ -0,0 +1,132 @@
+#include "stringutils.hpp"
+#include "regexmodel.hpp"
+
+#include <QFont>
+#include <QMessageBox>
+
+class QFont;
+
+#include "../hdt-lib/src/dictionary/LiteralDictionary.hpp"
+
+RegexModel::RegexModel(HDTController *manager) : hdtController(manager), numResults(0), results(NULL)
+{
+}
+
+RegexModel::~RegexModel()
+{
+    if(results!=NULL) {
+        free(results);
+    }
+}
+
+void RegexModel::setQuery(QString query)
+{
+    if(hdtController->hasHDT()) {
+        hdt::LiteralDictionary *dict = dynamic_cast<hdt::LiteralDictionary *>(hdtController->getHDT()->getDictionary());
+        if(dict==NULL) {
+            QMessageBox::warning(NULL, tr("ERROR"), tr("This HDT does not support substring search"));
+            return;
+        }
+        if(query.length()==0) {
+            numResults = 0;
+        } else {
+            QByteArray arr = query.toUtf8();
+            numResults = dict->substringToId((uchar *)arr.data(), arr.size(), &results);
+        }
+        emit layoutChanged();
+    }
+}
+
+int RegexModel::rowCount(const QModelIndex &parent) const
+{
+    return (int)numResults;
+}
+
+int RegexModel::columnCount(const QModelIndex &parent) const
+{
+    return 2;
+}
+
+QVariant RegexModel::data(const QModelIndex &index, int role) const
+{
+    if(results==NULL) {
+        return QVariant();
+    }
+
+    switch(role) {
+    case Qt::ToolTipRole:
+    case Qt::DisplayRole:
+    {
+        hdt::Dictionary *d = hdtController->getHDT()->getDictionary();
+
+        try {
+            switch(index.column()) {
+            case 0:
+            {
+                hdt::Triples *t = hdtController->getHDT()->getTriples();
+
+                hdt::TripleID tripleObject(0, 0, results[index.row()]);
+                hdt::IteratorTripleID *it = t->search(tripleObject);
+
+                int nResults = it->estimatedNumResults();
+                delete it;
+
+                return nResults;
+            }
+            case 1: {
+                return stringutils::toQString(d->idToString(results[index.row()], hdt::OBJECT).c_str());
+            }
+            }
+
+        } catch (char *e) {
+            cerr << "Error accesing dictionary: " << e << endl;
+        } catch (const char *e) {
+            cerr << "Error accesing dictionary: " << e << endl;
+        }
+        return QVariant();
+
+        break;
+    }
+    case Qt::FontRole:
+    {
+        static QFont font;
+        font.setPointSize(10);
+        return font;
+    }
+
+    }
+    return QVariant();
+}
+
+QVariant RegexModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    switch(role) {
+    case Qt::DisplayRole:
+    {
+        if(orientation == Qt::Horizontal) {
+            switch(section) {
+            case 0:
+                return tr("Triples  ");
+            case 1:
+                return tr("Object Literal");
+            }
+        } else {
+            return QString::number(results[section]);
+        }
+        break;
+    }
+    }
+
+    return QVariant();
+}
+
+void RegexModel::updateDatasetChanged()
+{
+    if(results==NULL) {
+        free(results);
+    }
+    numResults = 0;
+    results=NULL;
+
+    emit layoutChanged();
+}

package/deps/hdt-it/regexmodel.hpp

@@ -0,0 +1,37 @@
+#ifndef REGEXMODEL_HPP
+#define REGEXMODEL_HPP
+
+#include <QAbstractTableModel>
+
+#include "hdtcontroller.hpp"
+
+class HDTController;
+
+class RegexModel : public QAbstractTableModel
+{
+    Q_OBJECT
+
+private:
+    HDTController *hdtController;
+    uint32_t numResults;
+    uint32_t *results;
+
+public:
+    explicit RegexModel(HDTController *manager);
+    ~RegexModel();
+
+    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;
+
+    void updateDatasetChanged();
+signals:
+    
+public slots:
+    
+};
+
+#endif // REGEXMODEL_HPP

package/deps/hdt-it/resultcounter.cpp

@@ -0,0 +1,47 @@
+#include "resultcounter.hpp"
+#include <QtConcurrent/QtConcurrent>
+
+
+ResultCounter::ResultCounter(QObject *parent, HDTController *controller) :
+    QObject(parent),
+    hdtController(controller),
+    iterator(NULL)
+{
+}
+
+void ResultCounter::startCounting()
+{
+    if(!hdtController->hasHDT()){
+        return;
+    }
+    iterator = hdtController->getHDT()->getTriples()->search(hdtController->getSearchPatternID());
+    shouldCancel = false;
+    QtConcurrent::run(this, &ResultCounter::run);
+}
+
+void ResultCounter::cancel()
+{
+    shouldCancel = true;
+}
+
+void ResultCounter::run()
+{
+    if(iterator==NULL) {
+        return;
+    }
+    StopWatch cl;
+    unsigned int numResults = 0;
+    while(!shouldCancel && iterator->hasNext()) {
+        iterator->next();
+        numResults++;
+
+        cl.stop();
+        if(cl.getReal()>10000) {
+            cl.reset();
+            emit numResultsChanged(numResults);
+        }
+    }
+    delete iterator;
+    iterator = NULL;
+    emit finished();
+}

package/deps/hdt-it/resultcounter.hpp

@@ -0,0 +1,30 @@
+#ifndef RESULTCOUNTER_HPP
+#define RESULTCOUNTER_HPP
+
+#include <QObject>
+
+#include <hdtcontroller.hpp>
+
+class ResultCounter : public QObject
+{
+    Q_OBJECT
+private:
+    HDTController *hdtController;
+    hdt::IteratorTripleID *iterator;
+    bool shouldCancel;
+public:
+    explicit ResultCounter(QObject *parent, HDTController *hdtController);
+
+    void run();
+signals:
+    void numResultsChanged(int numResults);
+    void messageChanged(QString message);
+    void finished();
+private slots:
+    void startCounting();
+    void cancel();
+public slots:
+
+};
+
+#endif // RESULTCOUNTER_HPP

package/deps/hdt-it/searchresultsmodel.cpp

@@ -0,0 +1,179 @@
+#include "stringutils.hpp"
+#include "searchresultsmodel.hpp"
+#include <QFont>
+
+SearchResultsModel::SearchResultsModel(HDTController *view) : hdtController(view), triples(NULL)
+{
+    this->updateResultListChanged();
+}
+
+SearchResultsModel::~SearchResultsModel()
+{
+    if(triples!=NULL) {
+        delete triples;
+        triples = NULL;
+    }
+}
+
+int SearchResultsModel::rowCount(const QModelIndex &parent) const
+{
+    // FIXME: QTableView crashes when returning more than 100 Million rows :(
+    return numResults > 100000000 ? 100000000 : numResults;
+}
+
+int SearchResultsModel::columnCount(const QModelIndex &parent) const
+{
+    return 3;
+}
+
+QVariant SearchResultsModel::data(const QModelIndex &index, int role) const
+{
+    if(triples == NULL) {
+        return QVariant();
+    }
+
+    switch(role) {
+    case Qt::ToolTipRole:
+    case Qt::DisplayRole:
+    {
+	// cerr << "SearchResultsModel.data " << index.row() << "," << index.column() << endl;
+        // 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.
+        SearchResultsModel *noConstThis = const_cast<SearchResultsModel *>(this);
+        noConstThis->findTriple(index.row());
+
+        hdt::Dictionary *d = hdtController->getHDT()->getDictionary();
+
+        try {
+            switch(index.column()) {
+            case 0:
+        return stringutils::toQString(d->idToString(currentTriple->getSubject(), hdt::SUBJECT).c_str());
+            case 1:
+        return stringutils::toQString(d->idToString(currentTriple->getPredicate(), hdt::PREDICATE).c_str());
+            case 2:
+        return stringutils::toQString(d->idToString(currentTriple->getObject(), hdt::OBJECT).c_str());
+            }
+        } catch (char *e) {
+            cerr << "Error accesing dictionary: " << e << endl;
+        } catch (const char *e) {
+            cerr << "Error accesing dictionary: " << e << endl;
+        }
+        return QVariant();
+
+        break;
+    }
+    case Qt::FontRole:
+    {
+        static QFont font;
+        font.setPointSize(10);
+        return font;
+    }
+
+    }
+    return QVariant();
+}
+
+
+QVariant SearchResultsModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+
+    switch(role) {
+    case Qt::DisplayRole:
+    {
+        if(orientation == Qt::Horizontal) {
+            switch(section) {
+            case 0:
+                return tr("Subject");
+            case 1:
+                return tr("Predicate");
+            case 2:
+                return tr("Object");
+            }
+        } else {
+            return QString::number(section+1);
+        }
+        break;
+    }
+    }
+
+    return QVariant();
+}
+
+void SearchResultsModel::updateResultListChanged() {
+    if(triples!=NULL) {
+        delete triples;
+        triples = NULL;
+    }
+
+    if(hdtController->hasHDT()) {
+        triples = hdtController->getHDT()->getTriples()->search(hdtController->getSearchPatternID());
+        if(triples->hasNext()) {
+            currentTriple = triples->next();
+        }
+    } else {
+        triples = NULL;
+        currentTriple = NULL;
+        numResults=0;
+    }
+    currentIndex = 0;
+    goingUp = true;
+    numResults = hdtController->getNumResults();
+
+    emit layoutChanged();
+}
+
+void SearchResultsModel::updateNumResultsChanged()
+{
+    unsigned int old = numResults;
+    numResults = hdtController->getNumResults();
+
+    if(old!=numResults) {
+#if 0
+    beginInsertRows(QModelIndex(), old+1, numResults);
+    endInsertRows();
+    //emit dataChanged(createIndex(old+1,0), createIndex(numResults,2));
+#else
+    emit layoutChanged();
+#endif
+    }
+}
+
+
+void SearchResultsModel::findTriple(unsigned int index)
+{
+    if(triples == NULL) {
+        return;
+    }
+
+    if(triples->canGoTo() && abs((long int)currentIndex-(long int)index)>5) {
+	triples->goTo(index);
+	goingUp = true;
+        currentTriple = triples->next();
+        currentIndex = index;
+	//cerr << "Jump: " << currentIndex << " => " << *currentTriple << endl;
+        return;
+    }
+
+    while(currentIndex > index && triples->hasPrevious()) {
+        if(goingUp) {
+            // On direction changes, we need to move one extra position.
+            goingUp = false;
+            currentIndex++;
+        }
+        currentTriple = triples->previous();
+        currentIndex--;
+    }
+
+    while(currentIndex < index && triples->hasNext()) {
+        if(!goingUp){
+            // On direction changes, we need to move one extra position.
+            goingUp = true;
+            currentIndex--;
+        }
+        currentTriple = triples->next();
+        currentIndex++;
+    }
+
+    //cerr << "Access " << currentIndex << " => " << *currentTriple << endl;
+}

package/deps/hdt-it/searchresultsmodel.hpp

@@ -0,0 +1,39 @@
+#ifndef SEARCHRESULTSMODEL_HPP
+#define SEARCHRESULTSMODEL_HPP
+
+#include <QAbstractTableModel>
+
+#include <SingleTriple.hpp>
+
+#include "hdtcontroller.hpp"
+
+class HDTController;
+
+class SearchResultsModel : public QAbstractTableModel {
+    Q_OBJECT
+private:
+    HDTController *hdtController;
+    hdt::IteratorTripleID *triples;
+    hdt::TripleID *currentTriple;
+    unsigned int currentIndex;
+    unsigned int numResults;
+    bool goingUp;
+
+    void findTriple(unsigned int index);
+
+public:
+    SearchResultsModel(HDTController *view);
+    ~SearchResultsModel();
+
+    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;
+
+    void updateResultListChanged();
+    void updateNumResultsChanged();
+signals:
+};
+
+
+#endif // SEARCHRESULTSMODEL_HPP

package/deps/hdt-it/sparqlform.cpp

@@ -0,0 +1,27 @@
+#include "sparqlform.hpp"
+#include "ui_sparqlform.h"
+
+#include "sparqlmodel.hpp"
+#include "hdtit.hpp"
+
+SparqlForm::SparqlForm(QWidget *parent) :
+    QMainWindow(parent),
+    ui(new Ui::SparqlForm)
+{
+    ui->setupUi(this);
+
+    HDTit *hdtit = reinterpret_cast<HDTit *>(parent);
+    sparqlModel = new SparqlModel(hdtit->getManager());
+    ui->sparqlResultTable->setModel(sparqlModel);
+}
+
+SparqlForm::~SparqlForm()
+{
+    delete ui;
+}
+
+void SparqlForm::on_pushButton_clicked()
+{
+    sparqlModel->setQuery(ui->sparqlTextEdit->toPlainText());
+    ui->sparqlResultTable->scrollToTop();
+}