Search in sources :

Example 1 with XSDMapping

use of org.geotoolkit.feature.xml.jaxb.mapping.XSDMapping in project geotoolkit by Geomatys.

the class JAXPStreamFeatureReader method readFeature.

private Feature readFeature(final FeatureType featureType, final GenericName tagName) throws XMLStreamException {
    final Feature feature = featureType.newInstance();
    /*
         * We create a map and a collection because we can encounter two cases :
         * - The case featureType defines a property with max occur > 1.
         * - The case featureType defines a property with max occur = 1, and its
         * value instance of collection or map.
         * We store all encountered name with its linked property in the map, so
         * at each value parsed, we can add it in the existing property if its
         * value is a list or map. The collection is the final property store,
         * we add the all the created properties in it (so we can put multiple
         * properties with the same name).
         */
    final List<Entry<Operation, Object>> ops = new ArrayList<>();
    // read attributes
    final int nbAtts = reader.getAttributeCount();
    for (int i = 0; i < nbAtts; i++) {
        final QName attName = reader.getAttributeName(i);
        if ("href".equals(attName.getLocalPart())) {
            // or if can't be resolved we will still have the id
            try {
                final String attVal = reader.getAttributeValue(i);
                feature.setPropertyValue(AttributeConvention.IDENTIFIER, attVal);
            } catch (IllegalArgumentException ex) {
            // do nothing
            }
        } else {
            try {
                final AttributeType pd = (AttributeType) featureType.getProperty("@" + attName.getLocalPart());
                final String attVal = reader.getAttributeValue(i);
                final Object val = ObjectConverters.convert(attVal, pd.getValueClass());
                feature.setPropertyValue(pd.getName().toString(), val);
            } catch (PropertyNotFoundException ex) {
            // do nothing
            }
        }
    }
    boolean doNext = true;
    // read a real complex type
    while (!doNext || reader.hasNext()) {
        if (doNext) {
            reader.next();
        }
        doNext = true;
        int event = reader.getEventType();
        if (event == START_ELEMENT) {
            GenericName propName = nameCache.get(reader.getName());
            // we skip the boundedby attribute if it's present
            if ("boundedBy".equals(propName.tip().toString())) {
                toTagEnd("boundedBy");
                continue;
            }
            final String nameAttribute = reader.getAttributeValue(null, "name");
            // search property
            PropertyType propertyType = null;
            FeatureType associationSubType = null;
            // search direct name
            try {
                propertyType = featureType.getProperty(propName.toString());
            } catch (PropertyNotFoundException e) {
            /*can happen*/
            }
            // search using only local part
            if (propertyType == null) {
                try {
                    propertyType = featureType.getProperty(propName.tip().toString());
                } catch (PropertyNotFoundException e) {
                /*can happen*/
                }
            }
            // search if we are dealing with a subtype of a feature association role value type
            if (propertyType == null) {
                try {
                    final FeatureType candidate = featureTypes.get(propName.toString());
                    if (candidate != null) {
                        // search for a FeatureAssociationRole
                        for (PropertyType pt : featureType.getProperties(true)) {
                            if (pt instanceof FeatureAssociationRole) {
                                final FeatureAssociationRole far = (FeatureAssociationRole) pt;
                                final FeatureType vt = far.getValueType();
                                if (vt.isAssignableFrom(candidate)) {
                                    propertyType = far;
                                    associationSubType = candidate;
                                    // change property name where data will be stored
                                    propName = far.getName();
                                    break;
                                }
                            }
                        }
                    }
                } catch (IllegalNameException ex) {
                    Logger.getLogger(JAXPStreamFeatureReader.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            // skip property if we couldn't find it and user requested it
            if (propertyType == null && Boolean.TRUE.equals(this.properties.get(SKIP_UNEXPECTED_PROPERTY_TAGS))) {
                toTagEnd(propName.tip().toString());
                continue;
            }
            // search if we have an _any attribute available
            if (propertyType == null) {
                try {
                    final AttributeType pd = (AttributeType) featureType.getProperty("_any");
                    // convert the content as a dom node
                    final Document doc = readAsDom(propName.tip().toString());
                    feature.setPropertyValue(pd.getName().toString(), doc);
                    doNext = false;
                    continue;
                } catch (PropertyNotFoundException e) {
                    throw new XMLStreamException("Could not find any property fitting named tag " + propName);
                }
            }
            if (propertyType instanceof Operation) {
                final Operation opType = (Operation) propertyType;
                final PropertyType resultType = (PropertyType) opType.getResult();
                final Object value = readPropertyValue(resultType, null, null);
                ops.add(new AbstractMap.SimpleImmutableEntry<>((Operation) propertyType, value));
                if (resultType.getName().equals(propertyType.getName())) {
                    // we are already on the next element here, jaxb ate one
                    doNext = false;
                }
                continue;
            }
            // read attributes
            if (propertyType instanceof AttributeType) {
                final AttributeType<?> attType = (AttributeType) propertyType;
                final int nbPropAtts = reader.getAttributeCount();
                if (nbPropAtts > 0) {
                    final Attribute att = (Attribute) feature.getProperty(propName.toString());
                    for (int i = 0; i < nbPropAtts; i++) {
                        final QName qname = reader.getAttributeName(i);
                        final GenericName attName = nameCache.get(new QName(qname.getNamespaceURI(), "@" + qname.getLocalPart()));
                        final AttributeType<?> charType = attType.characteristics().get(attName.toString());
                        if (charType != null) {
                            final String attVal = reader.getAttributeValue(i);
                            final Object val = ObjectConverters.convert(attVal, charType.getValueClass());
                            final Attribute chara = charType.newInstance();
                            chara.setValue(val);
                            att.characteristics().put(attName.toString(), chara);
                        }
                    }
                }
            }
            // check if attribute has it's own mapping
            final XSDMapping mapping = GMLConvention.getMapping(propertyType);
            if (mapping != null) {
                mapping.readValue(reader, propName, feature);
            } else {
                // parse the value
                final Object value = readPropertyValue(propertyType, associationSubType, feature);
                setValue(feature, propertyType, propName, nameAttribute, value);
            }
        } else if (event == END_ELEMENT) {
            final QName q = reader.getName();
            if (q.getLocalPart().equals("featureMember") || nameCache.get(q).equals(tagName)) {
                break;
            }
        }
    }
    return feature;
}
Also used : FeatureType(org.opengis.feature.FeatureType) PropertyNotFoundException(org.opengis.feature.PropertyNotFoundException) Attribute(org.opengis.feature.Attribute) XSDMapping(org.geotoolkit.feature.xml.jaxb.mapping.XSDMapping) PropertyType(org.opengis.feature.PropertyType) Operation(org.opengis.feature.Operation) Document(org.w3c.dom.Document) Feature(org.opengis.feature.Feature) Entry(java.util.Map.Entry) GenericName(org.opengis.util.GenericName) AttributeType(org.opengis.feature.AttributeType) IllegalNameException(org.apache.sis.storage.IllegalNameException) QName(javax.xml.namespace.QName) XMLStreamException(javax.xml.stream.XMLStreamException) FeatureAssociationRole(org.opengis.feature.FeatureAssociationRole)

Example 2 with XSDMapping

use of org.geotoolkit.feature.xml.jaxb.mapping.XSDMapping in project geotoolkit by Geomatys.

the class JAXBFeatureTypeReader method getType.

private Object getType(String namespaceURI, ComplexType type, BuildStack stack, boolean useCache) {
    final GenericName name = extractFinalName(namespaceURI, type);
    if (useCache && typesCache.containsKey(name)) {
        return typesCache.get(name);
    }
    for (XSDMapping.Spi mapping : mappings) {
        final XSDMapping map = mapping.create(name, this, type);
        if (map != null) {
            IdentifiedType mappedType = map.getType();
            if (mappedType instanceof AttributeType) {
                AttributeType at = (AttributeType) mappedType;
                AttributeTypeBuilder atb = new FeatureTypeBuilder().addAttribute(at);
                atb.addCharacteristic(XSDMapping.class).setName(GMLConvention.MAPPING).setDefaultValue(map);
                mappedType = atb.build();
            // AttributeType[] att = (AttributeType[]) at.characteristics().values().toArray(new AttributeType[0]);
            // final Map properties = new HashMap();
            // properties.put(AbstractIdentifiedType.NAME_KEY, at.getName());
            // properties.put(AbstractIdentifiedType.DEFINITION_KEY, at.getDefinition());
            // properties.put(AbstractIdentifiedType.DEPRECATED_KEY, ((Deprecable) at).isDeprecated());
            // properties.put(AbstractIdentifiedType.DESCRIPTION_KEY, at.getDescription());
            // properties.put(AbstractIdentifiedType.DESIGNATION_KEY, at.getDesignation());
            // mappedType = new MappedAttributeType(
            // properties,
            // at.getValueClass(),
            // at.getMinimumOccurs(),
            // at.getMaximumOccurs(),
            // at.getDefaultValue(),
            // map,
            // att);
            }
            typesCache.put(name, mappedType);
            return mappedType;
        }
    }
    // special case for gml:ReferenceType
    final String namespace = NamesExt.getNamespace(name);
    if ((GMLConvention.GML_311_NAMESPACE.equals(namespace) || GMLConvention.GML_321_NAMESPACE.equals(namespace)) && "ReferenceType".equals(name.tip().toString())) {
        // note : can't use real AbstractGMLType, recursive object creation
        final QName gml = new QName(namespace, "AbstractGMLType");
        final Object abstractGmlType = getType(gml, stack);
        if (abstractGmlType instanceof GenericName) {
            final FeatureTypeBuilder ftb = new FeatureTypeBuilder();
            FeatureAssociationRole far = ftb.addAssociation((GenericName) abstractGmlType).setName(name).build();
            typesCache.put(name, far);
            return far;
        } else {
            final FeatureTypeBuilder ftb = new FeatureTypeBuilder();
            FeatureAssociationRole far = ftb.addAssociation((FeatureType) abstractGmlType).setName(name).build();
            typesCache.put(name, far);
            return far;
        }
    }
    final boolean deprecated = GMLConvention.isDeprecated(type);
    // read simple content type if defined
    final SimpleContent simpleContent = type.getSimpleContent();
    if (simpleContent != null) {
        final ExtensionType sext = simpleContent.getExtension();
        if (sext != null) {
            // simple type base, it must be : this is the content of the tag <tag>XXX<tag>
            // it is not named, so we call it value
            final QName base = sext.getBase();
            final AttributeType st = (AttributeType) resolveType(base, stack);
            final AttributeTypeBuilder atb = new FeatureTypeBuilder().addAttribute(st);
            atb.setName(name);
            atb.setDeprecated(deprecated);
            // read attributes
            for (PropertyType property : getAnnotatedAttributes(namespaceURI, sext.getAttributeOrAttributeGroup(), stack)) {
                CharacteristicTypeBuilder cb = atb.getCharacteristic(property.getName().toString());
                if (cb == null) {
                    atb.addCharacteristic((AttributeType) property);
                } else {
                // characteristic already exist
                }
            }
            final AttributeType att = atb.build();
            typesCache.put(name, att);
            return att;
        }
        final SimpleRestrictionType restriction = simpleContent.getRestriction();
        if (restriction != null) {
            final QName base = restriction.getBase();
            if (base != null) {
                final ComplexType sct = xsdContext.findComplexType(base);
                if (sct != null) {
                    final AttributeType tct = (AttributeType) getType(namespaceURI, sct, stack, true);
                    final AttributeTypeBuilder atb = new FeatureTypeBuilder().addAttribute(tct);
                    atb.setName(name);
                    atb.setDeprecated(deprecated);
                    // read attributes
                    for (PropertyType property : getAnnotatedAttributes(namespaceURI, restriction.getAttributeOrAttributeGroup(), stack)) {
                        CharacteristicTypeBuilder cb = atb.getCharacteristic(property.getName().toString());
                        if (cb == null) {
                            atb.addCharacteristic((AttributeType) property);
                        } else {
                        // characteristic already exist
                        }
                    }
                    final AttributeType att = atb.build();
                    typesCache.put(name, att);
                    return att;
                } else {
                // final PropertyType restType = resolveType(base, stack);
                // addOrReplace(finalType.builder, atb.create(restType, NamesExt.create(namespaceURI, Utils.VALUE_PROPERTY_NAME), 0, 1, false, null));
                }
            }
        }
        throw new MismatchedFeatureException("Undefined simple type : " + name);
    }
    final FeatureTypeBuilder ftb = new FeatureTypeBuilder();
    ftb.setName(name);
    ftb.setDeprecated(deprecated);
    // read attributes
    for (PropertyType property : getAnnotatedAttributes(namespaceURI, type.getAttributeOrAttributeGroup(), stack)) {
        addProperty(ftb, property);
    }
    // read sequence properties
    for (PropertyType property : getGroupAttributes(namespaceURI, type.getSequence(), stack)) {
        addProperty(ftb, property);
    }
    // read complex content if defined
    final ComplexContent content = type.getComplexContent();
    if (content != null) {
        final ExtensionType extension = content.getExtension();
        if (extension != null) {
            final QName base = extension.getBase();
            if (base != null && !base.getLocalPart().equalsIgnoreCase("anytype")) {
                final Object parent = getType(base, stack);
                if (parent instanceof FeatureType) {
                    ftb.setSuperTypes((FeatureType) parent);
                } else if (parent instanceof GenericName) {
                    // parent type is currently being resolved
                    return name;
                }
            }
            // read attributes
            for (PropertyType property : getAnnotatedAttributes(namespaceURI, extension.getAttributeOrAttributeGroup(), stack)) {
                addProperty(ftb, property);
            }
            // read groups
            for (PropertyType property : getGroupAttributes(namespaceURI, extension.getSequence(), stack)) {
                addProperty(ftb, property);
            }
        }
        /* BIG DIRTY HACK: Needed for GML 2.1.2 support.
             * For geometry definition, GML 2 propose an association to some
             * data-type defined by restiction over an abstract geometry type.
             * But, we do not want it to an association, we want it to be an
             * attribute, for god sake ! So, we cheat and if we find a structure
             * like that, we transform it into attribute (oh god that's awful).
             */
        final ComplexRestrictionType restriction = content.getRestriction();
        if (restriction != null) {
            final QName base = restriction.getBase();
            if (base != null) {
                Object restrictionType = getType(base, stack);
                if (restrictionType instanceof FeatureType) {
                    ftb.setSuperTypes((FeatureType) restrictionType);
                }
            // final ComplexType sct = xsdContext.findComplexType(base);
            // if (sct != null) {
            // final Object obj = getType(base.getNamespaceURI(), sct, stack);
            // if (obj instanceof FeatureType
            // //                                && isGeometric((FeatureType)obj)
            // ) {
            // final ExplicitGroup sequence = sct.getSequence();
            // if (sequence != null) {
            // final List<Element> elements = sequence.getElements();
            // if (elements != null && !elements.isEmpty()) {
            // Element e = sequence.getElements().get(0);
            // return ftb.addAttribute(Geometry.class)
            // .setName(e.getRef().getLocalPart())
            // .setMinimumOccurs(sequence.getMinOccurs())
            // .build();
            // }
            // }
            // } else if (obj instanceof PropertyType) {
            // final PropertyTypeBuilder ptb = new FeatureTypeBuilder().addProperty((PropertyType) obj);
            // if (ptb instanceof PropertyTypeBuilder) {
            // final AttributeTypeBuilder atb = (AttributeTypeBuilder) ptb;
            // // check characteristics
            // for (PropertyType property : getAnnotatedAttributes(namespaceURI, restriction.getAttributeOrAttributeGroup(), stack)) {
            // if (atb.getCharacteristic(property.getName().toString()) == null) {
            // atb.addCharacteristic((AttributeType) property);
            // }
            // }
            // }
            // }
            // }
            }
        }
    }
    // read choice if set
    final ExplicitGroup choice = type.getChoice();
    if (choice != null) {
    // this is the case of gml:location
    }
    // //        if (GMLConvention.isDecoratedProperty(featureType.getName().tip().toString())) {
    // //            //Used by geometry property types but also in some gml profils
    // //            final String decoratedName = NamesExt.toExpandedString(featureType.getName());
    // //
    // //            //this is an encapsulated property, we unroll it
    // //            final Collection<? extends PropertyType> subProps = featureType.getProperties(true);
    // //            //we peek the first association, there should be only one
    // //            //but attributes are possible
    // //            for (PropertyType pt : subProps) {
    // //                if (pt.getName().tip().toString().startsWith("@")) {
    // //                    //ignore xml attributes
    // //                    continue;
    // //                }
    // //
    // //                if (pt instanceof FeatureAssociationRole) {
    // //                    /* HACK : GML 3.1.1 : Only way I've found to manage
    // //                     * geometries as attributes. If we've found an association,
    // //                     * and if it's feature type is a geometric property
    // //                     * (derived from abstract geometric type), well, we
    // //                     * return a geometric property.
    // //                     */
    // //                    final FeatureAssociationRole subFar = (FeatureAssociationRole) pt;
    // //                    FeatureType valueType = subFar.getValueType();
    // //                    FeatureAssociationRole ar = ftb
    // //                            .addAssociation(subFar)
    // //                            .setDescription(GMLConvention.DECORATED_DESCRIPTION+NamesExt.toExpandedString(subFar.getName()))
    // //                            .build();
    // //
    // //                    typesCache.put(name, ar);
    // //                    return featureType;
    // //                } else if (pt instanceof AttributeType) {
    // //                    AttributeType at = (AttributeType) pt;
    // //
    // //                    ftb.clear();
    // //                    at = ftb.addAttribute(at).setDescription(GMLConvention.DECORATED_DESCRIPTION+" "+NamesExt.toExpandedString(at.getName())).build();
    // //                    typesCache.put(name, at);
    // //                    return at;
    // //                }
    // //            }
    // //
    // //            throw new UnsupportedOperationException("Decorated property without any property");
    // //
    // //        }
    // define the default geometry
    PropertyTypeBuilder candidateDefaultGeom = null;
    for (PropertyTypeBuilder ptb : ftb.properties()) {
        if (ptb instanceof AttributeTypeBuilder) {
            Class valueClass = ((AttributeTypeBuilder) ptb).getValueClass();
            if (Geometry.class.isAssignableFrom(valueClass)) {
                XSDMapping mapping = GMLConvention.getMapping(ptb.build());
                if (mapping instanceof GeometryMapping) {
                    if (((GeometryMapping) mapping).isDecorated()) {
                        // keep it as a candidate, we prefere undecorated properties
                        candidateDefaultGeom = ptb;
                    } else {
                        candidateDefaultGeom = null;
                        ((AttributeTypeBuilder) ptb).addRole(AttributeRole.DEFAULT_GEOMETRY);
                        break;
                    }
                }
            }
        }
    }
    if (candidateDefaultGeom != null) {
        ((AttributeTypeBuilder) candidateDefaultGeom).addRole(AttributeRole.DEFAULT_GEOMETRY);
    }
    FeatureType featureType = ftb.build();
    typesCache.put(name, featureType);
    return featureType;
}
Also used : GeometryMapping(org.geotoolkit.feature.xml.jaxb.mapping.GeometryMapping) SimpleRestrictionType(org.geotoolkit.xsd.xml.v2001.SimpleRestrictionType) FeatureType(org.opengis.feature.FeatureType) XSDMapping(org.geotoolkit.feature.xml.jaxb.mapping.XSDMapping) PropertyType(org.opengis.feature.PropertyType) ComplexContent(org.geotoolkit.xsd.xml.v2001.ComplexContent) ExplicitGroup(org.geotoolkit.xsd.xml.v2001.ExplicitGroup) SingleAttributeTypeBuilder(org.geotoolkit.feature.SingleAttributeTypeBuilder) AttributeTypeBuilder(org.apache.sis.feature.builder.AttributeTypeBuilder) PropertyTypeBuilder(org.apache.sis.feature.builder.PropertyTypeBuilder) GenericName(org.opengis.util.GenericName) AttributeType(org.opengis.feature.AttributeType) IdentifiedType(org.opengis.feature.IdentifiedType) FeatureTypeBuilder(org.apache.sis.feature.builder.FeatureTypeBuilder) QName(javax.xml.namespace.QName) ComplexRestrictionType(org.geotoolkit.xsd.xml.v2001.ComplexRestrictionType) CharacteristicTypeBuilder(org.apache.sis.feature.builder.CharacteristicTypeBuilder) MismatchedFeatureException(org.opengis.feature.MismatchedFeatureException) ExtensionType(org.geotoolkit.xsd.xml.v2001.ExtensionType) SimpleContent(org.geotoolkit.xsd.xml.v2001.SimpleContent) FeatureAssociationRole(org.opengis.feature.FeatureAssociationRole) LocalComplexType(org.geotoolkit.xsd.xml.v2001.LocalComplexType) ComplexType(org.geotoolkit.xsd.xml.v2001.ComplexType)

Aggregations

QName (javax.xml.namespace.QName)2 XSDMapping (org.geotoolkit.feature.xml.jaxb.mapping.XSDMapping)2 AttributeType (org.opengis.feature.AttributeType)2 FeatureAssociationRole (org.opengis.feature.FeatureAssociationRole)2 FeatureType (org.opengis.feature.FeatureType)2 PropertyType (org.opengis.feature.PropertyType)2 GenericName (org.opengis.util.GenericName)2 Entry (java.util.Map.Entry)1 XMLStreamException (javax.xml.stream.XMLStreamException)1 AttributeTypeBuilder (org.apache.sis.feature.builder.AttributeTypeBuilder)1 CharacteristicTypeBuilder (org.apache.sis.feature.builder.CharacteristicTypeBuilder)1 FeatureTypeBuilder (org.apache.sis.feature.builder.FeatureTypeBuilder)1 PropertyTypeBuilder (org.apache.sis.feature.builder.PropertyTypeBuilder)1 IllegalNameException (org.apache.sis.storage.IllegalNameException)1 SingleAttributeTypeBuilder (org.geotoolkit.feature.SingleAttributeTypeBuilder)1 GeometryMapping (org.geotoolkit.feature.xml.jaxb.mapping.GeometryMapping)1 ComplexContent (org.geotoolkit.xsd.xml.v2001.ComplexContent)1 ComplexRestrictionType (org.geotoolkit.xsd.xml.v2001.ComplexRestrictionType)1 ComplexType (org.geotoolkit.xsd.xml.v2001.ComplexType)1 ExplicitGroup (org.geotoolkit.xsd.xml.v2001.ExplicitGroup)1