Method restoreExtensions

src/App/ExtensionContainer.cpp:420–487

}

void ExtensionContainer::restoreExtensions(Base::XMLReader& reader)
{

    // Dynamic extensions are optional (also because they are introduced late into the document
    // format) and hence it is possible that the element does not exist. As we cannot check for the
    // existence of an element a object attribute is set if extensions are available. Here we check
    // that attribute, and only if it exists the extensions element will be available.
    if (!reader.hasAttribute("Extensions")) {
        return;
    }

    reader.readElement("Extensions");
    int Cnt = reader.getAttribute<long>("Count");

    for (int i = 0; i < Cnt; i++) {
        reader.readElement("Extension");
        const char* Type = reader.getAttribute<const char*>("type");
        const char* Name = reader.getAttribute<const char*>("name");
        try {
            App::Extension* ext = getExtension(Name);
            if (!ext) {
                // get the extension type asked for
                Base::Type extension = Base::Type::fromName(Type);
                if (extension.isBad()
                    || !extension.isDerivedFrom(App::Extension::getExtensionClassTypeId())) {
                    std::stringstream str;
                    str << "No extension found of type '" << Type << "'" << std::ends;
                    throw Base::TypeError(str.str());
                }

                // register the extension
                ext = static_cast<App::Extension*>(extension.createInstance());
                // check if this really is a python extension!
                if (!ext->isPythonExtension()) {
                    delete ext;
                    std::stringstream str;
                    str << "Extension is not a python addable version: '" << Type << "'";
                    throw Base::TypeError(str.str());
                }

                ext->initExtension(this);
            }
            if (ext && ext->getExtensionTypeId().getName() == Type) {
                ext->extensionRestore(reader);
            }
        }
        catch (const Base::XMLParseException&) {
            throw;  // re-throw
        }
        catch (const Base::Exception& e) {
            Base::Console().error("%s\n", e.what());
        }
        catch (const std::exception& e) {
            Base::Console().error("%s\n", e.what());
        }
        catch (const char* e) {
            Base::Console().error("%s\n", e);
        }