suzanne.soy/FreeCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Extension: Fix order-of-initialisation crash

Browse Source 
FreeCADs property system utilises some pointer math to calculate the offset between
property and base class. Due to virtual inheritance of th ePropertyContainer the memory
layout has been changed to rather random, which has lead to crashes dependend on the
order of object initialisation.

The solution is to not make PropertyContaner virtual but a class below, Base::Persitance.
Then the memory layout is random for Persistance, but it is perfectly aligned for the
base class chains from PropertyContainer onwards as well as from Extension onwards.
Hence the proeprty system was changed to take the offset always from those two.
This commit is contained in:
Stefan Tröger 2016-09-21 06:25:51 +02:00 committed by wmayer
parent 773c79d6b6
commit 22fa3b3922
31 changed files with 310 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/App/DocumentObjectExtension.cpp
View File

@ -33,7 +33,7 @@
using namespace App;
PROPERTY_SOURCE(App::DocumentObjectExtension, App::Extension)
EXTENSION_PROPERTY_SOURCE(App::DocumentObjectExtension, App::Extension)
DocumentObjectExtension::DocumentObjectExtension()
{

2
src/App/DocumentObjectExtension.h
View File

@ -38,7 +38,7 @@ class AppExport DocumentObjectExtension : public App::Extension
//The cass does not have properties itself, but it is important to provide the property access
//functions. see cpp file for details
PROPERTY_HEADER(App::DocumentObjectExtension );
EXTENSION_PROPERTY_HEADER(App::DocumentObjectExtension );
public:

2
src/App/DocumentObjectGroup.cpp
View File

@ -33,7 +33,7 @@
using namespace App;
PROPERTY_SOURCE_WITH_EXTENSIONS(App::DocumentObjectGroup, App::DocumentObject, (App::GroupExtension))
PROPERTY_SOURCE_WITH_EXTENSIONS(App::DocumentObjectGroup, App::DocumentObject)
DocumentObjectGroup::DocumentObjectGroup(void): DocumentObject(), GroupExtension() {

33
src/App/DynamicProperty.cpp
View File

@ -30,6 +30,7 @@
#include "Property.h"
#include "PropertyContainer.h"
#include "Application.h"
#include "ExtensionContainer.h"
#include <Base/Reader.h>
#include <Base/Writer.h>
#include <Base/Console.h>
@ -69,6 +70,10 @@ Property *DynamicProperty::getPropertyByName(const char* name) const
std::map<std::string,PropData>::const_iterator it = props.find(name);
if (it != props.end())
return it->second.property;
if(this->pc->isDerivedFrom(App::ExtensionContainer::getClassTypeId()))
return static_cast<App::ExtensionContainer*>(this->pc)->ExtensionContainer::getPropertyByName(name);
return this->pc->PropertyContainer::getPropertyByName(name);
}
@ -113,6 +118,10 @@ const char* DynamicProperty::getPropertyName(const Property* prop) const
if (it->second.property == prop)
return it->first.c_str();
}
if(this->pc->isDerivedFrom(App::ExtensionContainer::getClassTypeId()))
return static_cast<App::ExtensionContainer*>(this->pc)->ExtensionContainer::getPropertyName(prop);
return this->pc->PropertyContainer::getPropertyName(prop);
}
@ -139,6 +148,10 @@ short DynamicProperty::getPropertyType(const Property* prop) const
return attr;
}
}
if(this->pc->isDerivedFrom(App::ExtensionContainer::getClassTypeId()))
return static_cast<App::ExtensionContainer*>(this->pc)->ExtensionContainer::getPropertyType(prop);
return this->pc->PropertyContainer::getPropertyType(prop);
}
@ -153,6 +166,10 @@ short DynamicProperty::getPropertyType(const char *name) const
attr |= Prop_ReadOnly;
return attr;
}
if(this->pc->isDerivedFrom(App::ExtensionContainer::getClassTypeId()))
return static_cast<App::ExtensionContainer*>(this->pc)->ExtensionContainer::getPropertyType(name);
return this->pc->PropertyContainer::getPropertyType(name);
}
@ -162,6 +179,10 @@ const char* DynamicProperty::getPropertyGroup(const Property* prop) const
if (it->second.property == prop)
return it->second.group.c_str();
}
if(this->pc->isDerivedFrom(App::ExtensionContainer::getClassTypeId()))
return static_cast<App::ExtensionContainer*>(this->pc)->ExtensionContainer::getPropertyGroup(prop);
return this->pc->PropertyContainer::getPropertyGroup(prop);
}
@ -170,6 +191,10 @@ const char* DynamicProperty::getPropertyGroup(const char *name) const
std::map<std::string,PropData>::const_iterator it = props.find(name);
if (it != props.end())
return it->second.group.c_str();
if(this->pc->isDerivedFrom(App::ExtensionContainer::getClassTypeId()))
return static_cast<App::ExtensionContainer*>(this->pc)->ExtensionContainer::getPropertyGroup(name);
return this->pc->PropertyContainer::getPropertyGroup(name);
}
@ -179,6 +204,10 @@ const char* DynamicProperty::getPropertyDocumentation(const Property* prop) cons
if (it->second.property == prop)
return it->second.doc.c_str();
}
if(this->pc->isDerivedFrom(App::ExtensionContainer::getClassTypeId()))
return static_cast<App::ExtensionContainer*>(this->pc)->ExtensionContainer::getPropertyDocumentation(prop);
return this->pc->PropertyContainer::getPropertyDocumentation(prop);
}
@ -187,6 +216,10 @@ const char* DynamicProperty::getPropertyDocumentation(const char *name) const
std::map<std::string,PropData>::const_iterator it = props.find(name);
if (it != props.end())
return it->second.doc.c_str();
if(this->pc->isDerivedFrom(App::ExtensionContainer::getClassTypeId()))
return static_cast<App::ExtensionContainer*>(this->pc)->ExtensionContainer::getPropertyDocumentation(name);
return this->pc->PropertyContainer::getPropertyDocumentation(name);
}

78
src/App/Extension.cpp
View File

@ -34,19 +34,15 @@
#include <Base/Console.h>
#include <Base/PyObjectBase.h>
/* We do not use a standart property macro for type initiation. The reason is that we want to expose all property functions,
* to allow the derived classes to access the private property data, but we do not want to have our
* property data a reference to the parent data. That is because the extension is used in a multi
* inheritance way, and hence our propertydata partent data would point to the same property data
* as any other parent of the inherited class. It makes more sense to create a total unrelated line
* of property datas which are added as additional parent to the extended class.
/* We do not use a standart property macro for type initiation. The reason is that we have the first
* PropertyData in the extension chain, there is no parent property data.
*/
TYPESYSTEM_SOURCE_P(App::Extension);
const App::PropertyData * App::Extension::getPropertyDataPtr(void){return &propertyData;}
const App::PropertyData & App::Extension::getPropertyData(void) const{return propertyData;}
const App::PropertyData * App::Extension::extensionGetPropertyDataPtr(void){return &propertyData;}
const App::PropertyData & App::Extension::extensionGetPropertyData(void) const{return propertyData;}
App::PropertyData App::Extension::propertyData;
void App::Extension::init(void){
initSubclass(App::Extension::classTypeId, "App::Extension" , "App::PropertyContainer", &(App::Extension::create) );
initSubclass(App::Extension::classTypeId, "App::Extension" , "Base::Persistence", &(App::Extension::create) );
}
using namespace App;
@ -57,7 +53,6 @@ Extension::Extension()
Extension::~Extension()
{
Base::Console().Message("Delete extension\n");
if (!ExtensionPythonObject.is(Py::_None())){
// Remark: The API of Py::Object has been changed to set whether the wrapper owns the passed
// Python object or not. In the constructor we forced the wrapper to own the object so we need
@ -82,6 +77,13 @@ void Extension::initExtension(ExtensionContainer* obj) {
if(m_extensionType.isBad())
throw Base::Exception("Extension: Extension type not set");
//all properties are initialised without PropertyContainer father. Now that we know it we can
//finaly finsih the property initialisation
std::vector<Property*> list;
extensionGetPropertyData().getPropertyList(this, list);
for(Property* prop : list)
prop->setContainer(obj);
m_base = obj;
m_base->registerExtension( m_extensionType, this );
}
@ -106,8 +108,62 @@ const char* Extension::name() {
return std::string().c_str();
}
Property* Extension::extensionGetPropertyByName(const char* name) const {
return extensionGetPropertyData().getPropertyByName(this, name);
}
short int Extension::extensionGetPropertyType(const Property* prop) const {
return extensionGetPropertyData().getType(this, prop);
}
short int Extension::extensionGetPropertyType(const char* name) const {
return extensionGetPropertyData().getType(this, name);
}
const char* Extension::extensionGetPropertyName(const Property* prop) const {
return extensionGetPropertyData().getName(this,prop);
}
const char* Extension::extensionGetPropertyGroup(const Property* prop) const {
return extensionGetPropertyData().getGroup(this,prop);
}
const char* Extension::extensionGetPropertyGroup(const char* name) const {
return extensionGetPropertyData().getGroup(this,name);
}
const char* Extension::extensionGetPropertyDocumentation(const Property* prop) const {
return extensionGetPropertyData().getDocumentation(this, prop);
}
const char* Extension::extensionGetPropertyDocumentation(const char* name) const {
return extensionGetPropertyData().getDocumentation(this, name);
}
void Extension::extensionGetPropertyList(std::vector< Property* >& List) const {
extensionGetPropertyData().getPropertyList(this, List);
}
void Extension::extensionGetPropertyMap(std::map< std::string, Property* >& Map) const {
extensionGetPropertyData().getPropertyMap(this, Map);
}
namespace App {
PROPERTY_SOURCE_TEMPLATE(App::ExtensionPython, App::ExtensionPython::Inherited)
EXTENSION_PROPERTY_SOURCE_TEMPLATE(App::ExtensionPython, App::ExtensionPython::Inherited)
// explicit template instantiation
template class AppExport ExtensionPythonT<Extension>;

127
src/App/Extension.h
View File

@ -33,6 +33,35 @@ namespace App {
class ExtensionContainer;
// init property stuff
#define EXTENSION_PROPERTY_HEADER(_class_) \
TYPESYSTEM_HEADER(); \
protected: \
static const App::PropertyData * extensionGetPropertyDataPtr(void); \
virtual const App::PropertyData &extensionGetPropertyData(void) const; \
private: \
static App::PropertyData propertyData
#define EXTENSION_PROPERTY_SOURCE(_class_, _parentclass_) \
TYPESYSTEM_SOURCE_P(_class_);\
const App::PropertyData * _class_::extensionGetPropertyDataPtr(void){return &propertyData;} \
const App::PropertyData & _class_::extensionGetPropertyData(void) const{return propertyData;} \
App::PropertyData _class_::propertyData; \
void _class_::init(void){\
initSubclass(_class_::classTypeId, #_class_ , #_parentclass_, &(_class_::create) ); \
_class_::propertyData.addParentPropertyData(_parentclass_::extensionGetPropertyDataPtr());\
}
#define EXTENSION_PROPERTY_SOURCE_TEMPLATE(_class_, _parentclass_) \
TYPESYSTEM_SOURCE_TEMPLATE(_class_);\
template<> App::PropertyData _class_::propertyData = App::PropertyData(); \
template<> const App::PropertyData * _class_::extensionGetPropertyDataPtr(void){return &propertyData;} \
template<> const App::PropertyData & _class_::extensionGetPropertyData(void) const{return propertyData;} \
template<> void _class_::init(void){\
initSubclass(_class_::classTypeId, #_class_ , #_parentclass_, &(_class_::create) ); \
_class_::propertyData.addParentPropertyData(_parentclass_::extensionGetPropertyDataPtr());\
}
/**
* @brief Base class for all extension that can be added to a DocumentObject
*
@ -41,15 +70,22 @@ class ExtensionContainer;
*
* Extensions are like every other FreeCAD object and based on properties. All information storage
* and persistance should be achieved by use of those. Additional any number of methods can be
* added to provide funtionality around the proerties. The only difference to normal objects is that
* extensions must derive from the Extension class and that the tye needs to be initialised. This
* works as simple as
* added to provide funtionality around the properties. There are 3 samll difference to normal objects:
* 1. They must be derived from Extension class
* 2. Properties must be handled with special extension macros
* 3. Extensions must be initialised
* This works as simple as
* @code
* class MyExtension : public Extension {
* EXTENSION_PROPERTY_HEADER(MyExtension);
* PropertyInt MyProp;
* virtual bool overridableMethod(DocumentObject* obj) {};
* };
*
* EXTENSION_PROPERTY_SOURCE(App::MyExtension, App::Extension)
* MyExtension::MyExtension() {
*
* EXTENSION_ADD_PROPERTY(MyProp, (0)) *
* initExtension(MyExtension::getClassTypeId());
* }
* typedef ExtensionPythonT<MyExtension> MyExtensionPython;
@ -125,40 +161,79 @@ class ExtensionContainer;
* exension creators responsibility to ensure full implementation.
*
*/
class AppExport Extension : public virtual App::PropertyContainer
class AppExport Extension : public virtual Base::Persistence
{
//The cass does not have properties itself, but it is important to provide the property access
//functions. see cpp file for details
PROPERTY_HEADER(App::Extension);
//The cass does not have properties itself, but it is important to provide the property access
//functions. see cpp file for details
EXTENSION_PROPERTY_HEADER(App::Extension);
public:
Extension();
virtual ~Extension();
Extension();
virtual ~Extension();
void initExtension(App::ExtensionContainer* obj);
void initExtension(App::ExtensionContainer* obj);
App::ExtensionContainer* getExtendedContainer() {return m_base;};
const App::ExtensionContainer* getExtendedContainer() const {return m_base;};
App::ExtensionContainer* getExtendedContainer() {return m_base;};
const App::ExtensionContainer* getExtendedContainer() const {return m_base;};
//get extension name without namespace
const char* name();
bool isPythonExtension() {return m_isPythonExtension;};
//get extension name without namespace
const char* name();
bool isPythonExtension() {return m_isPythonExtension;};
virtual PyObject* getExtensionPyObject(void);
virtual PyObject* getExtensionPyObject(void);
/** @name Access properties */
//@{
/// find a property by its name
virtual Property *extensionGetPropertyByName(const char* name) const;
/// get the name of a property
virtual const char* extensionGetPropertyName(const Property* prop) const;
/// get all properties of the class (including properties of the parent)
virtual void extensionGetPropertyMap(std::map<std::string,Property*> &Map) const;
/// get all properties of the class (including properties of the parent)
virtual void extensionGetPropertyList(std::vector<Property*> &List) const;
/// get the Type of a Property
virtual short extensionGetPropertyType(const Property* prop) const;
/// get the Type of a named Property
virtual short extensionGetPropertyType(const char *name) const;
/// get the Group of a Property
virtual const char* extensionGetPropertyGroup(const Property* prop) const;
/// get the Group of a named Property
virtual const char* extensionGetPropertyGroup(const char *name) const;
/// get the Group of a Property
virtual const char* extensionGetPropertyDocumentation(const Property* prop) const;
/// get the Group of a named Property
virtual const char* extensionGetPropertyDocumentation(const char *name) const;
//@}
protected:
void initExtension(Base::Type type);
bool m_isPythonExtension = false;
Py::Object ExtensionPythonObject;
void initExtension(Base::Type type);
bool m_isPythonExtension = false;
Py::Object ExtensionPythonObject;
private:
Base::Type m_extensionType;
App::ExtensionContainer* m_base = nullptr;
Base::Type m_extensionType;
App::ExtensionContainer* m_base = nullptr;
};
// Property define
#define EXTENSION_ADD_PROPERTY(_prop_, _defaultval_) \
do { \
this->_prop_.setValue _defaultval_;\
propertyData.addProperty(static_cast<App::Extension*>(this), #_prop_, &this->_prop_); \
} while (0)
#define EXTENSION_ADD_PROPERTY_TYPE(_prop_, _defaultval_, _group_,_type_,_Docu_) \
do { \
this->_prop_.setValue _defaultval_;\
propertyData.addProperty(static_cast<App::Extension*>(this), #_prop_, &this->_prop_, (_group_),(_type_),(_Docu_)); \
} while (0)
/**
* Generic Python extension class which allows to behave every extension
@ -167,7 +242,7 @@ private:
template <class ExtensionT>
class ExtensionPythonT : public ExtensionT
{
PROPERTY_HEADER(App::ExtensionPythonT<ExtensionT>);
EXTENSION_PROPERTY_HEADER(App::ExtensionPythonT<ExtensionT>);
public:
typedef ExtensionT Inherited;
@ -175,7 +250,7 @@ public:
ExtensionPythonT() {
ExtensionT::m_isPythonExtension = true;
ADD_PROPERTY(ExtensionProxy,(Py::Object()));
EXTENSION_ADD_PROPERTY(ExtensionProxy,(Py::Object()));
}
virtual ~ExtensionPythonT() {
}
@ -185,12 +260,12 @@ public:
typedef ExtensionPythonT<App::Extension> ExtensionPython;
//helper macros to define python extensions
// Helper macros to define python extensions
#define EXTENSION_PROXY_FIRST(function) \
Base::PyGILStateLocker lock;\
Py::Object result;\
try {\
Property* proxy = this->getPropertyByName("ExtensionProxy");\
Property* proxy = this->extensionGetPropertyByName("ExtensionProxy");\
if (proxy && proxy->getTypeId() == PropertyPythonObject::getClassTypeId()) {\
Py::Object feature = static_cast<PropertyPythonObject*>(proxy)->getValue();\
if (feature.hasAttr(std::string("function"))) {\

78
src/App/ExtensionContainer.cpp
View File

@ -133,18 +133,14 @@ std::vector< Extension* > ExtensionContainer::getExtensionsDerivedFrom(Base::Typ
void ExtensionContainer::getPropertyList(std::vector< Property* >& List) const {
App::PropertyContainer::getPropertyList(List);
for(auto entry : _extensions) {
if(entry.second->isPythonExtension())
entry.second->getPropertyList(List);
}
for(auto entry : _extensions)
entry.second->extensionGetPropertyList(List);
}
void ExtensionContainer::getPropertyMap(std::map< std::string, Property* >& Map) const {
App::PropertyContainer::getPropertyMap(Map);
for(auto entry : _extensions) {
if(entry.second->isPythonExtension())
entry.second->getPropertyMap(Map);
}
for(auto entry : _extensions)
entry.second->extensionGetPropertyMap(Map);
}
Property* ExtensionContainer::getPropertyByName(const char* name) const {
@ -153,11 +149,9 @@ Property* ExtensionContainer::getPropertyByName(const char* name) const {
return prop;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()){
auto prop = entry.second->getPropertyByName(name);
if(prop)
return prop;
}
auto prop = entry.second->extensionGetPropertyByName(name);
if(prop)
return prop;
}
return nullptr;
@ -170,11 +164,9 @@ short int ExtensionContainer::getPropertyType(const Property* prop) const {
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyType(prop);
if(res != 0)
return res;
}
res = entry.second->extensionGetPropertyType(prop);
if(res != 0)
return res;
}
return 0;
@ -187,11 +179,9 @@ short int ExtensionContainer::getPropertyType(const char* name) const {
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyType(name);
if(res != 0)
return res;
}
res = entry.second->extensionGetPropertyType(name);
if(res != 0)
return res;
}
return 0;
@ -205,11 +195,9 @@ const char* ExtensionContainer::getPropertyName(const Property* prop) const {
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyName(prop);
if(res != 0)
return res;
}
res = entry.second->extensionGetPropertyName(prop);
if(res != 0)
return res;
}
return 0;
@ -222,11 +210,9 @@ const char* ExtensionContainer::getPropertyGroup(const Property* prop) const {
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyGroup(prop);
if(res != 0)
return res;
}
res = entry.second->extensionGetPropertyGroup(prop);
if(res != 0)
return res;
}
return 0;
@ -239,11 +225,9 @@ const char* ExtensionContainer::getPropertyGroup(const char* name) const {
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyGroup(name);
if(res != 0)
return res;
}
res = entry.second->extensionGetPropertyGroup(name);
if(res != 0)
return res;
}
return 0;
@ -257,11 +241,9 @@ const char* ExtensionContainer::getPropertyDocumentation(const Property* prop) c
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyDocumentation(prop);
if(res != 0)
return res;
}
res = entry.second->extensionGetPropertyDocumentation(prop);
if(res != 0)
return res;
}
return 0;
@ -274,11 +256,9 @@ const char* ExtensionContainer::getPropertyDocumentation(const char* name) const
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyDocumentation(name);
if(res != 0)
return res;
}
res = entry.second->extensionGetPropertyDocumentation(name);
if(res != 0)
return res;
}
return 0;
@ -294,7 +274,7 @@ void ExtensionContainer::onChanged(const Property* prop) {
//if a extension gets registered from python. This is only for synchronisation.
if(strcmp(prop->getName(), "Proxy")) {
for(auto entry : _extensions)
entry.second->getExtensionPyObject().setValue(static_cast<const PropertyPythonObject*>(prop)->getValue());
entry.second->extensionGetExtensionPyObject().setValue(static_cast<const PropertyPythonObject*>(prop)->getValue());
}*/
App::PropertyContainer::onChanged(prop);

26
src/App/ExtensionContainer.h
View File

@ -30,8 +30,6 @@
#include "DynamicProperty.h"
#include <CXX/Objects.hxx>
#include <boost/preprocessor/seq/for_each.hpp>
namespace App {
/**
@ -73,14 +71,18 @@ namespace App {
* access the universal extension API. As DocumentObject itself derives from ExtensionContainer this
* should be the case automatically in most circumstances.
*
* Note that a small boilerplate change is needed next to the multiple inheritance when adding
* extensions from c++. It must be ensured that the type registration is aware of the extensions.
* Note that two small boilerplate changes are needed next to the multiple inheritance when adding
* extensions from c++.
* 1. It must be ensured that the property and type registration is aware of the extensions by using
* special macros.
* 2. The extensions need to be initialised in the constructor
*
* Here a working example:
* @code
* class AppExport Part : public App::DocumentObject, public App::FirstExtension, public App::SecondExtension {
* PROPERTY_HEADER_WITH_EXTENSIONS(App::Part);
* };
* PROPERTY_SOURCE_WITH_EXTENSIONS(App::Part, App::DocumentObject, (App::FirstExtension)(App::SecondExtension))
* PROPERTY_SOURCE_WITH_EXTENSIONS(App::Part, App::DocumentObject)
* Part::Part(void) {
* FirstExtension::initExtension(this);
* SecondExtension::initExtension(this);
@ -107,7 +109,7 @@ namespace App {
*
* For information on howto create extension see the documentation of Extension
*/
class AppExport ExtensionContainer : public virtual App::PropertyContainer
class AppExport ExtensionContainer : public App::PropertyContainer
{
TYPESYSTEM_HEADER();
@ -179,24 +181,18 @@ private:
std::map<Base::Type, App::Extension*> _extensions;
};
#define PROPERTY_HEADER_WITH_EXTENSIONS(_class_) \
PROPERTY_HEADER(_class)
//helper macro to add parent to property data
#define ADD_PARENT(r, data, elem)\
data::propertyData.parentPropertyData.push_back(elem::getPropertyDataPtr());
///
#define PROPERTY_SOURCE_WITH_EXTENSIONS(_class_, _parentclass_, _extensions_) \
/// We make sur that the PropertyData of the container is not connected to the one of the extension
#define PROPERTY_SOURCE_WITH_EXTENSIONS(_class_, _parentclass_) \
TYPESYSTEM_SOURCE_P(_class_);\
const App::PropertyData * _class_::getPropertyDataPtr(void){return &propertyData;} \
const App::PropertyData & _class_::getPropertyData(void) const{return propertyData;} \
App::PropertyData _class_::propertyData; \
void _class_::init(void){\
initSubclass(_class_::classTypeId, #_class_ , #_parentclass_, &(_class_::create) ); \
ADD_PARENT(0, _class_, _parentclass_)\
BOOST_PP_SEQ_FOR_EACH(ADD_PARENT, _class_, _extensions_)\
_class_::propertyData.addParentPropertyData(_parentclass_::getPropertyDataPtr());\
}
} //App

2
src/App/ExtensionContainerPyImp.cpp
View File

@ -152,7 +152,7 @@ PyObject* ExtensionContainerPy::addExtension(PyObject *args) {
ext->initExtension(getExtensionContainerPtr());
//set the proxy to allow python overrides
App::Property* pp = ext->getPropertyByName("ExtensionProxy");
App::Property* pp = ext->extensionGetPropertyByName("ExtensionProxy");
if(!pp) {
std::stringstream str;
str << "Accessing the proxy property failed!" << std::ends;

6
src/App/GeoFeatureGroupExtension.cpp
View File

@ -36,7 +36,7 @@
using namespace App;
PROPERTY_SOURCE(App::GeoFeatureGroupExtension, App::GroupExtension)
EXTENSION_PROPERTY_SOURCE(App::GeoFeatureGroupExtension, App::GroupExtension)
//===========================================================================
@ -47,7 +47,7 @@ GeoFeatureGroupExtension::GeoFeatureGroupExtension(void)
{
initExtension(GeoFeatureGroupExtension::getClassTypeId());
ADD_PROPERTY(Placement,(Base::Placement()));
EXTENSION_ADD_PROPERTY(Placement,(Base::Placement()));
}
GeoFeatureGroupExtension::~GeoFeatureGroupExtension(void)
@ -148,7 +148,7 @@ DocumentObject* GeoFeatureGroupExtension::getGroupOfObject(const DocumentObject*
// Python feature ---------------------------------------------------------
namespace App {
PROPERTY_SOURCE_TEMPLATE(App::GeoFeatureGroupExtensionPython, App::GeoFeatureGroupExtension)
EXTENSION_PROPERTY_SOURCE_TEMPLATE(App::GeoFeatureGroupExtensionPython, App::GeoFeatureGroupExtension)
// explicit template instantiation
template class AppExport ExtensionPythonT<GroupExtensionPythonT<GeoFeatureGroupExtension>>;

2
src/App/GeoFeatureGroupExtension.h
View File

@ -38,7 +38,7 @@ namespace App
*/
class AppExport GeoFeatureGroupExtension : public App::GroupExtension
{
PROPERTY_HEADER(App::GeoFeatureGroupExtension);
EXTENSION_PROPERTY_HEADER(App::GeoFeatureGroupExtension);
public:
PropertyPlacement Placement;

6
src/App/GroupExtension.cpp
View File

@ -34,13 +34,13 @@
using namespace App;
PROPERTY_SOURCE(App::GroupExtension, App::DocumentObjectExtension)
EXTENSION_PROPERTY_SOURCE(App::GroupExtension, App::DocumentObjectExtension)
GroupExtension::GroupExtension()
{
initExtension(GroupExtension::getClassTypeId());
ADD_PROPERTY_TYPE(Group,(0),"Base",(App::PropertyType)(Prop_Output),"List of referenced objects");
EXTENSION_ADD_PROPERTY_TYPE(Group,(0),"Base",(App::PropertyType)(Prop_Output),"List of referenced objects");
}
GroupExtension::~GroupExtension()
@ -202,7 +202,7 @@ PyObject* GroupExtension::getExtensionPyObject(void) {
namespace App {
PROPERTY_SOURCE_TEMPLATE(App::GroupExtensionPython, App::GroupExtension)
EXTENSION_PROPERTY_SOURCE_TEMPLATE(App::GroupExtensionPython, App::GroupExtension)
// explicit template instantiation
template class AppExport ExtensionPythonT<GroupExtensionPythonT<GroupExtension>>;

2
src/App/GroupExtension.h
View File

@ -37,7 +37,7 @@ class GroupExtensionPy;
class AppExport GroupExtension : public DocumentObjectExtension
{
PROPERTY_HEADER(App::GroupExtension);
EXTENSION_PROPERTY_HEADER(App::GroupExtension);
public:
/// Constructor

6
src/App/OriginGroupExtension.cpp
View File

@ -35,13 +35,13 @@
using namespace App;
PROPERTY_SOURCE(App::OriginGroupExtension, App::GeoFeatureGroupExtension);
EXTENSION_PROPERTY_SOURCE(App::OriginGroupExtension, App::GeoFeatureGroupExtension);
OriginGroupExtension::OriginGroupExtension () {
initExtension(OriginGroupExtension::getClassTypeId());
ADD_PROPERTY_TYPE ( Origin, (0), 0, App::Prop_Hidden, "Origin linked to the group" );
EXTENSION_ADD_PROPERTY_TYPE ( Origin, (0), 0, App::Prop_Hidden, "Origin linked to the group" );
}
OriginGroupExtension::~OriginGroupExtension ()
@ -131,7 +131,7 @@ void OriginGroupExtension::onExtendedUnsetupObject () {
// Python feature ---------------------------------------------------------
namespace App {
PROPERTY_SOURCE_TEMPLATE(App::OriginGroupExtensionPython, App::OriginGroupExtension)
EXTENSION_PROPERTY_SOURCE_TEMPLATE(App::OriginGroupExtensionPython, App::OriginGroupExtension)
// explicit template instantiation
template class AppExport ExtensionPythonT<GroupExtensionPythonT<OriginGroupExtension>>;

3
src/App/OriginGroupExtension.h
View File

@ -34,7 +34,8 @@ class Origin;
*/
class AppExport OriginGroupExtension : public App::GeoFeatureGroupExtension
{
PROPERTY_HEADER(App::OriginGroupExtension);
EXTENSION_PROPERTY_HEADER(App::OriginGroupExtension);
public:
OriginGroupExtension ();
virtual ~OriginGroupExtension ();

2
src/App/Part.cpp
View File

@ -35,7 +35,7 @@
using namespace App;
PROPERTY_SOURCE_WITH_EXTENSIONS(App::Part, App::DocumentObject, (App::OriginGroupExtension))
PROPERTY_SOURCE_WITH_EXTENSIONS(App::Part, App::DocumentObject)
//===========================================================================

28
src/App/PropertyContainer.cpp
View File

@ -259,7 +259,7 @@ void PropertyContainer::Restore(Base::XMLReader &reader)
reader.readEndElement("Properties");
}
void PropertyData::addProperty(const PropertyContainer *container,const char* PropName, Property *Prop, const char* PropertyGroup , PropertyType Type, const char* PropertyDocu)
void PropertyData::addProperty(const void* container,const char* PropName, Property *Prop, const char* PropertyGroup , PropertyType Type, const char* PropertyDocu)
{
bool IsIn = false;
for (vector<PropertySpec>::const_iterator It = propertyData.begin(); It != propertyData.end(); ++It)
@ -285,7 +285,7 @@ void PropertyData::addParentPropertyData(const PropertyData* data) {
}
const PropertyData::PropertySpec *PropertyData::findProperty(const PropertyContainer *container,const char* PropName) const
const PropertyData::PropertySpec *PropertyData::findProperty(const void* container,const char* PropName) const
{
for (vector<PropertyData::PropertySpec>::const_iterator It = propertyData.begin(); It != propertyData.end(); ++It)
if(strcmp(It->Name,PropName)==0)
@ -300,13 +300,13 @@ const PropertyData::PropertySpec *PropertyData::findProperty(const PropertyConta
return 0;
}
const PropertyData::PropertySpec *PropertyData::findProperty(const PropertyContainer *container,const Property* prop) const
const PropertyData::PropertySpec *PropertyData::findProperty(const void* container,const Property* prop) const
{
const int diff = (int) ((char*)prop - (char*)container);
for (vector<PropertyData::PropertySpec>::const_iterator It = propertyData.begin(); It != propertyData.end(); ++It)
if(diff == It->Offset)
return &(*It);
return &(*It);
for(auto data : parentPropertyData) {
auto res = data->findProperty(container,prop);
@ -317,7 +317,7 @@ const PropertyData::PropertySpec *PropertyData::findProperty(const PropertyConta
return 0;
}
const char* PropertyData::getName(const PropertyContainer *container,const Property* prop) const
const char* PropertyData::getName(const void* container,const Property* prop) const
{
const PropertyData::PropertySpec* Spec = findProperty(container,prop);
@ -338,7 +338,7 @@ const char* PropertyData::getName(const PropertyContainer *container,const Prope
*/
}
short PropertyData::getType(const PropertyContainer *container,const Property* prop) const
short PropertyData::getType(const void* container,const Property* prop) const
{
const PropertyData::PropertySpec* Spec = findProperty(container,prop);
@ -361,7 +361,7 @@ short PropertyData::getType(const PropertyContainer *container,const Property* p
*/
}
short PropertyData::getType(const PropertyContainer *container,const char* name) const
short PropertyData::getType(const void* container,const char* name) const
{
const PropertyData::PropertySpec* Spec = findProperty(container,name);
@ -371,7 +371,7 @@ short PropertyData::getType(const PropertyContainer *container,const char* name)
return 0;
}
const char* PropertyData::getGroup(const PropertyContainer *container,const Property* prop) const
const char* PropertyData::getGroup(const void* container,const Property* prop) const
{
const PropertyData::PropertySpec* Spec = findProperty(container,prop);
@ -394,7 +394,7 @@ const char* PropertyData::getGroup(const PropertyContainer *container,const Prop
*/
}
const char* PropertyData::getGroup(const PropertyContainer *container,const char* name) const
const char* PropertyData::getGroup(const void* container,const char* name) const
{
const PropertyData::PropertySpec* Spec = findProperty(container,name);
@ -404,7 +404,7 @@ const char* PropertyData::getGroup(const PropertyContainer *container,const char
return 0;
}
const char* PropertyData::getDocumentation(const PropertyContainer *container,const Property* prop) const
const char* PropertyData::getDocumentation(const void* container,const Property* prop) const
{
const PropertyData::PropertySpec* Spec = findProperty(container,prop);
@ -414,7 +414,7 @@ const char* PropertyData::getDocumentation(const PropertyContainer *container,co
return 0;
}
const char* PropertyData::getDocumentation(const PropertyContainer *container,const char* name) const
const char* PropertyData::getDocumentation(const void* container,const char* name) const
{
const PropertyData::PropertySpec* Spec = findProperty(container,name);
@ -426,7 +426,7 @@ const char* PropertyData::getDocumentation(const PropertyContainer *container,co
Property *PropertyData::getPropertyByName(const PropertyContainer *container,const char* name) const
Property *PropertyData::getPropertyByName(const void* container,const char* name) const
{
const PropertyData::PropertySpec* Spec = findProperty(container,name);
@ -449,7 +449,7 @@ Property *PropertyData::getPropertyByName(const PropertyContainer *container,con
}*/
}
void PropertyData::getPropertyMap(const PropertyContainer *container,std::map<std::string,Property*> &Map) const
void PropertyData::getPropertyMap(const void* container,std::map<std::string,Property*> &Map) const
{
for (vector<PropertyData::PropertySpec>::const_iterator It = propertyData.begin(); It != propertyData.end(); ++It)
Map[It->Name] = (Property *) (It->Offset + (char *)container);
@ -467,7 +467,7 @@ void PropertyData::getPropertyMap(const PropertyContainer *container,std::map<st
}
void PropertyData::getPropertyList(const PropertyContainer *container,std::vector<Property*> &List) const
void PropertyData::getPropertyList(const void* container,std::vector<Property*> &List) const
{
for (vector<PropertyData::PropertySpec>::const_iterator It = propertyData.begin(); It != propertyData.end(); ++It)
List.push_back((Property *) (It->Offset + (char *)container) );

32
src/App/PropertyContainer.h
View File

@ -60,29 +60,29 @@ struct AppExport PropertyData
std::vector<PropertySpec> propertyData;
std::vector<const PropertyData*> parentPropertyData;
void addProperty(const PropertyContainer *container,const char* PropName, Property *Prop, const char* PropertyGroup= 0, PropertyType = Prop_None, const char* PropertyDocu= 0 );
void addProperty(const void* container,const char* PropName, Property *Prop, const char* PropertyGroup= 0, PropertyType = Prop_None, const char* PropertyDocu= 0 );
void addParentPropertyData(const PropertyData* data);
const PropertySpec *findProperty(const PropertyContainer *container,const char* PropName) const;
const PropertySpec *findProperty(const PropertyContainer *container,const Property* prop) const;
const PropertySpec *findProperty(const void* container,const char* PropName) const;
const PropertySpec *findProperty(const void* container,const Property* prop) const;
const char* getName (const PropertyContainer *container,const Property* prop) const;
short getType (const PropertyContainer *container,const Property* prop) const;
short getType (const PropertyContainer *container,const char* name) const;
const char* getGroup (const PropertyContainer *container,const char* name) const;
const char* getGroup (const PropertyContainer *container,const Property* prop) const;
const char* getDocumentation(const PropertyContainer *container,const char* name) const;
const char* getDocumentation(const PropertyContainer *container,const Property* prop) const;
const char* getName (const void* container,const Property* prop) const;
short getType (const void* container,const Property* prop) const;
short getType (const void* container,const char* name) const;
const char* getGroup (const void* container,const char* name) const;
const char* getGroup (const void* container,const Property* prop) const;
const char* getDocumentation(const void* container,const char* name) const;
const char* getDocumentation(const void* container,const Property* prop) const;
Property *getPropertyByName(const PropertyContainer *container,const char* name) const;
void getPropertyMap(const PropertyContainer *container,std::map<std::string,Property*> &Map) const;
void getPropertyList(const PropertyContainer *container,std::vector<Property*> &List) const;
Property *getPropertyByName(const void* container,const char* name) const;
void getPropertyMap(const void* container,std::map<std::string,Property*> &Map) const;
void getPropertyList(const void* container,std::vector<Property*> &List) const;
};
/** Base class of all classes with properties
*/
class AppExport PropertyContainer: public Base::Persistence
class AppExport PropertyContainer: public virtual Base::Persistence
{
TYPESYSTEM_HEADER();
@ -191,14 +191,14 @@ private:
do { \
this->_prop_.setValue _defaultval_;\
this->_prop_.setContainer(this); \
propertyData.addProperty(this, #_prop_, &this->_prop_); \
propertyData.addProperty(static_cast<App::PropertyContainer*>(this), #_prop_, &this->_prop_); \
} while (0)
#define ADD_PROPERTY_TYPE(_prop_, _defaultval_, _group_,_type_,_Docu_) \
do { \
this->_prop_.setValue _defaultval_;\
this->_prop_.setContainer(this); \
propertyData.addProperty(this, #_prop_, &this->_prop_, (_group_),(_type_),(_Docu_)); \
propertyData.addProperty(static_cast<App::PropertyContainer*>(this), #_prop_, &this->_prop_, (_group_),(_type_),(_Docu_)); \
} while (0)

6
src/Base/Persistence.h
View File

@ -48,7 +48,7 @@ public:
* It is not meant to have the exact size, it is more or less an estimation
* which runs fast! Is it two bytes or a GB?
*/
virtual unsigned int getMemSize (void) const = 0;
virtual unsigned int getMemSize (void) const;
/** This method is used to save properties to an XML document.
* A good example you'll find in PropertyStandard.cpp, e.g. the vector:
* \code
@ -65,7 +65,7 @@ public:
* is written. This means closing tags and writing UTF-8.
* @see Base::Writer
*/
virtual void Save (Writer &/*writer*/) const = 0;
virtual void Save (Writer &/*writer*/) const;
/** This method is used to restore properties from an XML document.
* It uses the XMLReader class, which bases on SAX, to read the in Save()
* written information. Again the Vector as an example:
@ -81,7 +81,7 @@ public:
* }
* \endcode
*/
virtual void Restore(XMLReader &/*reader*/) = 0;
virtual void Restore(XMLReader &/*reader*/);
/** This method is used to save large amounts of data to a binary file.
* Sometimes it makes no sense to write property data as XML. In case the
* amount of data is too big or the data type has a more effective way to

2
src/Gui/ViewProviderDocumentObjectGroup.cpp
View File

@ -47,7 +47,7 @@
using namespace Gui;
PROPERTY_SOURCE_WITH_EXTENSIONS(Gui::ViewProviderDocumentObjectGroup, Gui::ViewProviderDocumentObject, (Gui::ViewProviderGroupExtension))
PROPERTY_SOURCE_WITH_EXTENSIONS(Gui::ViewProviderDocumentObjectGroup, Gui::ViewProviderDocumentObject)
/**

4
src/Gui/ViewProviderExtension.cpp
View File

@ -33,7 +33,7 @@
using namespace Gui;
PROPERTY_SOURCE(Gui::ViewProviderExtension, App::Extension)
EXTENSION_PROPERTY_SOURCE(Gui::ViewProviderExtension, App::Extension)
ViewProviderExtension::ViewProviderExtension()
{
@ -62,7 +62,7 @@ void ViewProviderExtension::extensionUpdateData(const App::Property*) {
}
namespace Gui {
PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderExtensionPython, Gui::ViewProviderExtension)
EXTENSION_PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderExtensionPython, Gui::ViewProviderExtension)
// explicit template instantiation
template class GuiExport ViewProviderExtensionPythonT<ViewProviderExtension>;

6
src/Gui/ViewProviderExtension.h
View File

@ -39,7 +39,7 @@ class GuiExport ViewProviderExtension : public App::Extension
//The cass does not have properties itself, but it is important to provide the property access
//functions.
PROPERTY_HEADER(Gui::ViewProviderExtension);
EXTENSION_PROPERTY_HEADER(Gui::ViewProviderExtension);
public:
@ -90,7 +90,7 @@ private:
template <class ExtensionT>
class ViewProviderExtensionPythonT : public ExtensionT
{
PROPERTY_HEADER(Gui::ViewProviderExtensionPythonT<ExtensionT>);
EXTENSION_PROPERTY_HEADER(Gui::ViewProviderExtensionPythonT<ExtensionT>);
public:
typedef ExtensionT Inherited;
@ -98,7 +98,7 @@ public:
ViewProviderExtensionPythonT() {
ExtensionT::m_isPythonExtension = true;
ADD_PROPERTY(Proxy,(Py::Object()));
EXTENSION_ADD_PROPERTY(Proxy,(Py::Object()));
}
virtual ~ViewProviderExtensionPythonT() {
}

2
src/Gui/ViewProviderGeoFeatureGroup.cpp
View File

@ -36,7 +36,7 @@
using namespace Gui;
PROPERTY_SOURCE_WITH_EXTENSIONS(Gui::ViewProviderGeoFeatureGroup, Gui::ViewProviderDocumentObject, (Gui::ViewProviderGeoFeatureGroupExtension))
PROPERTY_SOURCE_WITH_EXTENSIONS(Gui::ViewProviderGeoFeatureGroup, Gui::ViewProviderDocumentObject)
ViewProviderGeoFeatureGroup::ViewProviderGeoFeatureGroup()
{

4
src/Gui/ViewProviderGeoFeatureGroupExtension.cpp
View File

@ -34,7 +34,7 @@
using namespace Gui;
PROPERTY_SOURCE(Gui::ViewProviderGeoFeatureGroupExtension, Gui::ViewProviderGroupExtension)
EXTENSION_PROPERTY_SOURCE(Gui::ViewProviderGeoFeatureGroupExtension, Gui::ViewProviderGroupExtension)
ViewProviderGeoFeatureGroupExtension::ViewProviderGeoFeatureGroupExtension()
{
@ -93,7 +93,7 @@ void ViewProviderGeoFeatureGroupExtension::extensionUpdateData(const App::Proper
namespace Gui {
PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderGeoFeatureGroupExtensionPython, Gui::ViewProviderGeoFeatureGroupExtension)
EXTENSION_PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderGeoFeatureGroupExtensionPython, Gui::ViewProviderGeoFeatureGroupExtension)
// explicit template instantiation
template class GuiExport ViewProviderExtensionPythonT<ViewProviderGeoFeatureGroupExtension>;

2
src/Gui/ViewProviderGeoFeatureGroupExtension.h
View File

@ -34,7 +34,7 @@ namespace Gui
class GuiExport ViewProviderGeoFeatureGroupExtension : public ViewProviderGroupExtension
{
PROPERTY_HEADER(Gui::ViewProviderGeoFeatureGroupExtension);
EXTENSION_PROPERTY_HEADER(Gui::ViewProviderGeoFeatureGroupExtension);
public:
/// Constructor

4
src/Gui/ViewProviderGroupExtension.cpp
View File

@ -40,7 +40,7 @@
using namespace Gui;
PROPERTY_SOURCE(Gui::ViewProviderGroupExtension, Gui::ViewProviderExtension)
EXTENSION_PROPERTY_SOURCE(Gui::ViewProviderGroupExtension, Gui::ViewProviderExtension)
ViewProviderGroupExtension::ViewProviderGroupExtension() : visible(false)
{
@ -199,7 +199,7 @@ bool ViewProviderGroupExtension::extensionOnDelete(const std::vector< std::strin
namespace Gui {
PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderGroupExtensionPython, Gui::ViewProviderGroupExtension)
EXTENSION_PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderGroupExtensionPython, Gui::ViewProviderGroupExtension)
// explicit template instantiation
template class GuiExport ViewProviderExtensionPythonT<ViewProviderGroupExtension>;

2
src/Gui/ViewProviderGroupExtension.h
View File

@ -32,7 +32,7 @@ namespace Gui
class GuiExport ViewProviderGroupExtension : public ViewProviderExtension
{
PROPERTY_HEADER(Gui::ViewProviderGroupExtension);
EXTENSION_PROPERTY_HEADER(Gui::ViewProviderGroupExtension);
public:
/// Constructor

2
src/Gui/ViewProviderOriginGroup.cpp
View File

@ -45,7 +45,7 @@
using namespace Gui;
PROPERTY_SOURCE_WITH_EXTENSIONS(Gui::ViewProviderOriginGroup, Gui::ViewProviderDocumentObject, (Gui::ViewProviderOriginGroupExtension))
PROPERTY_SOURCE_WITH_EXTENSIONS(Gui::ViewProviderOriginGroup, Gui::ViewProviderDocumentObject)
ViewProviderOriginGroup::ViewProviderOriginGroup ()
{

4
src/Gui/ViewProviderOriginGroupExtension.cpp
View File

@ -44,7 +44,7 @@
using namespace Gui;
PROPERTY_SOURCE(Gui::ViewProviderOriginGroupExtension, Gui::ViewProviderGeoFeatureGroupExtension)
EXTENSION_PROPERTY_SOURCE(Gui::ViewProviderOriginGroupExtension, Gui::ViewProviderGeoFeatureGroupExtension)
ViewProviderOriginGroupExtension::ViewProviderOriginGroupExtension()
{
@ -198,7 +198,7 @@ void ViewProviderOriginGroupExtension::updateOriginSize () {
namespace Gui {
PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderOriginGroupExtensionPython, Gui::ViewProviderOriginGroupExtension)
EXTENSION_PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderOriginGroupExtensionPython, Gui::ViewProviderOriginGroupExtension)
// explicit template instantiation
template class GuiExport ViewProviderExtensionPythonT<ViewProviderOriginGroupExtension>;

2
src/Gui/ViewProviderOriginGroupExtension.h
View File

@ -33,7 +33,7 @@ namespace Gui
class GuiExport ViewProviderOriginGroupExtension : public ViewProviderGeoFeatureGroupExtension
{
PROPERTY_HEADER(Gui::ViewProviderOriginGroupExtension);
EXTENSION_PROPERTY_HEADER(Gui::ViewProviderOriginGroupExtension);
public:
/// Constructor

2
src/Gui/ViewProviderPart.cpp
View File

@ -43,7 +43,7 @@
using namespace Gui;
PROPERTY_SOURCE_WITH_EXTENSIONS(Gui::ViewProviderPart, Gui::ViewProviderDocumentObject, (Gui::ViewProviderOriginGroupExtension))
PROPERTY_SOURCE_WITH_EXTENSIONS(Gui::ViewProviderPart, Gui::ViewProviderDocumentObject)
/**