GML Application Schemas

Document Sample
GML Application Schemas Powered By Docstoc
					Working with GML Application Schemas

      Milan Trnini}, Galdos Systems,
                    Inc.
           mtrninic@galdosinc.com

                                    GML Dev Days, July 2002
        Introduction

Purpose of the experiment: Analyze whether working
with GML application schemas is hard/easy/feasible.
Application schema abstraction – what does it mean,
what is its purpose?
Different uses of GML application schema
Information captured in GML application schemas.
API for working with GML application schemas.



                                          GML Dev Days, July 2002
       GML Application Schemas

Intention of GML is to be base for creating applications
in different domains.
This is achieved by GML and XMLSchema extensibility
mechanisms.
Example of GML extension mechanism: type
information in tag name.
GML occupies one level of abstraction.
Application schema is built on top of it as another level.


                                             GML Dev Days, July 2002
             GML Application Schemas
GML Application Schemas
                                               Logistical
                    Transportation

                                        Utilities
            Location Service                                Network


GML
          Feature      Geometries         Topology            Other types…



W3C                                  Strings        Other types…
                     Numbers


                                                                   GML Dev Days, July 2002
                Multiple Application Layers
Transportati
                                                   Route
on Services                 Route
                                                   finder

Transportatio
n Primitives    Road Segment        Intersection       Event           Other …
and
operations
GML
                  Feature       Geometries         Topology        Temporal



W3C                                   Strings      Other types…
                     Numbers


                                                                  GML Dev Days, July 2002
             Class Hierarchy
Objects from one layer are used                       Feature
to compose or create objects in a
higher layer.
Use XML mechanisms: type
extension substitution,               Road Segment   Intersection     Event
sequencing, choices, etc.
Use GML mechanisms:
collections, associations, feature-
                                                                     Accident
property model, etc.                      Route

Objects in different layers have
different
scope/meaning/semantics.


                                                                GML Dev Days, July 2002
              XML and GML Types

                            GML instance

<app:roadNetworkMember>
 <app:RoadSegment/>
  <gml:centerLineOf>
   <gml:LineString>
    <gml:coordinates>300.003,1234.232 306.234, 1235.090</gml:coordinates>
   </gml:LineString>
  </gml:centerLineOf>
  <app:otherProperty>…</app:otherProperty>
 </app:RoadSegment>
</app:roadNetworkMember>




                                                            GML Dev Days, July 2002
                  XML and GML Types
                           GML application schema

<xsd:element name=“RoadSegment” type=“app:RoadSegmentType”
substitutionGroup=“_Feature”/>

<xsd:complexType name=“RoadSegmentType”>
 <xsd:complexContent>
  <xsd:extension base=“gml:AbstractFeatureType”/>
 </xsd:complexContent>
</xsd:complexType>

                 We don’t care about XMLSchema types.
                 Element declarations are our GML types.



                                                             GML Dev Days, July 2002
                GML Types Names

                          GML instance
<app:qwe>
 <app:XYZ/>
  <app:abc>
   <app:ASD>
    <gml:coordinates>300.003,1234.232 306.234, 1235.090</gml:coordinates>
   </app:ASD>
  </app:abc>
  <app:otherProperty>…</app:otherProperty>
 </app:XYZ>
</app:qwe>




                                                               GML Dev Days, July 2002
                  GML Types Names

                           GML application schema

<xsd:element name=“XYZ” type=“app:XYZType” substitutionGroup=“gml:_Feature”/>

<xsd:complexType name=“XYZType”>
 <xsd:complexContent>
  <xsd:extension base=“gml:AbstractFeatureType”/>
 </xsd:complexContent>
</xsd:complexType>

                GML types names in themselves do not mean
                anything!!


                                                                 GML Dev Days, July 2002
        Applications and Schemas
What do applications need from the schemas?
A piece of semantics is needed in order to
know what to do with the data. Not all of it.
What is semantics? How do we find it? Set of
base “primitives” used to compare artifacts and
draw conclusions about them.
Semantics in schemas: type hierarchy, model
(feature – property), metadata.

                                      GML Dev Days, July 2002
          Captured “knowledge”


The “knowledge” exists in the schemas.
Different uses and types of the “knowledge”:
  Information about content or structure of types
  Information about types semantics – type hierarchy.
  Information from the GML model – we care about this
  Information from XMLSchema model - concerning schema
  validation




                                                  GML Dev Days, July 2002
        Semantics

Again – what do we need?
“Understanding” of arbitrary schema?
“Understanding” and processing of arbitrary
features?
Understanding always comes down to very
simple comparisons of strings (or other types).
Semantics by metadata – same thing.

                                      GML Dev Days, July 2002
           Schema Validator
For this purpose all the information from the schema is
needed, and it has to be interpreted correctly according
to the XMLSchema specification.
XML Schema specification is fairly complex.
Validating schemas means implementing all details
from XML Schema Specification (example: derivation
by restriction)
Not an easy task.
Performance issues are complex (depends on the
application where validator is used).

                                             GML Dev Days, July 2002
            GML Application Schema Parser
                 (Content Examiner)
Easier task than validating.
Some assumptions can be made:
   A client application will get a valid data
   If that is not the case, client can only report the error, no need to
   analyze it according to the XMLSchema specification.
   Client is interested only in content, if available.
No need to implement the whole specification – it is ok
to assume and hardcode some things.
Errors might not be very precise.


                                                              GML Dev Days, July 2002
        Uses of GML Application Schema
                    Parser

In all standard applications that use GML data such as
map portrayal applications, geocoders, gazetteers, etc.
GML data editors that provide content guidance.
GML application schema editors that provide content
guidance.
Applications for mapping of different data models.
Hard to remodel existing schemas.


                                            GML Dev Days, July 2002
                       Code Example
                       Vector getFeatures(Document gmlData)
                       {
                         Vector result;
                         NodeList nodes = gmlData.getDocumentElement().getChildren();
                         for (int index = 0; index < nodes.getLength(); index++)
                         {
                            Node property = nodes.get(index);
                            boolean isFeatureMember = _schemaParser.isFeatureMember(property);
                            if (isFeatureMember == false) continue;
                            Node value = property.getFirstChild();
                            boolean isFeature = _schemaParser.isFeature(value);
                            if (isFeature == true) result.add(value);
                         }
                         return result;
                       }

boolean isFeature(Node node)
{
  return ((getSubstitutionGroup(node) == “_Feature”) && (getBaseType == “AbstractFeatureType”));
}


                                                                               GML Dev Days, July 2002
                        Multiple Application Layers
<app:roadNetworkMember>
 <app:RoadConstruction/>
  <gml:centerLineOf>
   <gml:LineString>
    <gml:coordinates>300.003,1234.232 306.234, 1235.090</gml:coordinates>
   </gml:LineString>
  </gml:centerLineOf>
  <app:otherProperty>…</app:otherProperty>
 </app:RoadConstruction>
</app:roadNetworkMember>

<xsd:element name=“RoadConstruction” type=“RoadConstructionType” substitutionGroup=“RoadSegment”/>
<xsd:complexType name=“app:RoadConstructionType”>
 <xsd:complexContent>
  <xsd:extension base=“app:RoadSegmentType”/>
 </xsd:complexContent>
</xsd:complexType>


     This means only little more work for the parser – complexity is linear!


                                                                                     GML Dev Days, July 2002
         GML Application Schema Parser
                      API
Type functions       Content retrieval
  isFeature             getFeatures
  isFeatureMember       getGeometry
  isGeometry            getProperties
  isOfType              allowedFeatures
  etc .
                        allowedProperties
                        allowedGeometries
Miscellaneous           etc.
  getCardinality
  etc.


                                     GML Dev Days, July 2002
          GML Level of Abstraction


Work with features, geometries, feature members etc.
Not concerned about XMLSchema types, elements,
etc.
Use the same paradigm and model with different data
description languages (RDF, …).




                                           GML Dev Days, July 2002
         Performance

Verbosity of XML/GML.
Use of existing tools.
Schema parser data model – new DOM, tables and
arrays.
Solutions overlap with the ones regarding any XML
processing.
Not a bigger issue than processing of instance
documents (example - processing of Simple Xlinks).


                                         GML Dev Days, July 2002
          Summary

Extensibility and semantics on the level of the
application schemas achieved using simple methods –
type extension.
Validator needs to perform deep and extensive
analysis of the schema – it has to follow the
specification which can be (and often is) complex.
Content examiner needs to follow type hierarchy,
metadata information etc., which is simple –
comparable to processing instance documents.
Physical complexity of schemas is not the same as the
complexity of XMLSchema specification and except for
the basics does not mirror it.
                                           GML Dev Days, July 2002
                References

XMLSchema specification
http://www.w3c.org/TR/xmlschema-0/

GML 2.1 specification
http://www.opengis.net/gml/02-009/GML2-11.html

Schema Infoset
http://www.research.ibm.com/XML/schema/WD-XML-Schema-Infoset-API-Req.htm

GML model (specification, papers)
GML4J
http://gml4j.sourceforge.net




                                                         GML Dev Days, July 2002

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:11/12/2012
language:Unknown
pages:23
About Good!!!NICE!!! The best document database!