relation.h

#ifndef QELOQUENT_RELATION_H
#define QELOQUENT_RELATION_H
 
#include <QEloquent/global.h>
#include <QEloquent/entity.h>
#include <QEloquent/serializable.h>
#include <QEloquent/metaobject.h>
#include <QEloquent/itemproxy.h>
#include <QEloquent/listproxy.h>
#include <QEloquent/datamap.h>
 
#include <QList>
 
#include <source_location>
 
namespace QEloquent {
 
class Query;
class Error;
 
class QELOQUENT_EXPORT RelationData : public QSharedData,
                                      public Entity,
                                      public Serializable
{
public:
    RelationData();
    RelationData(const RelationData &other);
    virtual ~RelationData();
 
    virtual void init(NamingConvention *convention) = 0;
    virtual bool multiple() const = 0;
 
    // No need for full CRUD for now, insert/update not handled separately
    bool save() override { return false; }
    bool insert() override final { return save(); }
    bool update() override final { return save(); };
    bool deleteData() override { return false; }
 
    template<typename Model> QList<Model> &relatedModels() const
    { return *static_cast<QList<Model>*>(relatedList()); }
    virtual void *relatedList() const = 0;
 
    QString serializationContext() const override final;
    bool isListSerializable() const override final { return multiple(); }
 
    virtual RelationData *clone() const = 0;
 
    QString name;
    QMap<int, DataMap> pivotData;
    MetaObject primaryObject;
    MetaObject relatedObject;
    Model *parent = nullptr;
 
    bool isLoaded = false;
 
    static QExplicitlySharedDataPointer<RelationData> create(const QString &name, const Model *parent, const std::function<RelationData *()> &creationCallback);
    static QExplicitlySharedDataPointer<RelationData> create(const std::source_location &location, const Model *parent, const std::function<RelationData *()> &creationCallback);
 
protected:
    QVariant parentPrimary() const;
    void setParentPrimary(const QVariant &value);
 
    QVariant parentField(const QString &name) const;
    void setParentField(const QString &name, const QVariant &value);
 
    void conserve(const Query &query);
    void conserve(const Query &query, const Error &error);
};
 
template<typename Model>
class Relation : public Entity,
                 public AbstractItemProxy<Model>,
                 public AbstractListProxy<Model>,
                 public Serializable
{
    using ParentModel = QEloquent::Model;
    using RelatedModel = Model;
 
public:
    Relation() {}
    Relation(const QString &name, ParentModel *parent, const std::function<RelationData *()> &creationCallback)
        : data(RelationData::create(name, parent, creationCallback)) { ensureLoaded(); }
    Relation(const std::source_location &location, const ParentModel *parent, const std::function<RelationData *()> &creationCallback)
        : data(RelationData::create(location, parent, creationCallback)) { ensureLoaded(); }
    Relation(const Relation &other) = default;
    Relation(Relation &&other) = default;
    Relation<Model> &operator=(const Relation &other) = default;
    Relation<Model> &operator=(Relation &&other) = default;
 
    bool hasPivotData(int index, const QString &name) const
    { return data->pivotData.value(index).contains(name); }
 
    QVariant pivotData(int index, const QString &name) const
    { return data->pivotData.value(index).value(name); }
 
    void setPivotData(int index, const QString &name, const QVariant &value)
    { data->pivotData[index].insert(name, value); }
 
    bool exists() override { ensureLoaded(); return data->exists(); }
    bool get() override { ensureLoaded(); return data->get(); }
    bool save() override { return data->save(); }
    bool insert() override { return data->insert(); }
    bool update() override { return data->update(); }
    bool deleteData() override { return data->deleteData(); }
 
    QList<RelatedModel> related() const { ensureLoaded(); return data->relatedModels<RelatedModel>(); }
 
    QString serializationContext() const override final { return data->serializationContext(); }
    bool isListSerializable() const override final { return data->multiple(); }
    QList<DataMap> serialize() const override final { return data->serialize(); }
 
private:
    void ensureLoaded() const {
        if (!data->isLoaded) {
            data->get();
            data->isLoaded = true;
        }
    }
 
    const RelatedModel *constItem() const override {
        ensureLoaded();
        const QList<RelatedModel> *list = this->constList();
        return (list->isEmpty() ? this->defaultItem() : &list->first());
    }
 
    RelatedModel *mutableItem() override {
        ensureLoaded();
        QList<RelatedModel> *list = this->mutableList();
        return (list->isEmpty() ? this->defaultItem() : &list->first());
    }
 
    RelatedModel *defaultItem() const {
        static RelatedModel m;
        m = RelatedModel(); // We clear each time
        return &m;
    }
 
    const QList<RelatedModel> *constList() const override {
        ensureLoaded();
        return &data->relatedModels<RelatedModel>();
    }
 
    QList<RelatedModel> *mutableList() override {
        ensureLoaded();
        return &data->relatedModels<RelatedModel>();
    }
 
    QExplicitlySharedDataPointer<RelationData> data;
};
 
} // namespace QEloquent
 
Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(QEloquent::Relation)
 
#endif // QELOQUENT_RELATION_H