comparison common/Objects.h @ 0:e8f4c2b55fd8 classical-rdf

* reorganise

+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+#ifndef _CLASSICAL_DATA_OBJECTS_H_
+#define _CLASSICAL_DATA_OBJECTS_H_
+
+#include <QObject>
+#include <QMetaType>
+#include <QString>
+#include <QStringList>
+#include <QSharedPointer>
+#include <QUrl>
+#include <QSet>
+#include <QMutex>
+#include <QMutexLocker>
+#include <QMap>
+
+namespace ClassicalData {
+
+class HistoricalEvent : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(int year READ year WRITE setYear STORED true)
+    Q_PROPERTY(QString place READ place WRITE setPlace STORED true)
+    Q_PROPERTY(bool approximate READ approximate WRITE setApproximate STORED true)
+
+public:
+    HistoricalEvent() : m_year(0), m_place(), m_approximate(false) { }
+    HistoricalEvent(int y) : m_year(y), m_approximate(false) { }
+    HistoricalEvent(int y, QString p) : m_year(y), m_place(p), m_approximate(false) { }
+
+    int year() const { return m_year; }
+    void setYear(int y) { m_year = y; }
+    QString place() const { return m_place; }
+    void setPlace(QString p) { m_place = p; }
+    bool approximate() const { return m_approximate; }
+    void setApproximate(bool a) { m_approximate = a; }
+    
+private:
+    int m_year;
+    QString m_place;
+    bool m_approximate;
+};
+
+class Birth : public HistoricalEvent
+{
+    Q_OBJECT
+
+public:
+    Birth() : HistoricalEvent() { }
+    Birth(int y) : HistoricalEvent(y) { }
+    Birth(int y, QString p) : HistoricalEvent(y, p) { }
+};
+
+class Death : public HistoricalEvent
+{
+    Q_OBJECT
+
+public:
+    Death() : HistoricalEvent() { }
+    Death(int y) : HistoricalEvent(y) { }
+    Death(int y, QString p) : HistoricalEvent(y, p) { }
+};
+
+class Composer;
+class Work;
+
+class Composition : public HistoricalEvent
+{
+    Q_OBJECT
+    
+    Q_PROPERTY(ClassicalData::Composer *composer READ composer WRITE setComposer STORED true)
+    Q_PROPERTY(QSet<ClassicalData::Work *> works READ works WRITE setWorks STORED true)
+    Q_PROPERTY(QString composerName READ composerName WRITE setComposerName STORED false)
+
+public:
+    Composition() : HistoricalEvent(), m_composer(0) { }
+    Composition(int y) : HistoricalEvent(y), m_composer(0) { }
+    Composition(int y, QString p) : HistoricalEvent(y, p), m_composer(0) { }
+
+    Composer *composer() { return m_composer; }
+    void setComposer(Composer *c) { m_composer = c; }
+
+    QSet<Work *> works() { return m_works; }
+    void setWorks(QSet<Work *> c) { m_works = c; }
+    void addWork(Work *w) { m_works.insert(w); }
+
+    // Not a storable property, set temporarily while composer record is found
+    QString composerName() const { return m_cname; }
+    void setComposerName(QString n) { m_cname = n; }
+
+private:
+    Composer *m_composer;
+    QSet<Work *> m_works;
+    QString m_cname;
+};
+
+class Document : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QUrl uri READ uri WRITE setUri STORED true)
+    Q_PROPERTY(QString siteName READ siteName WRITE setSiteName STORED true)
+    Q_PROPERTY(QObject *topic READ topic WRITE setTopic STORED true)
+
+public:
+    Document(QObject *parent = 0) : QObject(parent), m_topic(0) { }
+    
+    QUrl uri() const { return m_uri; }
+    void setUri(QUrl uri) { m_uri = uri; }
+
+    QString siteName() const { return m_siteName; }
+    void setSiteName(QString n) { m_siteName = n; }
+
+    QObject *topic() const { return m_topic; }
+    void setTopic(QObject *t) { m_topic = t; }
+    
+private:
+    QUrl m_uri;
+    QString m_siteName;
+    QObject *m_topic;
+};
+
+
+class NamedEntity : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString name READ name WRITE setName STORED true)
+    Q_PROPERTY(QSet<QString> aliases READ aliases WRITE setAliases STORED true)
+    Q_PROPERTY(QString remarks READ remarks WRITE setRemarks STORED true)
+    Q_PROPERTY(QSet<ClassicalData::Document*> pages READ pages WRITE setPages STORED true)
+
+public:
+    NamedEntity(QObject *parent = 0) : QObject(parent) { }
+
+    QString name() const { return m_name; }
+    void setName(QString n) { m_name = n; }
+
+    QString remarks() const { return m_remarks; }
+    void setRemarks(QString n) { m_remarks = n; }
+    
+    QSet<QString> aliases() const { return m_aliases; }
+    void setAliases(QSet<QString> l) { m_aliases = l; }
+    void addAlias(QString a) { m_aliases.insert(a); }
+
+    QSet<Document *> pages() const { return m_pages; }
+    void addPage(Document *p) { m_pages.insert(p); }
+    void setPages(QSet<Document *> p) { m_pages = p; } //!!! destroy old ones? do we own?
+
+private:
+    QString m_name;
+    QString m_remarks;
+    QSet<QString> m_aliases;
+    QSet<Document *> m_pages;
+};
+
+class Movement;
+
+class Form;
+
+class Work : public NamedEntity
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString key READ key WRITE setKey STORED true)
+    Q_PROPERTY(QString opus READ opus WRITE setOpus STORED true)
+    Q_PROPERTY(QString catalogue READ catalogue WRITE setCatalogue STORED true)
+    Q_PROPERTY(QString number READ number WRITE setNumber STORED true)
+    Q_PROPERTY(QSet<ClassicalData::Form*> forms READ forms WRITE setForms STORED true)
+    Q_PROPERTY(ClassicalData::Work* partOf READ partOf WRITE setPartOf STORED true)
+    Q_PROPERTY(QSet<ClassicalData::Work*> parts READ parts WRITE setParts STORED true)
+    Q_PROPERTY(QSet<ClassicalData::Movement*> movements READ movements WRITE setMovements STORED true)
+    Q_PROPERTY(ClassicalData::Composition *composition READ composition WRITE setComposition STORED true)
+
+public:
+    Work(QObject *parent = 0) : NamedEntity(parent), m_partOf(0), m_composition(0) { }
+
+    QString key() const { return m_key; }
+    void setKey(QString n) { m_key = n; }
+
+    QString opus() const { return m_opus; }
+    void setOpus(QString n) { m_opus = n; }
+
+    QString catalogue() const { return m_catalogue; }
+    void setCatalogue(QString n) { m_catalogue = n; }
+
+    QString number() const { return m_number; }
+    void setNumber(QString n) { m_number = n; }
+
+    QSet<Form *> forms() const { return m_forms; }
+    void setForms(QSet<Form *> f) { m_forms = f; }
+    void addForm(Form *f) { m_forms.insert(f); }
+
+    Work *partOf() const { return m_partOf; }
+    void setPartOf(Work *w) { m_partOf = w; }
+
+    QSet<Work *> parts() const { return m_parts; }
+    void setParts(QSet<Work *> l) { m_parts = l; }
+    void addPart(Work *w) { m_parts.insert(w); }
+
+    QSet<Movement *> movements() const { return m_movements; }
+    void setMovements(QSet<Movement *> l) { m_movements = l; }
+    void addMovement(Movement *w) { m_movements.insert(w); }
+
+    Composition *composition() { return m_composition; }
+    const Composition *composition() const { return m_composition; }
+    void setComposition(Composition *c) { m_composition = c; }
+
+    struct Ordering {
+        bool operator()(Work *, Work *);
+    };
+
+private:
+    QString m_key;
+    QString m_opus;
+    QString m_catalogue;
+    QString m_number;
+    QSet<Form *> m_forms;
+    Work *m_partOf;
+    QSet<Work *> m_parts;
+    QSet<Movement *> m_movements;
+    Composition *m_composition;
+};
+
+class Movement : public NamedEntity
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString key READ key WRITE setKey STORED true)
+    Q_PROPERTY(QString number READ number WRITE setNumber STORED true)
+    Q_PROPERTY(ClassicalData::Work* partOf READ partOf WRITE setPartOf STORED true)
+    Q_PROPERTY(QSet<ClassicalData::Movement*> parts READ parts WRITE setParts STORED true) // movements can be nested
+    Q_PROPERTY(ClassicalData::Composition *composition READ composition WRITE setComposition STORED true)
+
+public:
+    Movement(QObject *parent = 0) : NamedEntity(parent), m_partOf(0), m_composition(0) { }
+
+    QString key() const { return m_key; }
+    void setKey(QString n) { m_key = n; }
+
+    QString number() const { return m_number; }
+    void setNumber(QString n) { m_number = n; }
+
+    Work *partOf() const { return m_partOf; }
+    void setPartOf(Work *w) { m_partOf = w; }
+
+    QSet<Movement *> parts() const { return m_parts; }
+    void setParts(QSet<Movement *> l) { m_parts = l; }
+    void addPart(Movement *w) { m_parts.insert(w); }
+
+    Composition *composition() { return m_composition; }
+    const Composition *composition() const { return m_composition; }
+    void setComposition(Composition *c) { m_composition = c; }
+
+private:
+    QString m_key;
+    QString m_number;
+    Work *m_partOf;
+    QSet<Movement *> m_parts;
+    Composition *m_composition;
+};
+
+class Composer : public NamedEntity
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString gender READ gender WRITE setGender STORED true)
+    Q_PROPERTY(QString nationality READ nationality WRITE setNationality STORED true)
+    Q_PROPERTY(QString period READ period WRITE setPeriod STORED true)
+    Q_PROPERTY(ClassicalData::Birth *birth READ birth WRITE setBirth STORED true)
+    Q_PROPERTY(ClassicalData::Death *death READ death WRITE setDeath STORED true)
+
+public:
+    Composer(QObject *parent = 0) : NamedEntity(parent), m_birth(0), m_death(0) { }
+
+    QString gender() const { return m_gender; }
+    void setGender(QString n) { m_gender = n; }
+
+    QString nationality() const { return m_nationality; }
+    void setNationality(QString n) { m_nationality = n; }
+
+    QString period() const { return m_period; }
+    void setPeriod(QString n) { m_period = n; }
+
+    Birth *birth() { return m_birth; }
+    const Birth *birth() const { return m_birth; }
+    void setBirth(Birth *b) { m_birth = b; }
+
+    Death *death() { return m_death; }
+    const Death *death() const { return m_death; }
+    void setDeath(Death *d) { m_death = d; }
+
+    QString getSortName(bool caps) const;
+    QString getDisplayDates() const;
+
+private:
+    QString m_gender;
+    QString m_nationality;
+    QString m_period;
+    Birth *m_birth;
+    Death *m_death;
+};
+
+class Form : public NamedEntity
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString uri READ uri)
+
+public:
+    Form(QObject *parent = 0) : NamedEntity(parent) { }
+
+    static Form *getFormByName(QString name) {
+        QMutexLocker locker(&m_mutex);
+        if (!m_map.contains(name)) {
+            Form *f = new Form();
+            f->setName(name);
+            m_map[name] = f;
+        }
+        return m_map[name];
+    }
+
+    QString uri() const {
+        return QString(":form_%1").arg(name()).toLower().replace(' ', '_');
+    }
+
+private:
+    static QMap<QString, Form *> m_map;
+    static QMutex m_mutex;
+};
+
+}
+
+Q_DECLARE_METATYPE(ClassicalData::HistoricalEvent*);
+Q_DECLARE_METATYPE(ClassicalData::Birth*);
+Q_DECLARE_METATYPE(ClassicalData::Death*);
+Q_DECLARE_METATYPE(ClassicalData::Composition*);
+Q_DECLARE_METATYPE(ClassicalData::Work*);
+Q_DECLARE_METATYPE(ClassicalData::Movement*);
+Q_DECLARE_METATYPE(ClassicalData::Document*);
+Q_DECLARE_METATYPE(QSet<QString>);
+Q_DECLARE_METATYPE(QSet<ClassicalData::Work*>);
+Q_DECLARE_METATYPE(QSet<ClassicalData::Movement*>);
+Q_DECLARE_METATYPE(QSet<ClassicalData::Document*>);
+Q_DECLARE_METATYPE(ClassicalData::Composer*);
+Q_DECLARE_METATYPE(ClassicalData::Form*);
+Q_DECLARE_METATYPE(QSet<ClassicalData::Form*>);
+	
+#endif