QSet<XsdElement::Ptr> collectAllElements(const XsdSchema::Ptr &schema)
{
QSet<XsdElement::Ptr> elements;
// collect global elements
const XsdElement::List elementList = schema->elements();
for (int i = 0; i < elementList.count(); ++i)
elements.insert(elementList.at(i));
// collect all elements from global groups
const XsdModelGroup::List groupList = schema->elementGroups();
for (int i = 0; i < groupList.count(); ++i) {
const XsdModelGroup::Ptr group(groupList.at(i));
for (int j = 0; j < group->particles().count(); ++j)
elements.unite(collectAllElements(group->particles().at(j)));
}
// collect all elements from complex type definitions
SchemaType::List types;
types << schema->types() << schema->anonymousTypes();
for (int i = 0; i < types.count(); ++i) {
if (types.at(i)->isComplexType() && types.at(i)->isDefinedBySchema()) {
const XsdComplexType::Ptr complexType(types.at(i));
if (complexType->contentType()->particle())
elements.unite(collectAllElements(complexType->contentType()->particle()));
}
}
return elements;
}
XsdComplexType::List XsdSchema::complexTypes() const
{
QReadLocker locker(&m_lock);
XsdComplexType::List retval;
const SchemaType::List types = m_types.values();
for (int i = 0; i < types.count(); ++i) {
if (types.at(i)->isComplexType() && types.at(i)->isDefinedBySchema())
retval.append(types.at(i));
}
return retval;
}
void XsdSchemaDebugger::dumpSchema(const XsdSchema::Ptr &schema)
{
qDebug() << "------------------------------ Schema -------------------------------";
// elements
{
qDebug() << "Global Elements:";
const XsdElement::List elements = schema->elements();
for (int i = 0; i < elements.count(); ++i) {
dumpElement(elements.at(i));
}
}
// attributes
{
qDebug() << "Global Attributes:";
const XsdAttribute::List attributes = schema->attributes();
for (int i = 0; i < attributes.count(); ++i) {
dumpAttribute(attributes.at(i));
}
}
// types
{
qDebug() << "Global Types:";
const SchemaType::List types = schema->types();
for (int i = 0; i < types.count(); ++i) {
dumpType(types.at(i));
}
}
// anonymous types
{
qDebug() << "Anonymous Types:";
const SchemaType::List types = schema->anonymousTypes();
for (int i = 0; i < types.count(); ++i) {
dumpType(types.at(i));
}
}
qDebug() << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
}
void XsdSchemaMerger::merge(const XsdSchema::Ptr &schema, const XsdSchema::Ptr &otherSchema)
{
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));
}
}
}