PropertyContainer.h

Go to the documentation of this file.

#pragma once

#include <Base/Persistence.h>
#include <Core/PropertyMacros.h>
#include <Core/PropertyValue.h>
#include <Core/DynamicProperty.h>
#include <Core/Variant.h>
#include <Geom/BrepData.h>

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

#define USE_PROPERTYMAP

static const char* PropertyName = "Property";

class PropertyTree;
class CA_Writer;
class QFont;
class MD5;



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;

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, 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 && 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 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;
    void setAllPropertiesValid();
    void setPropertyValues(const Core::PropertyValueMap& other);
    std::vector<Core::Property*> getPropertiesOrdered() const;

    virtual bool check_lx(char* f, 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);

    unsigned int _changedProperties;
    //DynamicProperty dynamicProps;

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;
    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