RTransaction.h

Go to the documentation of this file.

#ifndef RTRANSACTION_H
#define RTRANSACTION_H

#include <QList>
#include <QMap>
#include <QSet>
#include <QSharedPointer>

#include "RObject.h"
#include "REntity.h"
#include "RPropertyTypeId.h"
#include "RPropertyChange.h"

class RStorage;
class RExporter;
class RDocument;

#define RDEFAULT_QSET_RPROPERTYTYPEID QSet<RPropertyTypeId> ()

class RTransaction {
public:
    RTransaction();

    RTransaction(RStorage& storage);

    RTransaction(RStorage& storage, int transactionId, const QString& text,
            const QList<RObject::Id>& affectedObjects,
            //const QSet<RObject::Id>& affectedEntities,
            const QMap<RObject::Id, QList<RPropertyChange> >& propertyChanges,
            RTransaction* parent = NULL);

    RTransaction(RStorage& storage, const QString& text, bool undoable = true,
            RTransaction* parent = NULL);

    virtual ~RTransaction();

    void setRecordAffectedObjects(bool on) {
        recordAffectedObjects = on;
    }

    void setAllowAll(bool on) {
        allowAll = on;
    }

    void setAllowInvisible(bool on) {
        allowInvisible = on;
    }

    void setSpatialIndexDisabled(bool on) {
        spatialIndexDisabled = on;
    }

    bool isUndoable() {
        return undoable;
    }

    bool isFailed() {
        return failed;
    }

    virtual void redo(RDocument* objectContainer = NULL);

    virtual void undo(RDocument* objectContainer = NULL);

    //virtual void preview(RExporter& /*exporter*/) const {}

    void end();

    void updateOverwrittenBlockReferences();

    void setId(int id) {
        transactionId = id;
    }

    int getId() {
        return transactionId;
    }

    QString getText() {
        return text;
    }

    bool overwriteBlock(QSharedPointer<RBlock> block);

    bool addObject(QSharedPointer<RObject> obj,
                   bool useCurrentAttributes = true,
                   const QSet<RPropertyTypeId>& modifiedPropertyTypeIds = RDEFAULT_QSET_RPROPERTYTYPEID);

    void addAffectedObject(RObject::Id objectId);
    void addAffectedObjects(const QSet<RObject::Id>& objectIds);
    void addAffectedObject(QSharedPointer<RObject> object);

    void deleteObject(RObject::Id objectId, RDocument* document);
    void deleteObject(QSharedPointer<RObject> object, RDocument* document);

    QList<RObject::Id> getAffectedObjects() {
        return affectedObjects;
    }

    QSet<RObject::Id> getStatusChanges() {
        return statusChanges;
    }

    QMap<RObject::Id, QList<RPropertyChange> > getPropertyChanges() {
        return propertyChanges;
    }

    bool hasOnlyChanges() {
        return onlyChanges;
    }

    void fail();

protected:
    bool addPropertyChange(RObject::Id objectId, const RPropertyChange& propertyChange);
    void appendChild(RTransaction& t);

    void commit();
    void rollback();

protected:
    RStorage* storage;

    int transactionId;

    QString text;

    QList<RObject::Id> affectedObjects;

    QList<RObject::Id> overwrittenBlockReferences;

    QMap<RObject::Id, QList<RPropertyChange> > propertyChanges;

    QSet<RObject::Id> statusChanges;

    QList<RTransaction> childTransactions;

    bool undoable;

    bool failed;

    bool onlyChanges;

    bool recordAffectedObjects;

    bool allowAll;

    bool allowInvisible;

    bool spatialIndexDisabled;
};

QDebug operator<<(QDebug dbg, RTransaction& t);

Q_DECLARE_METATYPE(RTransaction)
Q_DECLARE_METATYPE(RTransaction*)

#endif