RObject.h

Go to the documentation of this file.

 
#ifndef ROBJECT_H
#define ROBJECT_H
 
#include "core_global.h"
 
#include <QDebug>
 
#include "RPropertyAttributes.h"
#include "RPropertyTypeId.h"
 
class RDocument;
class RTransaction;
class RVector;
 
#ifndef RQMapQStringQString
typedef QMap<QString, QString> RQMapQStringQString;
#endif
 
#ifndef RDEFAULT_QVARIANT
#define RDEFAULT_QVARIANT QVariant()
#endif
 
#ifndef RDEFAULT_QSTRING
#define RDEFAULT_QSTRING QString()
#endif
 
#ifndef RDEFAULT_QSTRINGLIST
#define RDEFAULT_QSTRINGLIST QStringList()
#endif
 
 
 
class QCADCORE_EXPORT 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 PropertyType;
    static RPropertyTypeId PropertyHandle;
    static RPropertyTypeId PropertyProtected;
    static RPropertyTypeId PropertyWorkingSet;
    static RPropertyTypeId PropertySelected;
    static RPropertyTypeId PropertyInvisible;
 
    enum XYZ {
        X, Y, Z
    };
 
public:
    enum ObjectFlag {
        NoFlags = 0x000,
        Undone = 0x001,           
        Protect = 0x002,          
        Selected = 0x004,         
        Invisible = 0x008,        
        WorkingSet = 0x010        
    };
    Q_DECLARE_FLAGS(Flags, ObjectFlag)
 
public:
    RObject(RDocument* document=NULL);
    RObject(const RObject& other);
    virtual ~RObject();
 
    static void init();
 
    static RS::EntityType getRtti() {
        return RS::ObjectUnknown;
    }
 
    virtual bool isOfType(RS::EntityType t) const {
        return getType()==t;
    }
 
    virtual RS::EntityType getType() const {
        return RS::ObjectUnknown;
    }
 
    virtual QSharedPointer<RObject> clone() const = 0;
 
    virtual bool mustAlwaysClone() const {
        return false;
    }
 
    RDocument* getDocument() {
        return document;
    }
 
    const RDocument* getDocument() const {
        return document;
    }
 
    void setDocument(RDocument* document);
 
    void setFlag(int flag, bool on = true) {
        if (on) {
            flags |= (ObjectFlag)flag;
        } else {
            flags &= ~(ObjectFlag)flag;
        }
    }
    bool getFlag(int flag) const {
        return (int)(flags & flag) == flag;
    }
 
    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 isProtected() const {
        return getFlag(RObject::Protect);
    }
 
    void setProtected(bool on) {
        setFlag(RObject::Protect, on);
    }
 
    bool isInvisible() const {
        return getFlag(RObject::Invisible);
    }
 
    void setInvisible(bool on) {
        setFlag(RObject::Invisible, on);
    }
 
    virtual bool isSelected() const {
        return getFlag(RObject::Selected);
    }
 
    virtual void setSelected(bool on) {
        setFlag(RObject::Selected, on);
    }
 
    bool isUndone() const {
        return getFlag(RObject::Undone);
    }
 
    virtual bool isWorkingSet() const {
        return getFlag(RObject::WorkingSet);
    }
 
    virtual void setWorkingSet(bool on) {
        setFlag(RObject::WorkingSet, on);
    }
 
    virtual QSet<RPropertyTypeId> getPropertyTypeIds(RPropertyAttributes::Option option = RPropertyAttributes::NoOptions) const;
    virtual QSet<RPropertyTypeId> getCustomPropertyTypeIds() const;
 
    virtual QPair<QVariant, RPropertyAttributes> getProperty(RPropertyTypeId& propertyTypeId,
        bool humanReadable = false, bool noAttributes = false, bool showOnRequest = false);
 
    virtual bool setProperty(RPropertyTypeId propertyTypeId,
        const QVariant& value, RTransaction* transaction=NULL);
 
    virtual bool hasPropertyType(RPropertyTypeId propertyTypeId) {
        return RPropertyTypeId::hasPropertyType(getType(), propertyTypeId);
    }
 
    bool hasCustomProperties() const;
    bool hasCustomProperty(const QString& title, const QString& key) const;
 
    bool hasCustomProperty(const QString& title, const QRegularExpression& key) const;
 
    virtual QVariant getCustomProperty(const QString& title, const QString& key, const QVariant& defaultValue = RDEFAULT_QVARIANT) const;
    virtual double getCustomDoubleProperty(const QString& title, const QString& key, double defaultValue) const;
    virtual int getCustomIntProperty(const QString& title, const QString& key, int defaultValue) const;
    virtual bool getCustomBoolProperty(const QString& title, const QString& key, bool defaultValue) const;
    virtual void setCustomProperty(const QString& title, const QString& key, const QVariant& value);
 
    virtual void setCustomProperties(const RQMapQStringQString& properties);
    virtual void removeCustomProperty(const QString& title, const QString& key);
    QStringList getCustomPropertyTitles() const;
    QStringList getCustomPropertyKeys(const QString& title) const;
    void copyCustomPropertiesFrom(const RObject *other,
            const QString& title = RDEFAULT_QSTRING,
            bool overwrite = false,
            const QStringList& ignoreList = RDEFAULT_QSTRINGLIST,
            const QString& mapKeyFrom = RDEFAULT_QSTRING,
            const QString& mapKeyTo = RDEFAULT_QSTRING);
 
    static void setCustomPropertyAttributes(const QString& title, const QString& key, const RPropertyAttributes& att);
    static RPropertyAttributes getCustomPropertyAttributes(const QString& title, const QString& key);
 
    QMap<QString, QVariantMap> getCustomProperties() const;
 
    virtual int getComplexity() const {
        return 0;
    }
 
    virtual void setAutoUpdatesBlocked(bool on) {
        Q_UNUSED(on)
    }
 
    void dump() const {
        qDebug() << *this;
    }
 
    virtual bool validate() {
        return true;
    }
 
    friend QDebug operator<<(QDebug dbg, const RObject& o) {
        o.print(dbg);
        return dbg;
    }
 
protected:
    virtual void print(QDebug dbg) const;
 
    void setUndone(bool on);
 
    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 setMemberFlag(int flag, const QVariant& value, bool condition = true);
    static bool setMember(QList<double>& variable, const QVariant& value, bool condition);
    static bool setMember(QList<int>& 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;
    Flags flags;
    QMap<QString, QVariantMap> customProperties;
 
    static QMap<QString, QMap<QString, RPropertyAttributes> > customPropertyAttributes;
};
 
Q_DECLARE_METATYPE(RObject::Id)
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*)
Q_DECLARE_METATYPE(RObject::ObjectFlag)
Q_DECLARE_METATYPE(QFlags<RObject::ObjectFlag>)
 
#endif