OMRAS2 Classical Browser

    m_bs(0),

    m_bs = new BasicStore;

    m_index = new TransactionalStore(m_bs);

    TypeRegistrar::addMappings(m_bs, 0);

	m_bs->import(QUrl::fromLocalFile(m_indexFileName),

                     BasicStore::ImportIgnoreDuplicates);

    delete m_index;

    delete m_bs;

FeatureFileIndex::loadFor(AudioFile *tf, Store *store)

    // The AudioFile object has a URI and a hash.  Feature files

    // generated for this AudioFile should ideally have a matching

    // hash; if they have no hash, then the URI should match.  If the

    // hash is present in the feature file but does not match, then it

    // cannot be the right track even if the URI matches.

    Triple t(Node(), "foaf:primaryTopic", tf->uri());

    Triples results = m_index->match(t);

    std::cerr << "FeatureFileIndex::loadFor: " << results.size() << " feature file(s) for audio file " << tf->uri() << std::endl;

    t = Triple(Node(), "foaf:primaryTopic",

               Uri(QString::fromUtf8(QUrl(tf->uri().toString()).toEncoded())));

    Triples moreResults = m_index->match(t);

    std::cerr << "FeatureFileIndex::loadFor: " << moreResults.size() << " feature file(s) for audio file " << t.c << std::endl;

    //!!! what's the right approach here?

    if (results.empty() && moreResults.empty()) {

        return;

    }

FeatureFileIndex::featureFileAdded(QString filepath)

{

    index(QUrl::fromLocalFile(filepath));

}    

void

            index(QUrl::fromLocalFile(fi.filePath()));

    m_bs->save(m_indexFileName);

}

void

FeatureFileIndex::index(QUrl fileUrl)

{

    Triple typeTriple(Uri(fileUrl), "a", m_index->expand("foaf:Document"));

    if (m_index->contains(typeTriple)) {

        return;

    }

    Transaction *tx = m_index->startTransaction();

    tx->add(typeTriple);

    try {

        BasicStore *b = BasicStore::load(fileUrl);

        Triples ts = b->match

            (Triple(Node(), "a", m_index->expand("mo:AudioFile")));

        foreach (Triple t, ts) {

            tx->add(Triple(Uri(fileUrl), "foaf:primaryTopic", t.a));;

        }

    } catch (...) { }

    delete tx;

#include <dataquay/TransactionalStore.h>

class FeatureFileIndex : public QObject

    Q_OBJECT

    void loadFor(AudioFile *, Dataquay::Store *);

public slots:

    void featureFileAdded(QString filepath);

    Dataquay::BasicStore *m_bs;

    Dataquay::TransactionalStore *m_index;

    void index(QUrl);

AudioFile::AudioFile(QObject *parent) :

    QObject(parent)

AudioFile::AudioFile(FileSource source, QObject *parent) :

    QObject(parent)

        //!!! stream this!

    std::cerr << "AudioFile::AudioFile: hash = " << m_hash.toStdString()

// Separate AudioFile and Signal, to correspond with 

class AudioFile : public QObject

    AudioFile(QObject *parent = 0);

    AudioFile(FileSource file, QObject *parent = 0);

    /// The URI is set automatically from the FileSource at construction

    Dataquay::Uri uri() const { return m_uri; }

    void setUri(Dataquay::Uri u) { m_uri = u; emit uriChanged(u); }

signals:

    void uriChanged(Dataquay::Uri);

    void hashChanged(QString);

private:

    Dataquay::Uri m_uri;

    QString m_hash;

};

class Signal : public QObject

{

    Q_OBJECT

    Q_PROPERTY(QString ofaFingerprint READ ofaFingerprint WRITE setOfaFingerprint NOTIFY ofaFingerprintChanged STORED true)

    Q_PROPERTY(QString puid READ puid WRITE setPuid NOTIFY puidChanged STORED true)

    Q_PROPERTY(QSet<ClassicalData::AudioFile *> availableAs READ availableAs WRITE setAvailableAs NOTIFY availableAsChanged STORED true)

    Q_PROPERTY(ClassicalData::Composer *composer READ composer WRITE setComposer NOTIFY composerChanged STORED true)

    Q_PROPERTY(ClassicalData::Work *work READ work WRITE setWork NOTIFY workChanged STORED true)

    Q_PROPERTY(ClassicalData::Movement *movement READ movement WRITE setMovement NOTIFY movementChanged STORED true)

public:

    Signal() : m_composer(0), m_work(0), m_movement(0) { }

    QSet<AudioFile *> availableAs() const { return m_availableAs; }

    void setAvailableAs(QSet<AudioFile *> aa) { m_availableAs = aa; emit availableAsChanged(m_availableAs); }

    void addAvailableAs(AudioFile *aa) { m_availableAs.insert(aa); emit availableAsChanged(m_availableAs); }

    void availableAsChanged(QSet<AudioFile *>);

    QSet<AudioFile *> m_availableAs;

Q_DECLARE_METATYPE(ClassicalData::AudioFile*);

Q_DECLARE_METATYPE(ClassicalData::Signal*);

Q_DECLARE_METATYPE(QSet<ClassicalData::AudioFile*>);

Q_DECLARE_METATYPE(QSet<ClassicalData::Signal*>);

    qRegisterMetaType<AudioFile *>

	("ClassicalData::AudioFile*");

    qRegisterMetaType<QSet<AudioFile *> >

	("QSet<ClassicalData::AudioFile*>");

    qRegisterMetaType<Signal *>

	("ClassicalData::Signal*");

    ObjectBuilder::getInstance()->registerClass

	<AudioFile>("ClassicalData::AudioFile*");

    ContainerBuilder::getInstance()->registerContainer

	<AudioFile*, QSet<AudioFile*> >

	("ClassicalData::AudioFile*", "QSet<ClassicalData::AudioFile*>",

	 ContainerBuilder::SetKind);

	mapping->addTypeMapping("ClassicalData::AudioFile", store->expand("mo:AudioFile"));

	mapping->addPropertyMapping("ClassicalData::AudioFile", "hash", store->expand("foaf:sha1"));

	mapping->addTypeMapping("ClassicalData::Signal", store->expand("mo:Signal"));

	mapping->addPropertyMapping("ClassicalData::Signal", "availableAs", store->expand("mo:available_as"));

	mapping->addPropertyMapping("ClassicalData::Signal", "puid", store->expand("mo:puid"));

	mapping->addPropertyMapping("ClassicalData::Signal", "composer", store->expand("mo:composer"));

	mapping->addPropertyMapping("ClassicalData::Signal", "work", store->expand("mo:"));

	mapping->addPropertyMapping("ClassicalData::Signal", "availableAs", store->expand("mo:available_as"));

Signal *

//    cerr << "Creating Signal object...";

    Signal *tf = new Signal;

    tf->addAvailableAs(new AudioFile(fs));

    QStringList args;

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

        args.push_back(argv[i]);

    }

    BasicStore bs;

    if (!args.empty()) {

        foreach (QString track, args) {

            FileSource fs(track);

            AudioFile af(fs);

            ffi->loadFor(&af, &bs);

        }

    } 

            Signal *tf = guess(track);

Signal *

//    cerr << "Creating Signal...";

    Signal *tf = new Signal;

    tf->addAvailableAs(new AudioFile(fs));

    localStorer->setFollowPolicy(ObjectStorer::FollowObjectProperties);

    localStorer->setPropertyStorePolicy(ObjectStorer::StoreIfChanged);

            Signal *tf = guess(track);

    } else {

        usage(argv[0]);

    }