Examples with FeatureAssociationRole org.opengis.feature.FeatureAssociationRole used on opensource projects

Example 11 with FeatureAssociationRole

use of org.opengis.feature.FeatureAssociationRole 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;
}

Example 12 with FeatureAssociationRole

use of org.opengis.feature.FeatureAssociationRole in project geotoolkit by Geomatys.

the class JAXBFeatureTypeReader method listFeatureTypes.

private void listFeatureTypes(Schema schema, GenericNameIndex<FeatureType> result) throws MismatchedFeatureException, IllegalNameException {
    // then we look for feature type and groups
    for (OpenAttrs opAtts : schema.getSimpleTypeOrComplexTypeOrGroup()) {
        if (opAtts instanceof TopLevelElement) {
            final TopLevelElement element = (TopLevelElement) opAtts;
            final QName typeName = element.getType();
            if (typeName != null) {
                final ComplexType type = xsdContext.findComplexType(typeName);
                if (type == null && xsdContext.findSimpleType(typeName) == null) {
                    LOGGER.log(Level.WARNING, "Unable to find a the declaration of type {0} in schemas.", typeName.getLocalPart());
                    continue;
                }
                // if (xsdContext.isFeatureType(type)) {
                final BuildStack stack = new BuildStack();
                Object typeObj = getType(typeName.getNamespaceURI(), type, stack, true);
                FeatureType ft = null;
                if (typeObj instanceof FeatureAssociationRole) {
                    ft = ((FeatureAssociationRole) typeObj).getValueType();
                } else if (typeObj instanceof FeatureType) {
                    ft = (FeatureType) typeObj;
                }
                if (ft != null) {
                    addIfMissing(result, ft);
                    // if the type name is not the same as the element name, make a subtype
                    if (!ft.getName().tip().toString().equals(element.getName())) {
                        final GenericName name = NamesExt.create(NamesExt.getNamespace(ft.getName()), element.getName());
                        final FeatureTypeBuilder ftb = new FeatureTypeBuilder();
                        ftb.setName(name);
                        ftb.setSuperTypes(ft);
                        final FeatureType renamed = ftb.build();
                        addIfMissing(result, renamed);
                    }
                }
            // }
            } else {
                LOGGER.log(Level.WARNING, "null typeName for element : {0}", element.getName());
            }
        }
    }
}

Example 13 with FeatureAssociationRole

use of org.opengis.feature.FeatureAssociationRole in project geotoolkit by Geomatys.

the class JAXBFeatureTypeReader method elementToAttribute.

private PropertyType elementToAttribute(final String namespaceURI, Element element, BuildStack stack) {
    GenericName name = null;
    final QName refName = element.getRef();
    PropertyType refType = null;
    if (refName != null) {
        final Element parentElement = xsdContext.findGlobalElement(refName);
        if (parentElement == null) {
            throw new MismatchedFeatureException("unable to find referenced element : " + refName);
        }
        refType = elementToAttribute(namespaceURI, parentElement, stack);
        name = NamesExt.create(refName);
    }
    // extract name
    String localName = element.getName();
    if (localName == null) {
        localName = element.getId();
    }
    if (localName != null) {
        // override name
        name = NamesExt.create(namespaceURI, localName);
    }
    // extract min/max
    final Integer[] minMax = getMinMax(element);
    if (minMax[0] == null)
        minMax[0] = 1;
    if (minMax[1] == null)
        minMax[1] = 1;
    final QName typeName = element.getType();
    if (typeName != null) {
        PropertyType parentType = resolveType(typeName, stack);
        if (element instanceof TopLevelElement && parentType instanceof FeatureAssociationRole) {
            final Object sct = getType(typeName, stack);
            if (sct instanceof FeatureType) {
                FeatureType type = new FeatureTypeBuilder().setSuperTypes((FeatureType) sct).setName(name).build();
                parentType = new FeatureTypeBuilder().addAssociation(type).setName(name).build();
            }
        }
        return reDefine(parentType, name, minMax[0], minMax[1], element.isNillable());
    }
    if (refType != null) {
        return reDefine(refType, name, minMax[0], minMax[1], element.isNillable());
    }
    final LocalSimpleType simpleType = element.getSimpleType();
    if (simpleType != null) {
        final PropertyType restrictionType = toProperty(simpleType, stack);
        return reDefine(restrictionType, name, minMax[0], minMax[1], element.isNillable());
    }
    final LocalComplexType complexType = element.getComplexType();
    if (complexType != null) {
        final FeatureTypeBuilder ftb = new FeatureTypeBuilder((FeatureType) getType(namespaceURI, complexType, stack, false));
        ftb.setName(name);
        if (element.isNillable()) {
            ftb.addAttribute(GMLConvention.NILLABLE_CHARACTERISTIC);
        }
        return new DefaultAssociationRole(Collections.singletonMap("name", name), ftb.build(), minMax[0], minMax[1]);
    }
    if (element.isAbstract()) {
        // create an abstract feature type with nothing in it
        final FeatureTypeBuilder ftb = new FeatureTypeBuilder();
        ftb.setName(name);
        ftb.setAbstract(true);
        if (element.isNillable()) {
            ftb.addAttribute(GMLConvention.NILLABLE_CHARACTERISTIC);
        }
        return new DefaultAssociationRole(Collections.singletonMap("name", name), ftb.build(), minMax[0], minMax[1]);
    } else {
        throw new UnsupportedOperationException("No type defined for " + element);
    }
}

Example 14 with FeatureAssociationRole

use of org.opengis.feature.FeatureAssociationRole in project geotoolkit by Geomatys.

the class PostgresVersionControl method trim.

private void trim(final String schemaName, final FeatureType type, final Date date, final Set<FeatureType> visited) throws VersioningException {
    if (visited.contains(type))
        return;
    visited.add(type);
    final String tableName = type.getName().tip().toString();
    // trim complex properties versioning
    for (PropertyType desc : type.getProperties(true)) {
        if (desc instanceof FeatureAssociationRole) {
            // complex type, trim sub table history
            FeatureAssociationRole far = (FeatureAssociationRole) desc;
            trim(schemaName, far.getValueType(), date, visited);
        }
    }
    Connection cnx = null;
    Statement stmt = null;
    ResultSet rs = null;
    try {
        cnx = featureStore.getDataSource().getConnection();
        stmt = cnx.createStatement();
        final StringBuilder sb = new StringBuilder("SELECT \"HSX_TrimHistory\"(");
        sb.append('\'');
        if (schemaName != null && !schemaName.isEmpty()) {
            sb.append(schemaName).append('.');
        }
        sb.append(tableName);
        sb.append('\'');
        sb.append(", TIMESTAMP '");
        sb.append(new Timestamp(date.getTime()).toString());
        sb.append("');");
        rs = stmt.executeQuery(sb.toString());
    } catch (SQLException ex) {
        throw new VersioningException(ex.getMessage(), ex);
    } finally {
        JDBCFeatureStoreUtilities.closeSafe(featureStore.getLogger(), cnx, stmt, null);
    }
}

Example 15 with FeatureAssociationRole

use of org.opengis.feature.FeatureAssociationRole in project geotoolkit by Geomatys.

the class PostgresVersionControl method revert.

private void revert(final String schemaName, final FeatureType type, final Date date, final Set<FeatureType> visited) throws VersioningException {
    if (visited.contains(type))
        return;
    visited.add(type);
    final String tableName = type.getName().tip().toString();
    // revert complex properties versioning
    for (PropertyType desc : type.getProperties(true)) {
        if (desc instanceof FeatureAssociationRole) {
            // complex type, revert sub table history
            FeatureAssociationRole far = (FeatureAssociationRole) desc;
            revert(schemaName, far.getValueType(), date, visited);
        }
    }
    Connection cnx = null;
    Statement stmt = null;
    ResultSet rs = null;
    try {
        cnx = featureStore.getDataSource().getConnection();
        stmt = cnx.createStatement();
        final StringBuilder sb = new StringBuilder("SELECT \"HSX_RevertHistory\"(");
        sb.append('\'');
        if (schemaName != null && !schemaName.isEmpty()) {
            sb.append(schemaName).append('.');
        }
        sb.append(tableName);
        sb.append('\'');
        sb.append(", TIMESTAMP '");
        sb.append(new Timestamp(date.getTime()).toString());
        sb.append("');");
        rs = stmt.executeQuery(sb.toString());
    } catch (SQLException ex) {
        throw new VersioningException(ex.getMessage(), ex);
    } finally {
        JDBCFeatureStoreUtilities.closeSafe(featureStore.getLogger(), cnx, stmt, null);
    }
}