PropertyContainer.h

Go to the documentation of this file.

#pragma once
#pragma warning(disable : 4251)

#include <Base/Persistance.h>
#include <Core/PropertyMacros.h>
#include <Core/PropertyValue.h>
#include <Core/Variant.h>
#include <Core/core_defines2.h>
#include <Geom/BrepData.h>

#include <list>
#include <map>
#include <set>
#include <unordered_map>

#define USE_PROPERTYMAP

static const char* PropertyName = "Property";

class PropertyTree;
class Base::AbstractXMLReader;
class CA_Writer;
class Base::Reader;
class QFont;
class Draw::DrawStyle;
class Draw::Arrowheads;
class MD5;
class Draw::Texture2Transform;



namespace Base
{
class Color;
}

namespace Core
{
class FieldData
{
public:
    FieldData(const Core::FieldData* /*fd*/){};
};
}  // namespace Core

namespace App
{
class ElementTool;
}



#define MUTABLE_CONTAINER(_class_) \
public: \
    static bool isMutableStatic() { return true; } \
\
public: \
    virtual bool isMutable() const { return true; }

#define IMMUTABLE_CONTAINER(_class_) \
public: \
    friend class Core::PropertyBundle<_class_>; \
\
public: \
    static bool isMutableStatic() { return false; } \
\
public: \
    virtual bool isMutable() const { return false; } \
\
public: \
    Core::PropertyBundle<_class_> getPropertyBundle() const \
    { \
        Core::PropertyBundle<_class_> dsBundle; \
        dsBundle.setPropertyValues(this); \
        return dsBundle; \
    }


namespace Core
{
class CoreDocument;
class Placement;
class DocObject;
class ObjectExecutor;
class Property;
class DbgInfo;
class PropertyUser;

class CORE_EXPORT LxFieldData
{
public:
    LxFieldData(void);
    LxFieldData(const LxFieldData* fd);
    void addField(void* base, char* fieldname, void* fieldptr);
    std::unordered_map<std::string, ptrdiff_t> m_fieldmap;
    bool fieldsAdded = false;
};



class CORE_EXPORT PropertyContainer : public Base::Persistance
{
    TYPESYSTEM_HEADER();
    LX_NODE_HEADER();
    MUTABLE_CONTAINER(Core::PropertyContainer);

public:
    friend class PostInitClass;
    friend class CoreDocument;
    friend class ObjectExecutor;
    friend class ::App::ElementTool;

    enum class CheckStatus
    {
        IsNew,
        IsUpdated
    };

    //                                                       //
    // --------------------- BEGIN API --------------------- //
    //                                                       //
    // ATTENTION: DO NOT CHANGE ANY SIGNATURES IN THE API !  //
    //                                                       //

    PropertyContainer(void);
    // Copy constructor
    PropertyContainer(const PropertyContainer& rhs);
    virtual ~PropertyContainer(void) = default;

    bool addProperty(Core::Property* p, const std::string& name);
    Core::Property* addProperty(Base::Type t, const std::string& name, const Core::Variant& defaultValue);
    Core::PropertyUser* addPropertyUser(const std::string& name, const Core::Variant& value);
    void removeProperty(Core::Property* p, std::string pName);
    void removeAllProperties();
    inline Core::Property* getPropertyByName(const std::string& name) const;
    inline Core::Property* getPropertyByName(const Base::String& name) const;

    template <typename T>
    T* getPropertyByName(const std::string& name) const
    {
        Core::Property* p = getPropertyByName(name);

        if (p && p->isDerivedFrom<T>())
        {
            return static_cast<T*>(p);
        }

        return nullptr;
    }


    void getPropertyMap(Core::PropertyMap&) const;
    std::vector<std::pair<Core::Property*, std::string> > getPropertiesAndNameByType(Base::Type type) const;
    std::vector<Core::Property*> getPropertiesByType(Base::Type type) const;
    std::vector<Core::Property*> getPropertiesByTypes(const std::vector<Base::Type>& type) const;
    bool setPropertyFromVariant(const std::string& name, const Core::Variant& value);

    bool setProperty(const std::string& name, double value);
    bool setProperty(const std::string& name, int value);
    bool setProperty(const std::string& name, const Geom::Vec& value);
    bool setProperty(const std::string& name, const std::list<Geom::Vec>& value);
    bool setProperty(const std::string& name, const Geom::Trsf& value);
    bool setProperty(const std::string& name, const std::string& value);
    bool setProperty(const std::string& name, const char* value);
    bool setProperty(const std::string& name, const Base::String& value);
    bool setProperty(const std::string& name, const Geom::Pnt& value);
    bool setProperty(const std::string& name, const Geom::Pnt2d& value);
    bool setProperty(const std::string& name, const std::vector<Geom::Pnt>& value);
    bool setProperty(const std::string& name, const std::vector<Geom::Pnt2d>& value);
    // bool setProperty(const std::string& name, const std::list<std::string>& value);
    // bool setProperty(const std::string& name, const Core::Placement& value);
    bool setProperty(const std::string& name, const MD5& value);
    bool setProperty(const std::string& name, bool value);
    bool setProperty(const std::string& name, Core::DocObject* value);
    // without this method, method setProperty(const std::string& name, bool value) is called for const Core::DocObject
    bool setProperty(const std::string& name, const Core::DocObject* value);
    bool setProperty(const std::string& name, const boost::unordered_set<Core::DocObject*>& value);
    bool setProperty(const std::string& name, const std::list<Core::DocObject*>& value);
    bool setProperty(const std::string& name, const std::vector<int>& value);
    bool setProperty(const std::string& name, const QFont& value);
    bool setProperty(const std::string& name, const Draw::DrawStyle& value);
    bool setProperty(const std::string& name, const Draw::Arrowheads& value);
    bool setProperty(const std::string& name, const Geom::Dir& value);
    bool setProperty(const std::string& name, const Geom::Dir2d& value);
    bool setProperty(const std::string& name, const Base::Color& value);
    bool setProperty(const std::string& name, const Geom::Ax1& value);
    bool setProperty(const std::string& name, const Geom::Ax2& value);
    // bool setProperty(const std::string& name, const gp_Ax22d& value);
    bool setProperty(const std::string& name, const Draw::Texture2Transform& value);
    bool setProperty(const std::string& name, const std::list<std::list<Geom::Pnt> >& value);
    bool setProperty(const std::string& name, const std::list<double>& value);
    bool setProperty(const std::string& name, pBrepData& value);



    virtual bool onBeforeChange(Core::Property* p, const Core::Variant& newValue = Core::Variant());
    virtual void onChanged(Core::Property* p);
    virtual void onDeleted();
    virtual void onNew();
    virtual void save(Base::AbstractWriter& writer, Base::PersistanceVersion& version);
    virtual void restore(Base::AbstractXMLReader& reader, Base::PersistanceVersion& version);
    bool enableNotify(const bool enable);
    bool isNotifyEnabled(void) const;
    void touch();

    bool isDeleted() const;
    bool isStatusDeleted() const;
    bool isMarkedForDelete() const;
    bool isMarkedForDeleteFinal() const;
    bool isDeletedFinal() const;
    bool isNew() const;
    bool isUpdated() const;
    bool isValid() const;
    bool hasErrors() const;
    void setData(const std::string& key, void* data);
    void* getData(const std::string& key, bool* ok = nullptr) const;
    void removeData(const std::string& key);
    bool hasSameValuesAs(const PropertyContainer* container) const;
    void setPropertyValues(const PropertyContainer* other);
    template <typename T>
    T getPropertyValueByName(const std::string& propertyName, bool* ok = 0) const
    {
        Core::Property* p = getPropertyByName(propertyName);
        if (p)
            return p->getVariant().getValue<T>(ok);
        else
            return Core::Variant().getValue<T>(ok);
    }

    virtual void ensureIntegrity();
    void integrityMaintained();
    void integrityLost();
    bool checkIntegrity();


protected:
    void addPropertiesFrom(const Core::PropertyContainer* other);

    //                                                       //
    // ---------------------- END API ---------------------- //
    //                                                       //


#ifndef LXAPI  // INTERFACES BELOW ARE -NOT- PART OF THE LEXOCAD API

public:
    Core::PropertyValueMap getPropertyValueMap() const;
    std::map<std::string, Core::Variant> getKeyValueMap() const;
    bool setPropertyFromKeyValue(const std::string& propertyName, const std::string& key, const Core::Variant& value);
    std::set<Core::Property*> getUpdatedProperties() const;
    void setUpdated();
    void setUpdated(const Core::Property* p);
    void setHasErrors();
    void setNew();
    void setValid();
    void setDeleted();
    void setMarkedForDelete();
    void setMarkedForDeleteFinal();
    void setDeleteFinal();

    unsigned int getPropertyChangeStatus() const;
    CheckStatus getCheckStatus() const;
    void setCheckStatus(CheckStatus status);
    void setAllPropertiesValid();
    void setPropertyValues(const Core::PropertyValueMap& other);
    std::vector<Core::Property*> getPropertiesOrdered() const;

    void __setCheckIsNew__();
    virtual bool check_lx(char* f, char* n);



    bool isRestored = false;

#ifdef USE_PROPERTYMAP

    bool rollBack();

    void saveLastValidPropertyMap();

    const Core::PropertyValueMap& getLastValidPropertyMap() const;
#endif


protected:
    enum class Status
    {
        New = 1,
        Updated = 2,
        Valid = 3,
        MarkedForDelete = 4,
        MarkedForDeleteFinal,
        Deleted,
        DeletedFinal,
        Error
    };

    virtual void setStatus(Status status);
    Status getStatus() const;

    bool checkForAlreadyExistingProperty(Core::Property* property);

    virtual void restoreProperty(Core::Property* property,
                                 const Base::String& name,
                                 Base::AbstractXMLReader& reader,
                                 Base::PersistanceVersion& version);

    unsigned int _changedProperties;

private:
    void _setPropertyValues(const Core::PropertyValueMap& pmap, bool isInit = false);
    void _setPropertyValues(const Core::PropertyContainer* other, bool isInit = false);
    void getPropertyMapSetNotify(bool v);

    std::unordered_map<std::string, Core::Property*> _userPropertyMap;
#ifdef USE_PROPERTYMAP
    std::unordered_map<std::string, PropertyValue> _lastValidPropertyMap;
#endif
    std::unordered_map<std::string, void*> _data;
    Status _status = Status::New;
    CheckStatus _checkstatus = CheckStatus::IsNew;
    bool _notify = true;

    bool _integrity = true;
#endif
};



class CORE_EXPORT PostInitClass
{
public:
    PostInitClass(Core::PropertyContainer* p) : container(p){};
    ~PostInitClass();
    Core::PropertyContainer* container;
};

}  // namespace Core