hdt 3.2.0 → 3.2.2

package/deps/hdt-it/hdtoperation.cpp

@@ -0,0 +1,284 @@
+#include <QApplication>
+#include <QtConcurrent/QtConcurrent>
+#include <QMessageBox>
+#include <QtGui>
+#include <QPushButton>
+
+#include <HDTManager.hpp>
+
+#include "hdtoperation.hpp"
+
+#define USE_DIALOG
+//#define OPERATION_CANCELABLE
+
+#ifdef WIN32
+#include <windows.h>
+#define sleep(a) Sleep((a)*1000)
+#else
+#include <iostream>
+#include <unistd.h>
+#define sleep(a) usleep(a)
+#endif
+
+
+HDTOperationDialog::HDTOperationDialog()
+{
+}
+
+void HDTOperationDialog::closeEvent(QCloseEvent *event)
+{
+#ifdef OPERATION_CANCELABLE
+    event->accept();
+#else
+    event->ignore();
+#endif
+}
+
+HDTOperation::HDTOperation() : hdt(NULL), hdtInfo(NULL), errorMessage(NULL)
+{
+}
+
+HDTOperation::HDTOperation(QString fileName) : fileName(fileName), hdt(NULL), hdtInfo(NULL), errorMessage(NULL)
+{
+}
+
+HDTOperation::HDTOperation(hdt::HDT *hdt) : hdt(hdt), hdtInfo(NULL), errorMessage(NULL)
+{
+}
+
+HDTOperation::HDTOperation(hdt::HDT *hdt, HDTCachedInfo *hdtInfo) : hdt(hdt), hdtInfo(hdtInfo), errorMessage(NULL)
+{
+}
+
+void HDTOperation::execute() {
+    errorMessage=NULL;
+    try {
+        switch(op) {
+        case HDT_READ: {
+            hdt::IntermediateListener iListener(dynamic_cast<ProgressListener *>(this));
+            iListener.setRange(0,70);
+
+            // TODO: Decompress GZIP here using progress bar.
+            // TODO: Detect whether .hdtcache and .hdt.index exist to be more accurate with the progress
+#if 1
+            hdt = hdt::HDTManager::mapIndexedHDT(fileName.toLatin1(), &iListener);
+#else            
+            hdt = hdt::HDTManager::loadIndexedHDT(fileName.toLatin1(), &iListener);
+#endif
+            iListener.setRange(70, 100);
+            hdtInfo = new HDTCachedInfo(hdt);
+            if(fileName.endsWith('.gz')){
+                fileName.left(fileName.length()-3);
+            }
+            QString infoFile = fileName + ".hdtcache";
+            hdtInfo->load(infoFile, &iListener);
+
+            break;
+        }
+        case RDF_READ:{
+            hdt::IntermediateListener iListener(dynamic_cast<ProgressListener *>(this));
+
+            iListener.setRange(0,80);
+            hdt = hdt::HDTManager::generateHDT(fileName.toLatin1(), baseUri.c_str(), notation, spec, &iListener);
+
+            iListener.setRange(80, 90);
+            hdt = hdt::HDTManager::indexedHDT(hdt);
+
+            iListener.setRange(90, 100);
+            hdtInfo = new HDTCachedInfo(hdt);
+            hdtInfo->generateGeneralInfo(&iListener);
+            hdtInfo->generateMatrix(&iListener);
+
+            break;
+            }
+        case HDT_WRITE:
+            hdt->saveToHDT(fileName.toLatin1(), dynamic_cast<ProgressListener *>(this));
+            break;
+        case RDF_WRITE:{
+            hdt::RDFSerializer *serializer = hdt::RDFSerializer::getSerializer(fileName.toLatin1(), notation);
+            hdt->saveToRDF(*serializer, dynamic_cast<ProgressListener *>(this));
+            delete serializer;
+            break;
+            }
+        case RESULT_EXPORT: {
+            hdt::RDFSerializer *serializer = hdt::RDFSerializer::getSerializer(fileName.toLatin1(), notation);
+            serializer->serialize(iterator, dynamic_cast<ProgressListener *>(this), numResults );
+            delete serializer;
+            delete iterator;
+            break;
+        }
+        }
+        emit processFinished(0);
+    } catch (char* err) {
+        cerr << "Error caught: " << err << endl;
+        errorMessage = err;
+        emit processFinished(1);
+    } catch (const char* err) {
+        cerr << "Error caught: " << err << endl;
+        errorMessage = (char *)err;
+        emit processFinished(1);
+    }
+   sleep(1);	// To ensure that dialog receives the signal and closes.
+}
+
+
+void HDTOperation::notifyProgress(float level, const char *section) {
+#ifdef OPERATION_CANCELABLE
+    if(isCancelled) {
+        cerr << "Throwing exception to cancel" << endl;
+        throw (char *)"Cancelled by user";
+    }
+#endif
+#ifdef USE_DIALOG
+    emit progressChanged((int)level);
+    emit messageChanged(QString(section));
+#endif
+}
+
+void HDTOperation::notifyProgress(float task, float level, const char *section)
+{
+#ifdef OPERATION_CANCELABLE
+    if(isCancelled) {
+        cerr << "Throwing exception to cancel" << endl;
+        throw (char *)"Cancelled by user";
+    }
+#endif
+    int levelInt = (int) level;
+    if(levelInt<0) {
+        levelInt=0;
+    }
+    if(levelInt>=100) {
+        levelInt=99;
+    }
+
+    emit progressChanged((int)level);
+    emit messageChanged(QString(section));
+}
+
+void HDTOperation::saveToRDF(QString &fileName, hdt::RDFNotation notation)
+{
+    this->op = RDF_WRITE;
+    this->fileName = fileName;
+    this->notation = notation;
+}
+
+void HDTOperation::saveToHDT(QString &fileName)
+{
+    this->op = HDT_WRITE;
+    this->fileName = fileName;
+}
+
+void HDTOperation::loadFromRDF(hdt::HDTSpecification &spec, QString &fileName, hdt::RDFNotation notation, const string &baseUri)
+{
+    this->op = RDF_READ;
+    this->spec = spec;
+    this->fileName = fileName;
+    this->notation = notation;
+    this->baseUri = baseUri;
+}
+
+void HDTOperation::loadFromHDT(QString &fileName)
+{
+    this->op = HDT_READ;
+    this->fileName = fileName;
+}
+
+void HDTOperation::exportResults(QString &fileName, hdt::IteratorTripleString *iterator, unsigned int numResults, hdt::RDFNotation notation)
+{
+    this->op = RESULT_EXPORT;
+    this->fileName = fileName;
+    this->iterator = iterator;
+    this->numResults = numResults;
+    this->notation = notation;
+}
+
+hdt::HDT *HDTOperation::getHDT()
+{
+    return hdt;
+}
+
+HDTCachedInfo *HDTOperation::getHDTInfo()
+{
+    return hdtInfo;
+}
+
+
+int HDTOperation::exec()
+{
+
+#ifdef USE_DIALOG
+    dialog.setRange(0,100);
+    dialog.setAutoClose(false);
+    dialog.setFixedSize(400,130);
+
+    switch(op) {
+    case HDT_READ:
+        dialog.setWindowTitle(tr("Loading HDT File"));
+        break;
+    case RDF_READ:
+        dialog.setWindowTitle(tr("Importing RDF File to HDT"));
+        break;
+    case HDT_WRITE:
+        dialog.setWindowTitle(tr("Saving HDT File"));
+        break;
+    case RDF_WRITE:
+        dialog.setWindowTitle(tr("Exporting HDT File to RDF"));
+        break;
+    case RESULT_EXPORT:
+        dialog.setWindowTitle(tr("Exporting results to RDF"));
+        break;
+    }
+
+#ifndef OPERATION_CANCELABLE
+    QPushButton btn;
+    btn.setEnabled(false);
+    btn.setText(tr("Cancel"));
+    dialog.setCancelButton(&btn);
+#endif
+
+    QFutureWatcher<void> watcher;
+
+    connect(&watcher, SIGNAL(finished()), this, SLOT(finished()), Qt::QueuedConnection);
+
+    connect(this, SIGNAL(progressChanged(int)), &dialog, SLOT(setValue(int)), Qt::QueuedConnection);
+    connect(this, SIGNAL(messageChanged(QString)), &dialog, SLOT(setLabelText(QString)), Qt::QueuedConnection);
+    connect(this, SIGNAL(processFinished(int)), &dialog, SLOT(done(int)), Qt::QueuedConnection);
+
+#ifdef OPERATION_CANCELABLE
+    connect(&dialog, SIGNAL(canceled()), this, SLOT(cancel()));
+#endif
+
+    isCancelled=false;
+    QFuture<void> f = QtConcurrent::run(this, &HDTOperation::execute);
+    watcher.setFuture(f);
+
+    int result = dialog.exec();
+
+    if(errorMessage) {
+        result = 1;
+        QMessageBox::critical(NULL, "ERROR", QString(errorMessage) );
+    }
+
+    QApplication::alert(QApplication::activeWindow());
+    return result;
+#else
+    this->execute();
+    if(errorMessage!=NULL)  {
+        return 1;
+    } else {
+        return 0;
+    }
+#endif
+}
+
+void HDTOperation::cancel()
+{
+    //cerr << "Operation cancelled" << endl;
+    isCancelled = true;
+}
+
+void HDTOperation::finished()
+{
+    cerr << "Finished! :)" << endl;
+    emit processFinished(0);
+}

package/deps/hdt-it/hdtoperation.hpp

@@ -0,0 +1,71 @@
+#ifndef HDTOPERATION_HPP
+#define HDTOPERATION_HPP
+
+#include <QProgressDialog>
+#include <QMutex>
+#include <QMutexLocker>
+#include <HDTListener.hpp>
+#include <HDT.hpp>
+#include <HDTSpecification.hpp>
+#include <SingleTriple.hpp>
+
+#include "hdtcachedinfo.hpp"
+
+
+class HDTOperationDialog : public QProgressDialog {
+    Q_OBJECT
+public:
+    HDTOperationDialog();
+    void closeEvent(QCloseEvent *event);
+};
+
+class HDTOperation : public QObject, public hdt::ProgressListener {
+    Q_OBJECT
+
+private:
+    hdt::HDTSpecification spec;
+    hdt::HDT *hdt;
+    HDTCachedInfo *hdtInfo;
+    hdt::IteratorTripleString *iterator;
+    unsigned int numResults;
+    QString fileName;
+    hdt::RDFNotation notation;
+    string baseUri;
+    char *errorMessage;
+    bool isCancelled;
+    HDTOperationDialog dialog;
+
+    enum Operation {
+        HDT_READ,
+        RDF_READ,
+        HDT_WRITE,
+        RDF_WRITE,
+        RESULT_EXPORT
+    } op;
+
+public:
+    HDTOperation();
+    HDTOperation(QString fileName);
+    HDTOperation(hdt::HDT *hdt);
+    HDTOperation(hdt::HDT *hdt, HDTCachedInfo *hdtInfo);
+    void saveToRDF(QString &fileName, hdt::RDFNotation notation);
+    void saveToHDT(QString &fileName);
+    void loadFromRDF(hdt::HDTSpecification &spec, QString &fileName, hdt::RDFNotation notation, const string &baseUri);
+    void loadFromHDT(QString &fileName);
+    void exportResults(QString &fileName, hdt::IteratorTripleString *iterator, unsigned int numResults, hdt::RDFNotation notation);
+    hdt::HDT *getHDT();
+    HDTCachedInfo *getHDTInfo();
+    void execute();
+    int exec();
+    void notifyProgress(float level, const char *section);
+    void notifyProgress(float task, float level, const char *section);
+signals:
+    void progressChanged(int progress);
+    void messageChanged(QString message);
+    void processFinished(int status);
+private slots:
+    void cancel();
+    void finished();
+};
+
+#endif // HDTOPERATION_HPP

package/deps/hdt-it/hdtresources.qrc

@@ -0,0 +1,7 @@
+<RCC>
+    <qresource prefix="/images">
+        <file>editreset.png</file>
+        <file>logo-hdt.png</file>
+        <file>loading.gif</file>
+    </qresource>
+</RCC>

package/deps/hdt-it/hdtspecform.cpp

@@ -0,0 +1,180 @@
+#include <QFileDialog>
+#include <QMessageBox>
+
+#include "hdtspecform.hpp"
+#include "ui_hdtspecform.h"
+
+#include <QtGui>
+
+HDTSpecForm::HDTSpecForm(QWidget *parent) :
+    QDialog(parent),
+    ui(new Ui::HDTSpecForm)
+{
+    ui->setupUi(this);
+}
+
+HDTSpecForm::~HDTSpecForm()
+{
+    delete ui;
+}
+
+void HDTSpecForm::on_triplesTypeCombo_currentIndexChanged(int index)
+{
+    switch(index) {
+    case 0:
+        // BitmapTriples
+        ui->streamXcombo->setEnabled(false);
+        ui->streamYcombo->setEnabled(true);
+        ui->streamZcombo->setEnabled(true);
+        break;
+    case 1:
+        // TriplesList
+        ui->streamXcombo->setEnabled(false);
+        ui->streamYcombo->setEnabled(false);
+        ui->streamZcombo->setEnabled(false);
+        break;
+    case 2:
+        // PlainTriples
+        ui->streamXcombo->setEnabled(true);
+        ui->streamYcombo->setEnabled(true);
+        ui->streamZcombo->setEnabled(true);
+        break;
+    case 4:
+        // FoQTriples
+        ui->streamXcombo->setEnabled(false);
+        ui->streamYcombo->setEnabled(false);
+        ui->streamZcombo->setEnabled(false);
+        break;
+    }
+    ui->triplesOrderCombo->setEnabled(index!=4);
+}
+
+void HDTSpecForm::on_inputFileButton_clicked()
+{
+    static QString lastDir = QDir::currentPath();
+    QString file = QFileDialog::getOpenFileName(this,tr("Select Input RDF File"), lastDir, tr("RDF Files(*)"), 0, 0 );
+    if(file!="") {
+        lastDir=file;
+        if(getBaseUri()=="") {
+            ui->baseUriText->setText("<file://"+file+">");
+        }
+
+        QString noCompression=file;
+
+        if(file.endsWith(".gz", Qt::CaseInsensitive)) {
+            noCompression = file.left(file.length()-3);
+        }
+
+        if(noCompression.endsWith(".ttl", Qt::CaseInsensitive)) {
+            ui->rdfInputCombo->setCurrentIndex(2);
+        } else if(noCompression.endsWith(".nt", Qt::CaseInsensitive)) {
+            ui->rdfInputCombo->setCurrentIndex(0);
+        } else if(noCompression.endsWith(".n3", Qt::CaseInsensitive)) {
+            ui->rdfInputCombo->setCurrentIndex(1);
+        } else if(noCompression.endsWith(".rdf", Qt::CaseInsensitive) || noCompression.endsWith(".xml", Qt::CaseInsensitive)) {
+            ui->rdfInputCombo->setCurrentIndex(3);
+        }
+    }
+    ui->rdfInputFile->setText(file);
+}
+
+QString HDTSpecForm::getFileName()
+{
+    return ui->rdfInputFile->text();
+}
+
+QString HDTSpecForm::getBaseUri()
+{
+    return ui->baseUriText->text();
+}
+
+std::string HDTSpecForm::getStreamType(int index) {
+    switch(index) {
+    case 0:
+        // LogStream
+        return hdt::HDTVocabulary::SEQ_TYPE_LOG;
+    case 1:
+        // IntegerStream
+        return hdt::HDTVocabulary::SEQ_TYPE_INT32;
+    case 2:
+        // HuffmanStream
+        return hdt::HDTVocabulary::SEQ_TYPE_HUFFMAN;
+    case 3:
+        // WaveletStream
+        return hdt::HDTVocabulary::SEQ_TYPE_WAVELET;
+    }
+    return "";
+}
+
+void HDTSpecForm::fillHDTSpecification(hdt::HDTSpecification &hdt)
+{
+    hdt.set("triplesOrder", hdt::getOrderStr((hdt::TripleComponentOrder)(ui->triplesOrderCombo->currentIndex()+1)));
+
+    hdt.set("header.type", hdt::HDTVocabulary::DICTIONARY_TYPE_PLAIN);
+
+    switch(ui->dictionaryTypeCombo->currentIndex()) {
+    case 0:
+        // FourSectionDictionary
+        hdt.set("dictionary.type", hdt::HDTVocabulary::DICTIONARY_TYPE_FOUR);
+        break;
+    case 1:
+        // PlainDictionary
+        hdt.set("dictionary.type", hdt::HDTVocabulary::DICTIONARY_TYPE_PLAIN);
+        break;
+    case 2:
+        // LiteralDictionary
+        hdt.set("dictionary.type", hdt::HDTVocabulary::DICTIONARY_TYPE_LITERAL);
+        break;
+    }
+
+    switch(ui->triplesTypeCombo->currentIndex()) {
+    case 0:
+        // BitmapTriples
+        hdt.set("triples.type", hdt::HDTVocabulary::TRIPLES_TYPE_BITMAP);
+        break;
+    case 1:
+        // TriplesList
+        hdt.set("triples.type", hdt::HDTVocabulary::TRIPLES_TYPE_TRIPLESLIST);
+        break;
+    case 2:
+        // PlainTriples
+        hdt.set("triples.type", hdt::HDTVocabulary::TRIPLES_TYPE_PLAIN);
+        break;
+    }
+
+    if(ui->streamXcombo->isEnabled()) {
+        hdt.set("stream.x", getStreamType(ui->streamXcombo->currentIndex()));
+    }
+
+    if(ui->streamYcombo->isEnabled()) {
+        hdt.set("stream.y", getStreamType(ui->streamYcombo->currentIndex()));
+    }
+
+    if(ui->streamZcombo->isEnabled()) {
+        hdt.set("stream.z", getStreamType(ui->streamZcombo->currentIndex()));
+    }
+}
+
+hdt::RDFNotation HDTSpecForm::getNotation()
+{
+    switch(ui->rdfInputCombo->currentIndex()) {
+    case 0:
+        return hdt::NTRIPLES;
+    case 1:
+        return hdt::N3;
+    case 2:
+        return hdt::TURTLE;
+    case 3:
+        return hdt::XML;
+    }
+    return hdt::NTRIPLES;
+}
+
+void HDTSpecForm::accept()
+{
+    if(getFileName()=="") {
+        QMessageBox::warning(NULL, tr("Select a file name."), tr("Please insert a file name or URI."));
+    } else {
+        done(1);
+    }
+}

package/deps/hdt-it/hdtspecform.hpp

@@ -0,0 +1,38 @@
+#ifndef HDTSPECFORM_HPP
+#define HDTSPECFORM_HPP
+
+#include <QDialog>
+
+#include <HDTSpecification.hpp>
+#include <HDTVocabulary.hpp>
+#include <HDTEnums.hpp>
+
+namespace Ui {
+    class HDTSpecForm;
+}
+
+class HDTSpecForm : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit HDTSpecForm(QWidget *parent = 0);
+    ~HDTSpecForm();
+
+public:
+    QString getFileName();
+    QString getBaseUri();
+    void fillHDTSpecification(hdt::HDTSpecification &spec);
+    hdt::RDFNotation getNotation();
+
+private:
+    Ui::HDTSpecForm *ui;
+    std::string getStreamType(int index);
+
+private slots:
+    void on_triplesTypeCombo_currentIndexChanged(int index);
+    void on_inputFileButton_clicked();
+    void accept();
+};
+
+#endif // HDTSPECFORM_HPP