OMRAS2 Classical Browser

#include "TypeRegistrar.h"

#include "Objects.h"

#include <dataquay/BasicStore.h>

#include <dataquay/objectmapper/TypeMapping.h>

#include <dataquay/objectmapper/ObjectBuilder.h>

#include <dataquay/objectmapper/ContainerBuilder.h>

using namespace Dataquay;

namespace ClassicalData {

void

TypeRegistrar::registerTypes()

{

    qRegisterMetaType<Year>

        ("ClassicalData::Year");

    qRegisterMetaType<HistoricalEvent *>

        ("ClassicalData::HistoricalEvent*");

    qRegisterMetaType<Birth *>

        ("ClassicalData::Birth*");

    qRegisterMetaType<Death *>

        ("ClassicalData::Death*");

    qRegisterMetaType<Composition *>

        ("ClassicalData::Composition*");

    qRegisterMetaType<Work *>

        ("ClassicalData::Work*");

    qRegisterMetaType<Movement *>

        ("ClassicalData::Movement*");

    qRegisterMetaType<Composer *>

        ("ClassicalData::Composer*");

    qRegisterMetaType<Document *>

        ("ClassicalData::Document*");

    qRegisterMetaType<Form *>

        ("ClassicalData::Form*");

    qRegisterMetaType<QSet<Work *> >

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

    qRegisterMetaType<QSet<Movement *> >

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

    qRegisterMetaType<QSet<Document *> >

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

    qRegisterMetaType<QSet<Form *> >

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

    qRegisterMetaType<QSet<QString> >

        ("QSet<QString>");

    qRegisterMetaType<QSet<Dataquay::Uri> >

        ("QSet<Dataquay::Uri>");

    qRegisterMetaType<AudioFileTag *>

        ("ClassicalData::AudioFileTag*");

    qRegisterMetaType<QSet<AudioFileTag *> >

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

    qRegisterMetaType<AudioFile *>

        ("ClassicalData::AudioFile*");

    qRegisterMetaType<QSet<AudioFile *> >

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

    qRegisterMetaType<Signal *>

        ("ClassicalData::Signal*");

    Node::registerDatatype(Uri("http://www.w3.org/2001/XMLSchema#gYear"),

                           "ClassicalData::Year", new Year::Encoder());

    ObjectBuilder::getInstance()->registerClass

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

    ObjectBuilder::getInstance()->registerClass

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

    ObjectBuilder::getInstance()->registerClass

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

    ObjectBuilder::getInstance()->registerClass

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

    ObjectBuilder::getInstance()->registerClass

        <Work, QObject>("ClassicalData::Work*");

    ObjectBuilder::getInstance()->registerClass

        <Movement, QObject>("ClassicalData::Movement*");

    ObjectBuilder::getInstance()->registerClass

        <Composer, QObject>("ClassicalData::Composer*");

    ObjectBuilder::getInstance()->registerClass

        <Document, QObject>("ClassicalData::Document*");

    ObjectBuilder::getInstance()->registerClass

        <Form, QObject>("ClassicalData::Form*");

    ObjectBuilder::getInstance()->registerClass

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

    ObjectBuilder::getInstance()->registerClass

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

    ContainerBuilder::getInstance()->registerContainer

        <QString, QSet<QString> >

        ("QString", "QSet<QString>", ContainerBuilder::SetKind);

    ContainerBuilder::getInstance()->registerContainer

        <Dataquay::Uri, QSet<Dataquay::Uri> >

        ("Dataquay::Uri", "QSet<Dataquay::Uri>", ContainerBuilder::SetKind);

    ContainerBuilder::getInstance()->registerContainer

        <Work*, QSet<Work*> >

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

         ContainerBuilder::SetKind);

    ContainerBuilder::getInstance()->registerContainer

        <Movement*, QSet<Movement*> >

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

         ContainerBuilder::SetKind);

    ContainerBuilder::getInstance()->registerContainer

        <Document*, QSet<Document*> >

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

         ContainerBuilder::SetKind);

    ContainerBuilder::getInstance()->registerContainer

        <Form*, QSet<Form*> >

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

         ContainerBuilder::SetKind);

    ContainerBuilder::getInstance()->registerContainer

        <AudioFileTag*, QSet<AudioFileTag*> >

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

         ContainerBuilder::SetKind);

    ContainerBuilder::getInstance()->registerContainer

        <AudioFile*, QSet<AudioFile*> >

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

         ContainerBuilder::SetKind);

}

void

TypeRegistrar::addMappings(BasicStore *store, TypeMapping *mapping)

{

    if (store) {

        store->addPrefix("foaf", Uri("http://xmlns.com/foaf/0.1/"));

        store->addPrefix("mo", Uri("http://purl.org/ontology/mo/"));

        store->addPrefix("dc", Uri("http://purl.org/dc/elements/1.1/"));

        store->addPrefix("bio", Uri("http://purl.org/vocab/bio/0.1/"));

        store->addPrefix("owl", Uri("http://www.w3.org/2002/07/owl#"));

        store->addPrefix("rdfs", Uri("http://www.w3.org/2000/01/rdf-schema#"));

        store->addPrefix("db", Uri("http://dbtune.org/musicbrainz/resource/"));

        store->addPrefix("dbv", Uri("http://dbtune.org/musicbrainz/resource/vocab/"));

        store->addPrefix("cmn", Uri("http://purl.org/ontology/classicalmusicnav#"));

        store->addPrefix("sim", Uri("http://purl.org/ontology/similarity/"));

    }

    if (mapping) {

        mapping->setObjectTypePrefix(Uri("http://dbtune.org/classical/resource/"));

        mapping->setPropertyPrefix(Uri("http://dbtune.org/classical/resource/vocab/"));

        mapping->setRelationshipPrefix(Uri("http://dbtune.org/classical/resource/vocab/relationship/"));

    }

    if (store && mapping) {

        store->addPrefix("type", mapping->getObjectTypePrefix());

        store->addPrefix("classical", Uri(mapping->getObjectTypePrefix().toString() + "type/"));

        store->addPrefix("property", mapping->getPropertyPrefix());

        store->addPrefix("rel", mapping->getRelationshipPrefix());

        store->add(Triple("classical:Composer", "a", store->expand("owl:Class")));

        store->add(Triple("classical:Composer", "rdfs:subClassOf", store->expand("mo:MusicArtist")));

        store->add(Triple("property:birth", "a", store->expand("owl:ObjectProperty")));

        store->add(Triple("property:birth", "rdfs:subPropertyOf", store->expand("bio:event")));

        store->add(Triple("property:death", "a", store->expand("owl:ObjectProperty")));

        store->add(Triple("property:death", "rdfs:subPropertyOf", store->expand("bio:event")));

        mapping->addTypeMapping("ClassicalData::Composer", store->expand("classical:Composer"));

        mapping->addPropertyMapping("ClassicalData::Composer", "pages", store->expand("foaf:page"));

        mapping->addPropertyMapping("ClassicalData::Composer", "name", store->expand("foaf:name"));

        mapping->addPropertyMapping("ClassicalData::Composer", "aliases", store->expand("dbv:alias"));

        mapping->addPropertyMapping("ClassicalData::Composer", "birth", store->expand("property:birth"));

        mapping->addPropertyMapping("ClassicalData::Composer", "death", store->expand("property:death"));

        mapping->addPropertyMapping("ClassicalData::Composer", "geonameURIs", store->expand("foaf:based_near"));

        mapping->addPropertyMapping("ClassicalData::Composer", "otherURIs", store->expand("owl:sameAs"));

        mapping->addPropertyMapping("ClassicalData::Composer", "gender", store->expand("foaf:gender"));

        mapping->addTypeMapping("ClassicalData::Birth", store->expand("bio:Birth"));

        mapping->addTypeMapping("ClassicalData::Death", store->expand("bio:Death"));

        mapping->addTypeUriPrefixMapping("ClassicalData::Birth", store->expand(":event/"));

        mapping->addTypeUriPrefixMapping("ClassicalData::Death", store->expand(":event/"));

        mapping->addPropertyMapping("ClassicalData::Birth", "year", store->expand("dc:date"));

        mapping->addPropertyMapping("ClassicalData::Death", "year", store->expand("dc:date"));

        mapping->addPropertyMapping("ClassicalData::Composition", "year", store->expand("dc:date"));

        mapping->addPropertyMapping("ClassicalData::Birth", "place", store->expand("bio:place"));

        mapping->addPropertyMapping("ClassicalData::Death", "place", store->expand("bio:place"));

        mapping->addPropertyMapping("ClassicalData::Composition", "place", store->expand("bio:place"));

        mapping->addTypeMapping("ClassicalData::Document", store->expand("foaf:Document"));

        mapping->addPropertyMapping("ClassicalData::Document", "topic", store->expand("foaf:primaryTopic"));

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

        mapping->addPropertyMapping("ClassicalData::Work", "composition", store->expand("mo:composed_in"));

        mapping->addPropertyMapping("ClassicalData::Work", "opus", store->expand("mo:opus"));

        mapping->addPropertyMapping("ClassicalData::Work", "catalogue", store->expand("mo:catalogue"));

        mapping->addPropertyMapping("ClassicalData::Work", "number", store->expand("mo:number"));

        mapping->addPropertyMapping("ClassicalData::Work", "partOf", store->expand("dc:isPartOf"));

        mapping->addPropertyMapping("ClassicalData::Work", "parts", store->expand("dc:hasPart"));

        mapping->addPropertyMapping("ClassicalData::Work", "pages", store->expand("foaf:page"));

        mapping->addPropertyMapping("ClassicalData::Work", "forms", store->expand("property:form"));

        mapping->addPropertyMapping("ClassicalData::Work", "key", store->expand("mo:key"));

        mapping->addPropertyMapping("ClassicalData::Work", "aliases", store->expand("dbv:alias"));

        mapping->addPropertyMapping("ClassicalData::Work", "name", store->expand("dc:title"));

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

        mapping->addTypeUriPrefixMapping("ClassicalData::Composition", store->expand(":event/"));

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

        mapping->addPropertyMapping("ClassicalData::Composition", "works", store->expand("mo:produced_work"));

        mapping->addTypeMapping("ClassicalData::AudioFileTag", store->expand("classical:AudioFileTag"));

        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"));

    }

}

}