kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Extensions: Make Python Integration work

Browse Source
This commit is contained in:
Stefan Tröger
2016-06-03 19:19:54 +02:00
committed by wmayer
parent 88484d7054
commit f0f31ff94c
19 changed files with 622 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files

251
src/App/Extension.cpp
View File

@@ -52,7 +52,6 @@ using namespace App;
Extension::Extension()
{
}
Extension::~Extension()
@@ -96,249 +95,9 @@ const char* Extension::name() {
return std::string().c_str();
}
namespace App {
PROPERTY_SOURCE_TEMPLATE(App::ExtensionPython, App::ExtensionPython::Inherited)
TYPESYSTEM_SOURCE(App::ExtensionContainer, App::PropertyContainer);
ExtensionContainer::ExtensionContainer() {
};
ExtensionContainer::~ExtensionContainer() {
};
void ExtensionContainer::registerExtension(Base::Type extension, Extension* ext) {
if(ext->getExtendedObject() != this)
throw Base::Exception("ExtensionContainer::registerExtension: Extension has not this as base object");
//no duplicate extensions (including base classes)
if(hasExtension(extension)) {
for(auto entry : _extensions) {
if(entry.first == extension || entry.first.isDerivedFrom(extension)) {
_extensions.erase(entry.first);
break;
}
}
}
_extensions[extension] = ext;
}
bool ExtensionContainer::hasExtension(Base::Type t) const {
//check for the exact type
bool found = _extensions.find(t) != _extensions.end();
if(!found) {
//and for types derived from it, as they can be cast to the extension
for(auto entry : _extensions) {
if(entry.first.isDerivedFrom(t))
return true;
}
return false;
}
return true;
}
bool ExtensionContainer::hasExtension(const char* name) const {
//and for types derived from it, as they can be cast to the extension
for(auto entry : _extensions) {
if(strcmp(entry.second->name(), name) == 0)
return true;
}
return false;
}
Extension* ExtensionContainer::getExtension(Base::Type t) {
auto result = _extensions.find(t);
if(result == _extensions.end()) {
//we need to check for derived types
for(auto entry : _extensions) {
if(entry.first.isDerivedFrom(t))
return entry.second;
}
//if we arive hear we don't have anything matching
throw Base::Exception("ExtensionContainer::getExtension: No extension of given type available");
}
return result->second;
}
Extension* ExtensionContainer::getExtension(const char* name) {
//and for types derived from it, as they can be cast to the extension
for(auto entry : _extensions) {
if(strcmp(entry.second->name(), name) == 0)
return entry.second;
}
return nullptr;
}
std::vector< Extension* > ExtensionContainer::getExtensionsDerivedFrom(Base::Type type) const {
std::vector<Extension*> vec;
//and for types derived from it, as they can be cast to the extension
for(auto entry : _extensions) {
if(entry.first.isDerivedFrom(type))
vec.push_back(entry.second);
}
return vec;
}
void ExtensionContainer::getPropertyList(std::vector< Property* >& List) const {
App::PropertyContainer::getPropertyList(List);
for(auto entry : _extensions) {
if(entry.second->isPythonExtension())
entry.second->getPropertyList(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);
}
}
Property* ExtensionContainer::getPropertyByName(const char* name) const {
auto prop = App::PropertyContainer::getPropertyByName(name);
if(prop)
return prop;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()){
auto prop = entry.second->getPropertyByName(name);
if(prop)
return prop;
}
}
return nullptr;
}
short int ExtensionContainer::getPropertyType(const Property* prop) const {
short int res = App::PropertyContainer::getPropertyType(prop);
if(res != 0)
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyType(prop);
if(res != 0)
return res;
}
}
return 0;
}
short int ExtensionContainer::getPropertyType(const char* name) const {
short int res = App::PropertyContainer::getPropertyType(name);
if(res != 0)
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyType(name);
if(res != 0)
return res;
}
}
return 0;
}
const char* ExtensionContainer::getPropertyName(const Property* prop) const {
const char* res = App::PropertyContainer::getPropertyName(prop);
if(res != 0)
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyName(prop);
if(res != 0)
return res;
}
}
return 0;
}
const char* ExtensionContainer::getPropertyGroup(const Property* prop) const {
const char* res = App::PropertyContainer::getPropertyGroup(prop);
if(res != 0)
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyGroup(prop);
if(res != 0)
return res;
}
}
return 0;
}
const char* ExtensionContainer::getPropertyGroup(const char* name) const {
const char* res = App::PropertyContainer::getPropertyGroup(name);
if(res != 0)
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyGroup(name);
if(res != 0)
return res;
}
}
return 0;
}
const char* ExtensionContainer::getPropertyDocumentation(const Property* prop) const {
const char* res = App::PropertyContainer::getPropertyDocumentation(prop);
if(res != 0)
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyDocumentation(prop);
if(res != 0)
return res;
}
}
return 0;
}
const char* ExtensionContainer::getPropertyDocumentation(const char* name) const {
const char* res = App::PropertyContainer::getPropertyDocumentation(name);
if(res != 0)
return res;
for(auto entry : _extensions) {
if(entry.second->isPythonExtension()) {
res = entry.second->getPropertyDocumentation(name);
if(res != 0)
return res;
}
}
return 0;
}
// explicit template instantiation
template class AppExport ExtensionPythonT<Extension>;
}