use of eu.esdihumboldt.hale.io.xsd.model.XmlElement in project hale by halestudio.
the class XmlSchemaReader method loadSchema.
/**
* Load the feature types defined by the given schema
*
* @param schemaLocation the schema location
* @param xmlSchema the schema
* @param imports the imports/includes that were already loaded or where
* loading has been started
* @param progress the progress indicator
* @param mainSchema states if this is a main schema and therefore elements
* declared here should be flagged mappable
*/
protected void loadSchema(String schemaLocation, XmlSchema xmlSchema, Set<String> imports, ProgressIndicator progress, boolean mainSchema) {
String namespace = xmlSchema.getTargetNamespace();
if (namespace == null) {
namespace = XMLConstants.NULL_NS_URI;
}
// add namespace prefixes
NamespacePrefixList namespaces = xmlSchema.getNamespaceContext();
addPrefixes(namespaces, namespace, mainSchema);
// the schema items
XmlSchemaObjectCollection items = xmlSchema.getItems();
// go through all schema items
for (int i = 0; i < items.getCount(); i++) {
XmlSchemaObject item = items.getItem(i);
if (item instanceof XmlSchemaElement) {
// global element declaration
XmlSchemaElement element = (XmlSchemaElement) item;
// determine type
XmlTypeDefinition elementType = null;
if (element.getSchemaTypeName() != null) {
// reference to type
elementType = index.getOrCreateType(element.getSchemaTypeName());
} else if (element.getSchemaType() != null) {
// element has internal type definition, generate anonymous
// type name
QName typeName = new QName(element.getQName().getNamespaceURI(), // $NON-NLS-1$
element.getQName().getLocalPart() + "_AnonymousType");
// create type
elementType = createType(element.getSchemaType(), typeName, schemaLocation, namespace, mainSchema);
} else if (element.getQName() != null) {
// element with no type
elementType = index.getOrCreateType(XmlTypeUtil.NAME_ANY_TYPE);
}
if (elementType != null) {
// the element name
// XXX use element QName instead?
QName elementName = new QName(namespace, element.getName());
// the substitution group
QName subGroup = element.getSubstitutionGroup();
// TODO do we also need an index for substitutions?
// create schema element
XmlElement schemaElement = new XmlElement(elementName, elementType, subGroup);
// set metadata
setMetadata(schemaElement, element, schemaLocation);
// extend XmlElements constraint
XmlElements xmlElements = elementType.getConstraint(XmlElements.class);
xmlElements.addElement(schemaElement);
// set custom display name
elementType.setConstraint(new ElementName(xmlElements));
// set Mappable constraint (e.g. Mappable)
// for types with an associated element it can be determined
// on the spot if it is mappable
configureMappingRelevant(elementType, mainSchema);
// XXX needed? may result in conflicts when defining
// mappable types manually XXX the element is also marked
// with the Mappable constraint, to help with cases where
// multiple elements are defined for one
// schemaElement.setConstraint(MappableFlag.get(mainSchema));
// store element in index
index.getElements().put(elementName, schemaElement);
} else {
reporter.error(new IOMessageImpl(MessageFormat.format("No type for element {0} found.", element.getName()), null, element.getLineNumber(), element.getLinePosition()));
}
} else if (item instanceof XmlSchemaType) {
// complex or simple type
createType((XmlSchemaType) item, null, schemaLocation, namespace, mainSchema);
} else if (item instanceof XmlSchemaAttribute) {
// schema attribute that might be referenced somewhere
XmlSchemaAttribute att = (XmlSchemaAttribute) item;
if (att.getQName() != null) {
XmlTypeDefinition type = getAttributeType(att, null, schemaLocation);
if (type == null) {
// XXX if this occurs we might need a attribute
// referencing attribute
reporter.error(new IOMessageImpl("Could not determine attribute type", null, att.getLineNumber(), att.getLinePosition()));
} else {
XmlAttribute attribute = new XmlAttribute(att.getQName(), type);
index.getAttributes().put(attribute.getName(), attribute);
}
} else {
reporter.warn(new IOMessageImpl(MessageFormat.format("Attribute could not be processed: {0}", att.getName()), null, att.getLineNumber(), att.getLinePosition()));
}
} else if (item instanceof XmlSchemaAttributeGroup) {
// schema attribute group that might be referenced somewhere
XmlSchemaAttributeGroup attributeGroup = (XmlSchemaAttributeGroup) item;
if (attributeGroup.getName() != null) {
String groupIdent = attributeGroup.getName().getNamespaceURI() + "/" + attributeGroup.getName().getLocalPart();
XmlAttributeGroup attGroup = new XmlAttributeGroup(groupIdent, true);
createAttributes(attributeGroup, attGroup, "", schemaLocation, namespace);
index.getAttributeGroups().put(attributeGroup.getName(), attGroup);
} else {
reporter.warn(new IOMessageImpl("Attribute group could not be processed", null, attributeGroup.getLineNumber(), attributeGroup.getLinePosition()));
}
} else if (item instanceof XmlSchemaGroup) {
// group that might be referenced somewhere
XmlSchemaGroup schemaGroup = (XmlSchemaGroup) item;
if (schemaGroup.getName() != null) {
String groupIdent = schemaGroup.getName().getNamespaceURI() + "/" + schemaGroup.getName().getLocalPart();
XmlGroup group = new XmlGroup(groupIdent, true);
createPropertiesFromParticle(group, schemaGroup.getParticle(), schemaLocation, namespace, false);
index.getGroups().put(schemaGroup.getName(), group);
} else {
reporter.warn(new IOMessageImpl("Group could not be processed", null, schemaGroup.getLineNumber(), schemaGroup.getLinePosition()));
}
} else if (item instanceof XmlSchemaImport || item instanceof XmlSchemaInclude) {
// ignore, is treated separately
} else if (item instanceof XmlSchemaNotation) {
// notations are ignored
} else {
reporter.error(new IOMessageImpl("Unrecognized global definition: " + item.getClass().getSimpleName(), null, item.getLineNumber(), item.getLinePosition()));
}
}
// Set of include locations
Set<String> includes = new HashSet<String>();
// handle imports
XmlSchemaObjectCollection externalItems = xmlSchema.getIncludes();
if (externalItems.getCount() > 0) {
// $NON-NLS-1$
_log.info("Loading includes and imports for schema at " + schemaLocation);
}
for (int i = 0; i < externalItems.getCount(); i++) {
try {
XmlSchemaExternal imp = (XmlSchemaExternal) externalItems.getItem(i);
XmlSchema importedSchema = imp.getSchema();
String location = importedSchema.getSourceURI();
if (!(imports.contains(location))) {
// only add schemas that
// were not already
// added
// place a marker in the map to
imports.add(location);
// prevent loading the location in
// the call to loadSchema
loadSchema(location, importedSchema, imports, progress, mainSchema && imp instanceof XmlSchemaInclude);
// is part of main schema if it's a main schema include
}
if (imp instanceof XmlSchemaInclude) {
includes.add(location);
}
} catch (Throwable e) {
reporter.error(new IOMessageImpl("Error adding imported schema from " + schemaLocation, // $NON-NLS-1$
e));
}
}
// $NON-NLS-1$
_log.info("Creating types for schema at " + schemaLocation);
progress.setCurrentTask(// $NON-NLS-1$
MessageFormat.format(Messages.getString("ApacheSchemaProvider.33"), namespace));
}
use of eu.esdihumboldt.hale.io.xsd.model.XmlElement in project hale by halestudio.
the class XmlSchemaReader method applyRelevantElements.
/**
* Apply the relevant elements setting to the given XML index.
*
* @param index the XML index
*/
private void applyRelevantElements(XmlIndex index) {
Set<? extends QName> names = getRelevantElements();
if (names != null && !names.isEmpty()) {
// only apply if any elements are given
// get all currently marked relevant types
Set<TypeDefinition> toggleTypes = new HashSet<>(index.getMappingRelevantTypes());
boolean foundAny = false;
for (QName name : names) {
XmlElement elm = index.getElements().get(name);
if (elm != null) {
foundAny = true;
TypeDefinition type = elm.getType();
if (toggleTypes.contains(type)) {
// do not toggle -> stay relevant
toggleTypes.remove(type);
} else {
// toggle -> become relevant
toggleTypes.add(type);
}
}
}
if (foundAny) {
// only apply if one of the given elements was actually found in
// the schema
index.toggleMappingRelevant(toggleTypes);
}
}
}
use of eu.esdihumboldt.hale.io.xsd.model.XmlElement in project hale by halestudio.
the class SubstitutionGroupProperty method initChildren.
/**
* @see LazyGroupPropertyDefinition#initChildren()
*/
@Override
protected void initChildren() {
if (property != null) {
TypeDefinition propertyType = property.getPropertyType();
// add property and substitutions
// collect substitution types and elements
List<XmlElement> substitutions = collectSubstitutions(property.getName(), propertyType);
if (substitutions == null || substitutions.isEmpty()) {
// add property (XXX even if the property type is abstract)
// no redeclaration necessary as this
super.addChild(property);
// is already the declaring group
} else {
// add property if the type is not abstract
if (!propertyType.getConstraint(AbstractFlag.class).isEnabled()) {
// no redeclaration necessary as
super.addChild(property);
// this is already the declaring
// group
}
// add substitutions
for (XmlElement substitution : substitutions) {
PropertyDefinition p = new SubstitutionProperty(substitution, property, this);
// must call super add
super.addChild(p);
}
}
}
// else empty group
}
use of eu.esdihumboldt.hale.io.xsd.model.XmlElement in project hale by halestudio.
the class XmlSchemaReaderTest method testRead_shiporder_unqualified.
/**
* Test reading a simple XML schema that contains one big element and where
* elementFormDefault/attributeFromDefault is set to unqualified and no
* target namespace is set. Focuses on structure, simple type bindings and
* cardinalities.
*
* @throws Exception if reading the schema fails
*/
@Test
public void testRead_shiporder_unqualified() throws Exception {
URI location = getClass().getResource("/testdata/shiporder/shiporder-unqualified.xsd").toURI();
LocatableInputSupplier<? extends InputStream> input = new DefaultInputSupplier(location);
XmlIndex schema = (XmlIndex) readSchema(input);
String ns = XMLConstants.NULL_NS_URI;
assertEquals(ns, schema.getNamespace());
// shiporder element
Collection<XmlElement> elements = getElementsWithNS(ns, schema.getElements().values());
assertEquals(1, elements.size());
XmlElement shiporder = elements.iterator().next();
// XXX use null namespace XXX not sure how to work with unqualified form
// FIXME target namespace no effect?! should the target namespace always
// be injected?
testShiporderStructure(shiporder, ns);
}
use of eu.esdihumboldt.hale.io.xsd.model.XmlElement in project hale by halestudio.
the class XmlSchemaReaderTest method testRead_definitive_chapter03.
/**
* Test reading a simple XML schema that is split into several files. Tests
* also the {@link XmlElements} and {@link MappingRelevantFlag} constraints
*
* @throws Exception if reading the schema fails
*/
@Test
public void testRead_definitive_chapter03() throws Exception {
URI location = getClass().getResource("/testdata/definitive/chapter03env.xsd").toURI();
LocatableInputSupplier<? extends InputStream> input = new DefaultInputSupplier(location);
XmlIndex schema = (XmlIndex) readSchema(input);
// envelope element
XmlElement envelope = schema.getElements().get(new QName("http://example.org/ord", "envelope"));
assertNotNull(envelope);
TypeDefinition envType = envelope.getType();
// mappable
assertTrue(envType.getConstraint(MappingRelevantFlag.class).isEnabled());
// XmlElements
Collection<? extends XmlElement> elements = envType.getConstraint(XmlElements.class).getElements();
assertEquals(1, elements.size());
assertEquals(envelope, elements.iterator().next());
// order
PropertyDefinition order = envType.getChild(new QName("http://example.org/ord", "order")).asProperty();
assertNotNull(order);
TypeDefinition orderType = order.getPropertyType();
// mappable
assertTrue(orderType.getConstraint(MappingRelevantFlag.class).isEnabled());
// number
PropertyDefinition number = orderType.getChild(new QName("http://example.org/ord", "number")).asProperty();
assertNotNull(number);
// binding must be string
assertEquals(String.class, number.getPropertyType().getConstraint(Binding.class).getBinding());
// items
PropertyDefinition items = orderType.getChild(new QName("http://example.org/ord", "items")).asProperty();
assertNotNull(items);
// not mappable
assertFalse(items.getPropertyType().getConstraint(MappingRelevantFlag.class).isEnabled());
// no elements
assertTrue(items.getPropertyType().getConstraint(XmlElements.class).getElements().isEmpty());
// SpecialOrderType
// extension to OrderType, should be mappable using xsi:type
TypeDefinition specialOrderType = schema.getType(new QName("http://example.org/ord", "SpecialOrderType"));
assertNotNull(specialOrderType);
// number of declared children
assertEquals(1, specialOrderType.getDeclaredChildren().size());
// number of children
assertEquals(3, specialOrderType.getChildren().size());
// mappable
assertTrue(specialOrderType.getConstraint(MappableFlag.class).isEnabled());
// no elements
assertTrue(specialOrderType.getConstraint(XmlElements.class).getElements().isEmpty());
// overall mappable types
Collection<? extends TypeDefinition> mt = schema.getMappingRelevantTypes();
// envelope, order, special order
assertEquals(2, mt.size());
}
Aggregations