Examples with XmlElement eu.esdihumboldt.hale.io.xsd.model.XmlElement used on opensource projects

Example 26 with XmlElement

use of eu.esdihumboldt.hale.io.xsd.model.XmlElement in project hale by halestudio.

the class StreamGmlWriter method getConfiguredContainerElement.

/**
 * Get the for an I/O provider configured target container element, assuming
 * the I/O provider uses the {@link #PARAM_ROOT_ELEMENT_NAMESPACE} and
 * {@value #PARAM_ROOT_ELEMENT_NAME} parameters for this.
 *
 * @param provider the I/O provider
 * @param targetIndex the target XML index
 * @return the container element or <code>null</code> if it was not found
 */
public static XmlElement getConfiguredContainerElement(IOProvider provider, XmlIndex targetIndex) {
    // no container defined, try to use a custom root element
    String namespace = provider.getParameter(PARAM_ROOT_ELEMENT_NAMESPACE).as(String.class);
    // determine target namespace
    if (namespace == null) {
        // default to target namespace
        namespace = targetIndex.getNamespace();
    }
    String elementName = provider.getParameter(PARAM_ROOT_ELEMENT_NAME).as(String.class);
    // find root element
    XmlElement containerElement = null;
    if (elementName != null) {
        QName name = new QName(namespace, elementName);
        containerElement = targetIndex.getElements().get(name);
    }
    return containerElement;
}

Example 27 with XmlElement

use of eu.esdihumboldt.hale.io.xsd.model.XmlElement in project hale by halestudio.

the class SubstitutionGroupProperty method collectSubstitutions.

/**
 * Collect all sub-types from the given type that may substitute it on
 * condition of the given element name.
 *
 * @param elementName the element name
 * @param type the type to be substituted
 * @return the substitution types
 */
public static List<XmlElement> collectSubstitutions(QName elementName, TypeDefinition type) {
    Set<QName> substitute = new HashSet<QName>();
    substitute.add(elementName);
    Queue<TypeDefinition> subTypes = new LinkedList<TypeDefinition>();
    /*
		 * Add type itself also to list of types to be checked for
		 * substitutions. (this is needed e.g. in CityGML 0.4.0 schema
		 * cityObjectMember substituting featureMember) This essentially then is
		 * only a substitution in name and not in type. XXX if other elements,
		 * that are in no relation to the type, should also be possible for
		 * substitution, we would need some kond of substitution index in
		 * XmlIndex
		 */
    subTypes.add(type);
    // add all sub-types to the queue
    subTypes.addAll(type.getSubTypes());
    List<XmlElement> result = new ArrayList<XmlElement>();
    while (!subTypes.isEmpty()) {
        TypeDefinition subType = subTypes.poll();
        // check the declared elements for the substitution group
        Collection<? extends XmlElement> elements = subType.getConstraint(XmlElements.class).getElements();
        Iterator<? extends XmlElement> it = elements.iterator();
        while (it.hasNext()) {
            XmlElement element = it.next();
            QName subGroup = element.getSubstitutionGroup();
            if (subGroup != null && substitute.contains(subGroup)) {
                // only if substitution group match
                // add element name also to the name that may be substituted
                substitute.add(element.getName());
                if (!element.getType().getConstraint(AbstractFlag.class).isEnabled()) {
                    // only add if type is not abstract
                    result.add(element);
                }
            }
        }
        // XXX what about using xsi:type?
        // XXX we could also add elements for other sub-types then, e.g.
        // while also adding a specific constraint
        // add the sub-type's sub-types
        subTypes.addAll(subType.getSubTypes());
    }
    return result;
}

Example 28 with XmlElement

use of eu.esdihumboldt.hale.io.xsd.model.XmlElement in project hale by halestudio.

the class XmlElementsFactory method valueToElement.

private XmlElement valueToElement(Value val, Definition<?> definition, @SuppressWarnings("unused") TypeResolver typeResolver) {
    ValueProperties props = val.as(ValueProperties.class);
    if (props != null) {
        QName name = props.getSafe("name").as(QName.class);
        if (name != null) {
            QName substitutionGroup = props.getSafe("substitutionGroup").as(QName.class);
            TypeDefinition type = null;
            if (definition instanceof TypeDefinition) {
                type = (TypeDefinition) definition;
            } else {
                log.error("Wrong definition for XmlElements constraint: " + definition);
            }
            return new XmlElement(name, type, substitutionGroup);
        }
    }
    return null;
}

Example 29 with XmlElement

use of eu.esdihumboldt.hale.io.xsd.model.XmlElement in project hale by halestudio.

the class XmlElementsFactory method restore.

@Override
public XmlElements restore(Value value, Definition<?> definition, TypeResolver typeResolver, ClassResolver classResolver) throws Exception {
    XmlElements result = new XmlElements();
    ValueList list = value.as(ValueList.class);
    if (list != null) {
        for (Value val : list) {
            XmlElement element = valueToElement(val, definition, typeResolver);
            if (element != null) {
                result.addElement(element);
            }
        }
    }
    return result;
}

Example 30 with XmlElement

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, Map<String, 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();
            String targetNamespace = importedSchema.getTargetNamespace();
            if (!imports.containsKey(location)) {
                // only add schemas that
                // were not already
                // added
                boolean addedBefore = imports.entrySet().stream().anyMatch(e -> {
                    // and "https") and they have the same target namespace.
                    return targetNamespace.equals(e.getValue()) && schemeIndependentEquals(location, e.getKey());
                });
                if (!addedBefore) {
                    // place a marker in the map to prevent loading the
                    // location in the call to loadSchema
                    imports.put(location, targetNamespace);
                    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));
}