QPatternist::XsdSchemaMerger Class Reference

A helper class that merges two schemas into one. More...

#include <qxsdschemamerger_p.h>

Inheritance diagram for QPatternist::XsdSchemaMerger:

Public Types
typedef QExplicitlySharedDataPointer< XsdSchemaMerger >	Ptr

Public Functions
XsdSchema::Ptr	mergedSchema () const
	XsdSchemaMerger (const XsdSchema::Ptr &schema, const XsdSchema::Ptr &otherSchema)
Public Functions inherited from QSharedData
	QSharedData ()
	Constructs a QSharedData object with a reference count of 0. More...
	QSharedData (const QSharedData &)
	Constructs a QSharedData object with reference count 0. More...

Private Functions
void	merge (const XsdSchema::Ptr &schema, const XsdSchema::Ptr &otherSchema)

Properties
XsdSchema::Ptr	m_mergedSchema

Additional Inherited Members
Public Variables inherited from QSharedData
QAtomicInt	ref

Detailed Description

A helper class that merges two schemas into one.

This class is used in XsdValidatingInstanceReader to merge the schema given in the constructor with a schema defined in the instance document via xsi:schemaLocation or xsi:noNamespaceSchema location.

Author

Tobias Koenig tobia.nosp@m.s.ko.nosp@m.enig@.nosp@m.noki.nosp@m.a.com

Definition at line 73 of file qxsdschemamerger_p.h.

Typedefs

Ptr

typedef QExplicitlySharedDataPointer<XsdSchemaMerger> QPatternist::XsdSchemaMerger::Ptr

Definition at line 76 of file qxsdschemamerger_p.h.

Constructors and Destructors

XsdSchemaMerger()

XsdSchemaMerger::XsdSchemaMerger	(	const XsdSchema::Ptr &	schema,
		const XsdSchema::Ptr &	otherSchema
	)

Creates a new schema merger object that merges schema with otherSchema.

Definition at line 48 of file qxsdschemamerger.cpp.

{
    merge(schema, otherSchema);
}

Functions

merge()

void XsdSchemaMerger::merge ( const XsdSchema::Ptr &  schema, const XsdSchema::Ptr &  otherSchema  )

private

Definition at line 58 of file qxsdschemamerger.cpp.

Referenced by XsdSchemaMerger().

{
    m_mergedSchema = XsdSchema::Ptr(new XsdSchema(otherSchema->namePool()));

    // first fill the merged schema with the values from schema
    if (schema) {
        const XsdElement::List elements = schema->elements();
        for (int i = 0; i < elements.count(); ++i) {
            m_mergedSchema->addElement(elements.at(i));
        }

        const XsdAttribute::List attributes = schema->attributes();
        for (int i = 0; i < attributes.count(); ++i) {
            m_mergedSchema->addAttribute(attributes.at(i));
        }

        const SchemaType::List types = schema->types();
        for (int i = 0; i < types.count(); ++i) {
            m_mergedSchema->addType(types.at(i));
        }

        const SchemaType::List anonymousTypes = schema->anonymousTypes();
        for (int i = 0; i < anonymousTypes.count(); ++i) {
            m_mergedSchema->addAnonymousType(anonymousTypes.at(i));
        }

        const XsdModelGroup::List elementGroups = schema->elementGroups();
        for (int i = 0; i < elementGroups.count(); ++i) {
            m_mergedSchema->addElementGroup(elementGroups.at(i));
        }

        const XsdAttributeGroup::List attributeGroups = schema->attributeGroups();
        for (int i = 0; i < attributeGroups.count(); ++i) {
            m_mergedSchema->addAttributeGroup(attributeGroups.at(i));
        }

        const XsdNotation::List notations = schema->notations();
        for (int i = 0; i < notations.count(); ++i) {
            m_mergedSchema->addNotation(notations.at(i));
        }

        const XsdIdentityConstraint::List identityConstraints = schema->identityConstraints();
        for (int i = 0; i < identityConstraints.count(); ++i) {
            m_mergedSchema->addIdentityConstraint(identityConstraints.at(i));
        }
    }

    // then merge in the values from the otherSchema
    {
        const XsdElement::List elements = otherSchema->elements();
        for (int i = 0; i < elements.count(); ++i) {
            if (!m_mergedSchema->element(elements.at(i)->name(otherSchema->namePool())))
                m_mergedSchema->addElement(elements.at(i));
        }

        const XsdAttribute::List attributes = otherSchema->attributes();
        for (int i = 0; i < attributes.count(); ++i) {
            if (!m_mergedSchema->attribute(attributes.at(i)->name(otherSchema->namePool())))
                m_mergedSchema->addAttribute(attributes.at(i));
        }

        const SchemaType::List types = otherSchema->types();
        for (int i = 0; i < types.count(); ++i) {
            if (!m_mergedSchema->type(types.at(i)->name(otherSchema->namePool())))
                m_mergedSchema->addType(types.at(i));
        }

        const SchemaType::List anonymousTypes = otherSchema->anonymousTypes();
        for (int i = 0; i < anonymousTypes.count(); ++i) {
            // add anonymous type as they are
            m_mergedSchema->addAnonymousType(anonymousTypes.at(i));
        }

        const XsdModelGroup::List elementGroups = otherSchema->elementGroups();
        for (int i = 0; i < elementGroups.count(); ++i) {
            if (!m_mergedSchema->elementGroup(elementGroups.at(i)->name(otherSchema->namePool())))
                m_mergedSchema->addElementGroup(elementGroups.at(i));
        }

        const XsdAttributeGroup::List attributeGroups = otherSchema->attributeGroups();
        for (int i = 0; i < attributeGroups.count(); ++i) {
            if (!m_mergedSchema->attributeGroup(attributeGroups.at(i)->name(otherSchema->namePool())))
                m_mergedSchema->addAttributeGroup(attributeGroups.at(i));
        }

        const XsdNotation::List notations = otherSchema->notations();
        for (int i = 0; i < notations.count(); ++i) {
            if (!m_mergedSchema->notation(notations.at(i)->name(otherSchema->namePool())))
                m_mergedSchema->addNotation(notations.at(i));
        }

        const XsdIdentityConstraint::List identityConstraints = otherSchema->identityConstraints();
        for (int i = 0; i < identityConstraints.count(); ++i) {
            if (!m_mergedSchema->identityConstraint(identityConstraints.at(i)->name(otherSchema->namePool())))
                m_mergedSchema->addIdentityConstraint(identityConstraints.at(i));
        }
    }
}

mergedSchema()

XsdSchema::Ptr XsdSchemaMerger::mergedSchema

(

)

const

Returns the merged schema.

Definition at line 53 of file qxsdschemamerger.cpp.

Referenced by QPatternist::XsdValidatingInstanceReader::addSchema().

{
    return m_mergedSchema;
}

Properties

m_mergedSchema

XsdSchema::Ptr QPatternist::XsdSchemaMerger::m_mergedSchema

private

Definition at line 91 of file qxsdschemamerger_p.h.

Referenced by merge(), and mergedSchema().

---

The documentation for this class was generated from the following files:

• /src/xmlpatterns/schema/qxsdschemamerger_p.h
• /src/xmlpatterns/schema/qxsdschemamerger.cpp