PropertyContainer.h

Go to the documentation of this file.

#pragma once
 
#include <Core/PropertyMacros.h>
#include <Core/DynamicProperty.h>
#include <Core/Property.h>
namespace Base { class AbstractWriter; }
namespace Base { class AbstractXMLReader; }
 
#define USE_PROPERTYMAP
 
constexpr const char* PropertyName = "Property";
 
class QFont;
 
 
namespace Core
{
class FieldData
{
public:
    FieldData(const Core::FieldData* /*fd*/){};
};
}  // namespace Core
 
namespace App
{
class ElementTool;
}
namespace Draw
{
}  // namespace Draw
namespace Geom
{
}
 
 
#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 DocObject;
class PropertyUser;
 
enum PropertyType
{
    Prop_None = 0,         
    Prop_ReadOnly = 1,     
    Prop_Transient = 2,    
    Prop_Hidden = 4,       
    Prop_Output = 8,       
    Prop_NoRecompute = 16, 
    Prop_NoPersist = 32,   
};
 
class LX_CORE_EXPORT LxFieldData
{
public:
    LxFieldData(void);
    LxFieldData(const LxFieldData* fd);
    void addField(void* base, const char* fieldname, void* fieldptr);
    std::unordered_map<std::string, ptrdiff_t> m_fieldmap;
    bool fieldsAdded = false;
};
 
 
 
class LX_CORE_EXPORT PropertyContainer : public Base::Persistence
{
    TYPESYSTEM_HEADER();
    LX_NODE_HEADER();
    MUTABLE_CONTAINER(Core::PropertyContainer);
 
public:
    friend class PostInitClass;
    friend class CoreDocument;
    friend class ObjectExecutor;
    friend class Property;
    friend class ::App::ElementTool;
 
    //                                                       //
    // --------------------- 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;
    virtual const char* getPropertyName(const Property* prop) const;
 
    template <typename T>
    T* getPropertyByName(const std::string& name) const
    {
        Core::Property* p = getPropertyByName(name);
 
        if (p && dynamic_cast<T*>(p))
        {
            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;
    void getLinkProperties(  std::vector<Core::Property*>& properties1,                           
                             std::vector<Core::Property*>& properties2,                           
                             std::vector<Core::Property*>& properties3) const;
    void getPropertiesByType(Base::Type type, std::vector<Core::Property*>& props) 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 std::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::vector<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 onPropertyStatusBitsChanged(const Property& /*prop*/, unsigned long /*oldStatus*/) {}
    virtual void save(Base::AbstractWriter& writer, Base::PersistenceVersion& version);
    virtual void restore(Base::AbstractXMLReader& reader, Base::PersistenceVersion& 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();
 
 
    virtual bool onChangedDebug( Core::Property* p );
 
    virtual void checkAfterOnDeleted();
    
 
protected:
    virtual void onBeforeChangeProperty(const Property* /*prop*/) {}
    virtual void onChangedProperty(const Property* /*prop*/) {}
    
    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();
    virtual void breakLinks();
 
    unsigned int getPropertyChangeStatus() const;
    unsigned int getLastPropertyChangeStatus() const;
    void setAllPropertiesValid();
    void setPropertyValues(const Core::PropertyValueMap& other);
    std::vector<Core::Property*> getPropertiesOrdered() const;
 
    virtual bool check_lx(const char* f, const char* n);
 
    // HPK: Do not use DynamicProperty. This is for
    // testing transactions only.
    virtual Core::Property* addDynamicProperty(const char* type,
                                               const char* name = 0,
                                               const char* group = 0,
                                               const char* doc = 0,
                                               short attr = 0,
                                               bool ro = false,
                                               bool hidden = false);
 
#ifndef SWIG
    DynamicProperty::PropData getDynamicPropertyData(const Property* prop) const;
#endif
 
    virtual bool removeDynamicProperty(const char* name);
    virtual std::vector<std::string> getDynamicPropertyNames() const;
    virtual Core::Property* getDynamicPropertyByName(const char* name) const;
 
 
 
    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::PersistenceVersion& version);
 
    
    void addChangedProperties(unsigned int propertiesflags);
 
private:
 
    unsigned int _changedProperties;
    unsigned int _lastChangedProperties;
 
    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;
    bool _notify = true;
 
    bool _integrity = true;
#endif
};
 
 
 
class LX_CORE_EXPORT PostInitClass
{
public:
    PostInitClass(Core::PropertyContainer* p) : container(p){};
    ~PostInitClass();
    Core::PropertyContainer* container;
};
 
}  // namespace Core