RObject.h

Go to the documentation of this file.

#ifndef ROBJECT_H
#define ROBJECT_H

#include "RPropertyAttributes.h"
#include "RPropertyTypeId.h"

class RDocument;

#ifndef RDEFAULT_QVARIANT
#define RDEFAULT_QVARIANT QVariant()
#endif


class RObject {

    friend class RStorage;

public:
    typedef int Id;
    const static Id INVALID_ID;
    typedef int Handle;
    const static Handle INVALID_HANDLE;

    static RPropertyTypeId PropertyCustom;
    static RPropertyTypeId PropertyHandle;

    enum XYZ {
        X, Y, Z
    };

public:

    RObject(RDocument* document=NULL, Id id = INVALID_ID) :
        document(document), objectId(id), handle(INVALID_HANDLE), undone(false) {
    }
    virtual ~RObject() {
    }

    static void init();

    virtual RObject* clone() const = 0;

    RDocument* getDocument() {
        return document;
    }

    const RDocument* getDocument() const {
        return document;
    }

    void setDocument(RDocument* document) {
        this->document = document;
    }

    //  static double variantToDouble(const QVariant& v, double defaultValue,
    //          bool ignoreError = true);
    //  static int variantToInt(const QVariant& v, int defaultValue,
    //          bool ignoreError = true);

    template<class T>
    static bool setMember(T& variable, const QVariant& value,
        bool condition = true) {

        if (!condition) {
            return false;
        }
        variable = value.value<T> ();
        return true;
    }

    RObject::Id getId() const {
        return objectId;
    }

    RObject::Handle getHandle() const {
        return handle;
    }

    bool isUndone() const {
        return undone;
    }

    virtual void setUndone(bool on);

    virtual QSet<RPropertyTypeId> getPropertyTypeIds() const;

    virtual QPair<QVariant, RPropertyAttributes>
            getProperty(RPropertyTypeId propertyTypeId,
                    bool humanReadable = false,
                    bool noAttributes = false);

    virtual bool setProperty(RPropertyTypeId propertyTypeId, const QVariant& value);

    virtual bool hasPropertyType(RPropertyTypeId propertyTypeId) {
        return RPropertyTypeId::hasPropertyType(typeid(*this), propertyTypeId);
    }

    virtual bool isSelectedForPropertyEditing() = 0;

    QVariant getCustomProperty(const QString& key, const QVariant& defaultValue = RDEFAULT_QVARIANT);
    void setCustomProperty(const QString& key, const QVariant& value);
    void removeCustomProperty(const QString& key);
    QMap<QString, QVariant> getCustomProperties() const;

    virtual int getComplexity() const {
        return 0;
    }

    //    RPropertyTypeId getPropertyId(const QString& propertyGroupTitle, const QString& propertyTitle) {
    //        if (propertyTypeIdMap.count(propertyGroupTitle)==0 ||
    //            propertyTypeIdMap[propertyGroupTitle].count(propertyTitle)==0) {
    //
    //            return -1;
    //        }
    //        else {
    //            return propertyTypeIdMap[propertyGroupTitle][propertyTitle];
    //        }
    //    }

    //    static RPropertyTypeId getPropertyTypeId(const QString& propertyGroupTitle, const QString& propertyTitle) {
    //        if (propertyTypeIdMap.count(propertyGroupTitle)==0) {
    //            return -1;
    //        }
    //        if (propertyTypeIdMap[propertyGroupTitle].count(propertyTitle)==0) {
    //            return -1;
    //        }
    //
    //        return propertyTypeIdMap[propertyGroupTitle][propertyTitle];
    //    }

    friend QDebug operator<<(QDebug dbg, const RObject& o) {
        o.print(dbg);
        return dbg;
    }

protected:
    virtual void print(QDebug dbg) const;

    void setId(RObject::Id id) {
        objectId = id;
    }

    void setHandle(RObject::Handle h) {
        handle = h;
    }

    static bool setMember(QString& variable, const QVariant& value,
            bool condition = true);
    static bool setMember(double& variable, const QVariant& value,
            bool condition = true);
    static bool setMember(int& variable, const QVariant& value,
            bool condition = true);
    static bool setMember(bool& variable, const QVariant& value,
            bool condition = true);
    bool setMember(QList<double>& variable, const QVariant& value,
           bool condition);
    static bool setMemberX(QList<RVector>& variable, const QVariant& value,
                          bool condition = true);
    static bool setMemberY(QList<RVector>& variable, const QVariant& value,
                           bool condition = true);
    static bool setMemberZ(QList<RVector>& variable, const QVariant& value,
                           bool condition = true);

    static bool setMemberVector(QList<RVector>& variable, const QVariant& value,
                             RObject::XYZ xyz);

private:
    RDocument* document;
    Id objectId;
    Handle handle;
    bool undone;
    QMap<QString, QVariant> customProperties;
};

Q_DECLARE_METATYPE(RObject::XYZ)
Q_DECLARE_METATYPE(RObject::XYZ*)
Q_DECLARE_METATYPE(QList<QSharedPointer<RObject> >)
Q_DECLARE_METATYPE(QSharedPointer<RObject>)
Q_DECLARE_METATYPE(QSharedPointer<RObject>*)
typedef QMap<int, QSharedPointer<RObject> > _RMapIntObjectPointer;
Q_DECLARE_METATYPE(_RMapIntObjectPointer)
Q_DECLARE_METATYPE(RObject*)

#endif