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;
}
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;
}
Aggregations