OMRAS2 Classical Browser

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

#include "Objects.h"

#include "EditDistance.h"

#include "TypeRegistrar.h"

#include <dataquay/BasicStore.h>

#include <dataquay/objectmapper/ObjectLoader.h>

#include <dataquay/objectmapper/TypeMapping.h>

#include <dataquay/Debug.h>

#include <QTemporaryFile>

#include <QMultiMap>

#include <iostream>

#ifdef TURBOT_PROFILER

#include <base/Profiler.h>

#endif

using namespace Dataquay;

using namespace ClassicalData;

bool

load(BasicStore *store, QString resourceName)

{

    QTemporaryFile tf;

    if (!tf.open()) return false;

    tf.setAutoRemove(true);

    QFile f(resourceName);

    if (!f.open(QFile::ReadOnly)) return false;

    QByteArray buffer;

    int bufsiz = 10240;

    while (!f.atEnd()) {

        buffer = f.read(bufsiz);

        tf.write(buffer);

    }

    tf.close();

    std::cerr << "unpacked, importing..." << std::endl;

    store->import("file://" + tf.fileName(),

                  BasicStore::ImportPermitDuplicates, // fastest mode

                  "ntriples");

    return true;

}

int main(int argc, char **argv)

{

    BasicStore *store = new BasicStore();

    store->setBaseUri(Uri("http://dbtune.org/classical/resource/"));

    ObjectLoader *loader = new ObjectLoader(store);

    TypeMapping tm;

    TypeRegistrar::registerTypes();

    TypeRegistrar::addMappings(store, &tm);

    loader->setTypeMapping(tm);

    if (!load(store, ":data.ntriples")) {

        std::cerr << "Failed to unpack and load resource" << std::endl;

        return 1;

    }

    std::cerr << "imported, mapping..." << std::endl;

//    QObject *root = loader->loadAllObjects(0);

    QObjectList objects;

    try {

        objects = loader->loadAll();

//        std::cerr << "Loaded " << objects.size() << " objects" << std::endl;

    } catch (const std::exception &e) {

        std::cerr << "mapping failed: " << e.what() << std::endl;

        return 1;

    }

    delete loader;

    delete store;

    QObjectList composers;

//    std::cerr << "Known composers:" << std::endl;

    foreach (QObject *o, objects) {

        Composer *c = qobject_cast<Composer *>(o);

        if (c) {

            QString sn = c->getSortName(true);

            if (sn == "") {

                std::cerr << "WARNING: Composer " << c->name().toStdString() << " (URI " << c->property("uri").toString().toStdString() << ") has no sort-name" << std::endl;

            } else {

//                std::cerr << sn.toStdString() << std::endl;

            }

            composers.push_back(c);

        }

    }

/*

    for (int i = 1; i < argc; ++i) {

        QString name = argv[i];

        std::cerr << "Name: " << name.toStdString() << std::endl;

        QMultiMap<int, QString> matches;

        foreach (QObject *o, composers) {

            Composer *c = qobject_cast<Composer *>(o);

            if (!c) continue;

            int value = c->matchFuzzyName(name);

            matches.insert(value, c->getSortName(false));

        }

        for (QMultiMap<int, QString>::const_iterator i = matches.begin();

             i != matches.end(); ++i) {

            if (i.key() < 0) continue;

            std::cerr << "Score: " << i.key() << " for name: " << i.value().toStdString() << std::endl;

        }

    }

*/

    while (!std::cin.eof()) {

        std::cerr << std::endl << "Enter composer name: ";

        std::string s;

        getline(std::cin, s);

        std::cerr << "[" << s << "]" << std::endl;

        QMultiMap<float, QString> matches;

        QRegExp sre("[\\., -]+");

        QStringList elements = QString::fromStdString(s)

            .toLower().split(sre, QString::SkipEmptyParts);

        foreach (QObject *o, composers) {

            Composer *c = qobject_cast<Composer *>(o);

            if (!c) continue;

//            float value = c->matchFuzzyName(elements);

            float value = c->matchTyping(QString::fromStdString(s));

            matches.insert(value, c->getSortName(false));

        }

        int n = 0;

        for (QMultiMap<float, QString>::const_iterator i = matches.end();

             i != matches.begin(); ) {

            --i;

            if (i.key() <= 0) continue;

            if (n == 0) {

                std::cerr << "Best match:" << std::endl << " * ";

            } else if (n == 1) {

                std::cerr << "Other candidate(s):" << std::endl << " - ";

            } else {

                std::cerr << " - ";

            }

            std::cerr << i.value().toStdString();

            for (int c = i.value().length(); c < 40; ++c) std::cerr << " ";

            std::cerr << "[" << i.key() << "]" << std::endl;

            if (++n > 5) break;

        }

        if (n == 0) std::cerr << "No matches" << std::endl;

    }        

#ifdef TURBOT_PROFILER

    Turbot::Profiler::dump();

#endif

/*

    std::cerr << "mapped, storing again..." << std::endl;

    // let's try just writing out the composers

    BasicStore *outstore = new BasicStore();

    outstore->setBaseUri("http://dbtune.org/classical/resource/");

    ObjectMapper *outmapper = new ObjectMapper(outstore);

    TypeRegistrar::addMappings(outstore, outmapper);

//    outmapper->storeObjectTree(root);

    outmapper->storeAllObjects(composers);

    delete outmapper;

    std::cerr << "stored, saving..." << std::endl;

    outstore->save("test-output.ttl");

    delete outstore;

*/

}