+ *
+ * @param expr
+ * A valid XPath 1.0 expression.
+ * @param context
+ * The context node.
+ * @param namespaceBindings
+ * A collection of namespace bindings for the XPath expression,
+ * where each entry maps a namespace URI (key) to a prefix
+ * (value). It may be {@code null}.
+ */
+ public static void assertXPath(String expr, Node context, Map namespaceBindings) {
+ if (null == context) {
+ throw new NullPointerException("Context node is null.");
+ }
+ NamespaceBindings bindings = NamespaceBindings.withStandardBindings();
+ bindings.addAllBindings(namespaceBindings);
+ XPath xpath = XPathFactory.newInstance().newXPath();
+ xpath.setNamespaceContext(bindings);
+ Boolean result;
+ try {
+ result = (Boolean) xpath.evaluate(expr, context, XPathConstants.BOOLEAN);
+ } catch (XPathExpressionException xpe) {
+ String msg = ErrorMessage.format(ErrorMessageKeys.XPATH_ERROR, expr);
+ LOGR.log(Level.WARNING, msg, xpe);
+ throw new AssertionError(msg);
+ }
+ Element elemNode;
+ if (Document.class.isInstance(context)) {
+ elemNode = Document.class.cast(context).getDocumentElement();
+ } else {
+ elemNode = (Element) context;
+ }
+ Assert.assertTrue(result, ErrorMessage.format(ErrorMessageKeys.XPATH_RESULT, elemNode.getNodeName(), expr));
+ }
+
+ /**
+ * Asserts that an XML resource is schema-valid.
+ *
+ * @param validator
+ * The Validator to use.
+ * @param source
+ * The XML Source to be validated.
+ */
+ public static void assertSchemaValid(Validator validator, Source source) {
+ ValidationErrorHandler errHandler = new ValidationErrorHandler();
+ validator.setErrorHandler(errHandler);
+ try {
+ validator.validate(source);
+ } catch (Exception e) {
+ throw new AssertionError(ErrorMessage.format(ErrorMessageKeys.XML_ERROR, e.getMessage()));
+ }
+ Assert.assertFalse(errHandler.errorsDetected(), ErrorMessage.format(ErrorMessageKeys.NOT_SCHEMA_VALID,
+ errHandler.getErrorCount(), errHandler.toString()));
+ }
+
+ /**
+ * Asserts that an XML resource satisfies all applicable constraints defined
+ * for the specified phase in a Schematron (ISO 19757-3) schema. The "xslt2"
+ * query language binding is supported. Two phase names have special
+ * meanings:
+ *
+ *
"#ALL": All patterns are active
+ *
"#DEFAULT": The phase identified by the defaultPhase attribute on the
+ * schema element should be used.
+ *
+ *
+ * @param schemaRef
+ * A URL that denotes the location of a Schematron schema.
+ * @param xmlSource
+ * The XML Source to be validated.
+ * @param activePhase
+ * The active phase (pattern set) whose patterns are used for
+ * validation; this is set to "#ALL" if not specified.
+ */
+ public static void assertSchematronValid(URL schemaRef, Source xmlSource, String activePhase) {
+ String phase = (null == activePhase || activePhase.isEmpty()) ? "#ALL" : activePhase;
+ SchematronValidator validator;
+ try {
+ validator = new SchematronValidator(new StreamSource(schemaRef.toString()), phase);
+ } catch (Exception e) {
+ StringBuilder msg = new StringBuilder("Failed to process Schematron schema at ");
+ msg.append(schemaRef).append('\n');
+ msg.append(e.getMessage());
+ throw new AssertionError(msg);
+ }
+ DOMResult result = (DOMResult) validator.validate(xmlSource);
+ Assert.assertFalse(validator.ruleViolationsDetected(), ErrorMessage.format(ErrorMessageKeys.NOT_SCHEMA_VALID,
+ validator.getRuleViolationCount(), XMLUtils.writeNodeToString(result.getNode())));
+ }
+
+ /**
+ * Asserts that the given XML entity contains the expected number of
+ * descendant elements having the specified name.
+ *
+ * @param xmlEntity
+ * A Document representing an XML entity.
+ * @param elementName
+ * The qualified name of the element.
+ * @param expectedCount
+ * The expected number of occurrences.
+ */
+ public static void assertDescendantElementCount(Document xmlEntity, QName elementName, int expectedCount) {
+ NodeList features = xmlEntity.getElementsByTagNameNS(elementName.getNamespaceURI(), elementName.getLocalPart());
+ Assert.assertEquals(features.getLength(), expectedCount,
+ String.format("Unexpected number of %s descendant elements.", elementName));
+ }
+
+ /**
+ * Asserts that the given response message contains an OGC exception report.
+ * The message body must contain an XML document that has a document element
+ * with the following properties:
+ *
+ *
+ *
+ * @param rsp
+ * A ClientResponse object representing an HTTP response message.
+ * @param exceptionCode
+ * The expected OGC exception code.
+ * @param locator
+ * A case-insensitive string value expected to occur in the
+ * locator attribute (e.g. a parameter name); the attribute value
+ * will be ignored if the argument is null or empty.
+ */
+ public static void assertExceptionReport(ClientResponse rsp, String exceptionCode, String locator) {
+ Assert.assertEquals(rsp.getStatus(), ClientResponse.Status.BAD_REQUEST.getStatusCode(),
+ ErrorMessage.get(ErrorMessageKeys.UNEXPECTED_STATUS));
+ Document doc = rsp.getEntity(Document.class);
+ String expr = String.format("//ows:Exception[@exceptionCode = '%s']", exceptionCode);
+ NodeList nodeList = null;
+ try {
+ nodeList = XMLUtils.evaluateXPath(doc, expr, null);
+ } catch (XPathExpressionException xpe) {
+ // won't happen
+ }
+ Assert.assertTrue(nodeList.getLength() > 0, "Exception not found in response: " + expr);
+ if (null != locator && !locator.isEmpty()) {
+ Element exception = (Element) nodeList.item(0);
+ String locatorValue = exception.getAttribute("locator").toLowerCase();
+ Assert.assertTrue(locatorValue.contains(locator.toLowerCase()),
+ String.format("Expected locator attribute to contain '%s']", locator));
+ }
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/ErrorMessage.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/ErrorMessage.java
new file mode 100644
index 0000000..8fca8d5
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/ErrorMessage.java
@@ -0,0 +1,49 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+import java.text.MessageFormat;
+import java.util.ResourceBundle;
+
+/**
+ * Utility class for retrieving and formatting localized error messages that
+ * describe failed assertions.
+ */
+public class ErrorMessage {
+
+ private static final String BASE_NAME =
+ "org.opengis.cite.ogcapiprocesses10.MessageBundle";
+ private static ResourceBundle msgResources =
+ ResourceBundle.getBundle(BASE_NAME);
+
+ /**
+ * Produces a formatted error message using the supplied substitution
+ * arguments and the current locale. The arguments should reflect the order
+ * of the placeholders in the message template.
+ *
+ * @param msgKey
+ * The key identifying the message template; it should be a
+ * member of {@code ErrorMessageKeys}.
+ * @param args
+ * An array of arguments to be formatted and substituted in the
+ * content of the message.
+ * @return A String containing the message content. If no message is found
+ * for the given key, a {@link java.util.MissingResourceException}
+ * is thrown.
+ */
+ public static String format(String msgKey, Object... args) {
+ return MessageFormat.format(msgResources.getString(msgKey), args);
+ }
+
+ /**
+ * Retrieves a simple message according to the current locale.
+ *
+ * @param msgKey
+ * The key identifying the message; it should be a member of
+ * {@code ErrorMessageKeys}.
+ * @return A String containing the message content. If no message is found
+ * for the given key, a {@link java.util.MissingResourceException}
+ * is thrown.
+ */
+ public static String get(String msgKey) {
+ return msgResources.getString(msgKey);
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/ErrorMessageKeys.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/ErrorMessageKeys.java
new file mode 100644
index 0000000..ee0cf1b
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/ErrorMessageKeys.java
@@ -0,0 +1,22 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+/**
+ * Defines keys used to access localized messages for assertion errors. The
+ * messages are stored in Properties files that are encoded in ISO-8859-1
+ * (Latin-1). For some languages the {@code native2ascii} tool must be used to
+ * process the files and produce escaped Unicode characters.
+ */
+public class ErrorMessageKeys {
+
+ public static final String NOT_SCHEMA_VALID = "NotSchemaValid";
+ public static final String EMPTY_STRING = "EmptyString";
+ public static final String XPATH_RESULT = "XPathResult";
+ public static final String NAMESPACE_NAME = "NamespaceName";
+ public static final String LOCAL_NAME = "LocalName";
+ public static final String XML_ERROR = "XMLError";
+ public static final String XPATH_ERROR = "XPathError";
+ public static final String MISSING_INFOSET_ITEM = "MissingInfosetItem";
+ public static final String UNEXPECTED_STATUS = "UnexpectedStatus";
+ public static final String UNEXPECTED_MEDIA_TYPE = "UnexpectedMediaType";
+ public static final String MISSING_ENTITY = "MissingEntity";
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/Namespaces.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/Namespaces.java
new file mode 100644
index 0000000..b7f30c2
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/Namespaces.java
@@ -0,0 +1,31 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+import java.net.URI;
+
+/**
+ * XML namespace names.
+ *
+ * @see Namespaces in XML 1.0
+ *
+ */
+public class Namespaces {
+
+ private Namespaces() {
+ }
+
+ /** SOAP 1.2 message envelopes. */
+ public static final String SOAP_ENV = "http://www.w3.org/2003/05/soap-envelope";
+ /** W3C XLink */
+ public static final String XLINK = "http://www.w3.org/1999/xlink";
+ /** OGC 06-121r3 (OWS 1.1) */
+ public static final String OWS = "http://www.opengis.net/ows/1.1";
+ /** ISO 19136 (GML 3.2) */
+ public static final String GML = "http://www.opengis.net/gml/3.2";
+ /** W3C XML Schema namespace */
+ public static final URI XSD = URI
+ .create("http://www.w3.org/2001/XMLSchema");
+ /** Schematron (ISO 19757-3) namespace */
+ public static final URI SCH = URI
+ .create("http://purl.oclc.org/dsdl/schematron");
+
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/ReusableEntityFilter.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/ReusableEntityFilter.java
new file mode 100644
index 0000000..cc85b25
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/ReusableEntityFilter.java
@@ -0,0 +1,26 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+import com.sun.jersey.api.client.ClientHandlerException;
+import com.sun.jersey.api.client.ClientRequest;
+import com.sun.jersey.api.client.ClientResponse;
+import com.sun.jersey.api.client.filter.ClientFilter;
+
+/**
+ * Buffers the (response) entity so it can be read multiple times.
+ *
+ *
WARNING: The entity InputStream must be reset after each
+ * read attempt.
+ */
+public class ReusableEntityFilter extends ClientFilter {
+
+ @Override
+ public ClientResponse handle(ClientRequest req) throws ClientHandlerException {
+ // leave request entity--it can usually be read multiple times
+ ClientResponse rsp = getNext().handle(req);
+ if (rsp.hasEntity()) {
+ rsp.bufferEntity();
+ }
+ return rsp;
+ }
+
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/SuiteAttribute.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/SuiteAttribute.java
new file mode 100644
index 0000000..02d4c79
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/SuiteAttribute.java
@@ -0,0 +1,50 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+import com.sun.jersey.api.client.Client;
+
+import java.io.File;
+
+import org.w3c.dom.Document;
+
+/**
+ * An enumerated type defining ISuite attributes that may be set to constitute a
+ * shared test fixture.
+ */
+@SuppressWarnings("rawtypes")
+public enum SuiteAttribute {
+
+ /**
+ * A client component for interacting with HTTP endpoints.
+ */
+ CLIENT("httpClient", Client.class),
+ /**
+ * A DOM Document that represents the test subject or metadata about it.
+ */
+ TEST_SUBJECT("testSubject", Document.class),
+ /**
+ * A File containing the test subject or a description of it.
+ */
+ TEST_SUBJ_FILE("testSubjectFile", File.class);
+ private final Class attrType;
+ private final String attrName;
+
+ private SuiteAttribute(String attrName, Class attrType) {
+ this.attrName = attrName;
+ this.attrType = attrType;
+ }
+
+ public Class getType() {
+ return attrType;
+ }
+
+ public String getName() {
+ return attrName;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder(attrName);
+ sb.append('(').append(attrType.getName()).append(')');
+ return sb.toString();
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/SuiteFixtureListener.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/SuiteFixtureListener.java
new file mode 100644
index 0000000..6d0eb02
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/SuiteFixtureListener.java
@@ -0,0 +1,121 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Map;
+import java.util.logging.Level;
+
+import org.opengis.cite.ogcapiprocesses10.util.ClientUtils;
+import org.opengis.cite.ogcapiprocesses10.util.TestSuiteLogger;
+import org.opengis.cite.ogcapiprocesses10.util.URIUtils;
+import org.opengis.cite.ogcapiprocesses10.util.XMLUtils;
+import org.testng.ISuite;
+import org.testng.ISuiteListener;
+import org.w3c.dom.Document;
+
+import com.sun.jersey.api.client.Client;
+
+/**
+ * A listener that performs various tasks before and after a test suite is run,
+ * usually concerned with maintaining a shared test suite fixture. Since this
+ * listener is loaded using the ServiceLoader mechanism, its methods will be
+ * called before those of other suite listeners listed in the test suite
+ * definition and before any annotated configuration methods.
+ *
+ * Attributes set on an ISuite instance are not inherited by constituent test
+ * group contexts (ITestContext). However, suite attributes are still accessible
+ * from lower contexts.
+ *
+ * @see org.testng.ISuite ISuite interface
+ */
+public class SuiteFixtureListener implements ISuiteListener {
+
+ @Override
+ public void onStart(ISuite suite) {
+ processSuiteParameters(suite);
+ registerClientComponent(suite);
+ }
+
+ @Override
+ public void onFinish(ISuite suite) {
+ if (null != System.getProperty("deleteSubjectOnFinish")) {
+ deleteTempFiles(suite);
+ System.getProperties().remove("deleteSubjectOnFinish");
+ }
+ }
+
+ /**
+ * Processes test suite arguments and sets suite attributes accordingly. The
+ * entity referenced by the {@link TestRunArg#IUT iut} argument is retrieved
+ * and written to a File that is set as the value of the suite attribute
+ * {@link SuiteAttribute#TEST_SUBJ_FILE testSubjectFile}.
+ *
+ * @param suite
+ * An ISuite object representing a TestNG test suite.
+ */
+ void processSuiteParameters(ISuite suite) {
+ Map params = suite.getXmlSuite().getParameters();
+ TestSuiteLogger.log(Level.CONFIG, "Suite parameters\n" + params.toString());
+ String iutParam = params.get(TestRunArg.IUT.toString());
+ if ((null == iutParam) || iutParam.isEmpty()) {
+ throw new IllegalArgumentException("Required test run parameter not found: " + TestRunArg.IUT.toString());
+ }
+ URI iutRef = URI.create(iutParam.trim());
+ File entityFile = null;
+ try {
+ entityFile = URIUtils.dereferenceURI(iutRef);
+ } catch (IOException iox) {
+ throw new RuntimeException("Failed to dereference resource located at " + iutRef, iox);
+ }
+ TestSuiteLogger.log(Level.FINE, String.format("Wrote test subject to file: %s (%d bytes)",
+ entityFile.getAbsolutePath(), entityFile.length()));
+ suite.setAttribute(SuiteAttribute.TEST_SUBJ_FILE.getName(), entityFile);
+ Document iutDoc = null;
+ try {
+ iutDoc = URIUtils.parseURI(entityFile.toURI());
+ } catch (Exception x) {
+ throw new RuntimeException("Failed to parse resource retrieved from " + iutRef, x);
+ }
+ suite.setAttribute(SuiteAttribute.TEST_SUBJECT.getName(), iutDoc);
+ if (TestSuiteLogger.isLoggable(Level.FINE)) {
+ StringBuilder logMsg = new StringBuilder("Parsed resource retrieved from ");
+ logMsg.append(iutRef).append("\n");
+ logMsg.append(XMLUtils.writeNodeToString(iutDoc));
+ TestSuiteLogger.log(Level.FINE, logMsg.toString());
+ }
+ }
+
+ /**
+ * A client component is added to the suite fixture as the value of the
+ * {@link SuiteAttribute#CLIENT} attribute; it may be subsequently accessed
+ * via the {@link org.testng.ITestContext#getSuite()} method.
+ *
+ * @param suite
+ * The test suite instance.
+ */
+ void registerClientComponent(ISuite suite) {
+ Client client = ClientUtils.buildClient();
+ if (null != client) {
+ suite.setAttribute(SuiteAttribute.CLIENT.getName(), client);
+ }
+ }
+
+ /**
+ * Deletes temporary files created during the test run if TestSuiteLogger is
+ * enabled at the INFO level or higher (they are left intact at the CONFIG
+ * level or lower).
+ *
+ * @param suite
+ * The test suite.
+ */
+ void deleteTempFiles(ISuite suite) {
+ if (TestSuiteLogger.isLoggable(Level.CONFIG)) {
+ return;
+ }
+ File testSubjFile = (File) suite.getAttribute(SuiteAttribute.TEST_SUBJ_FILE.getName());
+ if (testSubjFile.exists()) {
+ testSubjFile.delete();
+ }
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/SuitePreconditions.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/SuitePreconditions.java
new file mode 100644
index 0000000..bfdb165
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/SuitePreconditions.java
@@ -0,0 +1,39 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.testng.ITestContext;
+import org.testng.annotations.BeforeSuite;
+
+/**
+ * Checks that various preconditions are satisfied before the test suite is run.
+ * If any of these (BeforeSuite) methods fail, all tests will be skipped.
+ */
+public class SuitePreconditions {
+
+ private static final Logger LOGR = Logger.getLogger(SuitePreconditions.class.getName());
+
+ /**
+ * Verifies that the referenced test subject exists and has the expected
+ * type.
+ *
+ * @param testContext
+ * Information about the (pending) test run.
+ */
+ @BeforeSuite
+ @SuppressWarnings("rawtypes")
+ public void verifyTestSubject(ITestContext testContext) {
+ SuiteAttribute testFileAttr = SuiteAttribute.TEST_SUBJ_FILE;
+ Object sutObj = testContext.getSuite().getAttribute(testFileAttr.getName());
+ Class expectedType = testFileAttr.getType();
+ if (null != sutObj && expectedType.isInstance(sutObj)) {
+ // TODO: Verify test subject
+ } else {
+ String msg = String.format("Value of test suite attribute '%s' is missing or is not an instance of %s",
+ testFileAttr.getName(), expectedType.getName());
+ LOGR.log(Level.SEVERE, msg);
+ throw new AssertionError(msg);
+ }
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/TestFailureListener.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/TestFailureListener.java
new file mode 100644
index 0000000..b39d489
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/TestFailureListener.java
@@ -0,0 +1,97 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+import com.sun.jersey.api.client.ClientRequest;
+import com.sun.jersey.api.client.ClientResponse;
+import java.nio.charset.StandardCharsets;
+import javax.ws.rs.core.MediaType;
+import org.opengis.cite.ogcapiprocesses10.util.ClientUtils;
+import org.opengis.cite.ogcapiprocesses10.util.XMLUtils;
+import org.testng.ITestResult;
+import org.testng.TestListenerAdapter;
+import org.w3c.dom.Document;
+
+/**
+ * A listener that augments a test result with diagnostic information in the
+ * event that a test method failed. This information will appear in the XML
+ * report when the test run is completed.
+ */
+public class TestFailureListener extends TestListenerAdapter {
+
+ /**
+ * Sets the "request" and "response" attributes of a test result. The value
+ * of these attributes is a string that contains information about the
+ * content of an outgoing or incoming message: target resource, status code,
+ * headers, entity (if present). The entity is represented as a String with
+ * UTF-8 character encoding.
+ *
+ * @param result A description of a test result (with a fail verdict).
+ */
+ @Override
+ public void onTestFailure(ITestResult result) {
+ super.onTestFailure(result);
+ Object instance = result.getInstance();
+ if (CommonFixture.class.isInstance(instance)) {
+ CommonFixture fixture = CommonFixture.class.cast(instance);
+ result.setAttribute("request", getRequestMessageInfo(fixture.request));
+ result.setAttribute("response", getResponseMessageInfo(fixture.response));
+ }
+ }
+
+ /**
+ * Gets diagnostic information about a request message. If the request
+ * contains a message body, it should be represented as a DOM Document node
+ * or as an object having a meaningful toString() implementation.
+ *
+ * @param req An object representing an HTTP request message.
+ * @return A string containing information gleaned from the request message.
+ */
+ String getRequestMessageInfo(ClientRequest req) {
+ if (null == req) {
+ return "No request message.";
+ }
+ StringBuilder msgInfo = new StringBuilder();
+ msgInfo.append("Method: ").append(req.getMethod()).append('\n');
+ msgInfo.append("Target URI: ").append(req.getURI()).append('\n');
+ msgInfo.append("Headers: ").append(req.getHeaders()).append('\n');
+ if (null != req.getEntity()) {
+ Object entity = req.getEntity();
+ String body;
+ if (Document.class.isInstance(entity)) {
+ Document doc = Document.class.cast(entity);
+ body = XMLUtils.writeNodeToString(doc);
+ } else {
+ body = entity.toString();
+ }
+ msgInfo.append(body).append('\n');
+ }
+ return msgInfo.toString();
+ }
+
+ /**
+ * Gets diagnostic information about a response message.
+ *
+ * @param rsp An object representing an HTTP response message.
+ * @return A string containing information gleaned from the response
+ * message.
+ */
+ String getResponseMessageInfo(ClientResponse rsp) {
+ if (null == rsp) {
+ return "No response message.";
+ }
+ StringBuilder msgInfo = new StringBuilder();
+ msgInfo.append("Status: ").append(rsp.getStatus()).append('\n');
+ msgInfo.append("Headers: ").append(rsp.getHeaders()).append('\n');
+ if (rsp.hasEntity()) {
+ if (rsp.getType().isCompatible(MediaType.APPLICATION_XML_TYPE)) {
+ Document doc = ClientUtils.getResponseEntityAsDocument(rsp, null);
+ msgInfo.append(XMLUtils.writeNodeToString(doc));
+ } else {
+ byte[] body = rsp.getEntity(byte[].class);
+ msgInfo.append(new String(body, StandardCharsets.UTF_8));
+ }
+ msgInfo.append('\n');
+ }
+ return msgInfo.toString();
+ }
+
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/TestNGController.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/TestNGController.java
new file mode 100644
index 0000000..3345596
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/TestNGController.java
@@ -0,0 +1,169 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.logging.Level;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.transform.Source;
+
+import org.opengis.cite.ogcapiprocesses10.util.TestSuiteLogger;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.ParameterException;
+import com.occamlab.te.spi.executors.TestRunExecutor;
+import com.occamlab.te.spi.executors.testng.TestNGExecutor;
+import com.occamlab.te.spi.jaxrs.TestSuiteController;
+
+/**
+ * Main test run controller oversees execution of TestNG test suites.
+ */
+public class TestNGController implements TestSuiteController {
+
+ private TestRunExecutor executor;
+ private Properties etsProperties = new Properties();
+
+ /**
+ * A convenience method for running the test suite using a command-line
+ * interface. The default values of the test run arguments are as follows:
+ *
+ *
XML properties file: ${user.home}/test-run-props.xml
+ *
+ * @param args
+ * Test run arguments (optional). The first argument must refer
+ * to an XML properties file containing the expected set of test
+ * run arguments. If no argument is supplied, the file located at
+ * ${user.home}/test-run-props.xml will be used.
+ * @throws Exception
+ * If the test run cannot be executed (usually due to
+ * unsatisfied pre-conditions).
+ */
+ public static void main(String[] args) throws Exception {
+ CommandLineArguments testRunArgs = new CommandLineArguments();
+ JCommander cmd = new JCommander(testRunArgs);
+ try {
+ cmd.parse(args);
+ } catch (ParameterException px) {
+ System.out.println(px.getMessage());
+ cmd.usage();
+ }
+ if (testRunArgs.doDeleteSubjectOnFinish()) {
+ System.setProperty("deleteSubjectOnFinish", "true");
+ }
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ File xmlArgs = testRunArgs.getPropertiesFile();
+ Document testRunProps = db.parse(xmlArgs);
+ TestNGController controller = new TestNGController(testRunArgs.getOutputDir());
+ Source testResults = controller.doTestRun(testRunProps);
+ System.out.println("Test results: " + testResults.getSystemId());
+ }
+
+ /**
+ * Default constructor uses the location given by the "java.io.tmpdir"
+ * system property as the root output directory.
+ */
+ public TestNGController() {
+ this(System.getProperty("java.io.tmpdir"));
+ }
+
+ /**
+ * Construct a controller that writes results to the given output directory.
+ *
+ * @param outputDir
+ * The location of the directory in which test results will be
+ * written (a file system path or a 'file' URI). It will be
+ * created if it does not exist.
+ */
+ public TestNGController(String outputDir) {
+ InputStream is = getClass().getResourceAsStream("ets.properties");
+ try {
+ this.etsProperties.load(is);
+ } catch (IOException ex) {
+ TestSuiteLogger.log(Level.WARNING, "Unable to load ets.properties. " + ex.getMessage());
+ }
+ URL tngSuite = TestNGController.class.getResource("testng.xml");
+ File resultsDir;
+ if (null == outputDir || outputDir.isEmpty()) {
+ resultsDir = new File(System.getProperty("user.home"));
+ } else if (outputDir.startsWith("file:")) {
+ resultsDir = new File(URI.create(outputDir));
+ } else {
+ resultsDir = new File(outputDir);
+ }
+ TestSuiteLogger.log(Level.CONFIG, "Using TestNG config: " + tngSuite);
+ TestSuiteLogger.log(Level.CONFIG, "Using outputDirPath: " + resultsDir.getAbsolutePath());
+ // NOTE: setting third argument to 'true' enables the default listeners
+ this.executor = new TestNGExecutor(tngSuite.toString(), resultsDir.getAbsolutePath(), false);
+ }
+
+ @Override
+ public String getCode() {
+ return etsProperties.getProperty("ets-code");
+ }
+
+ @Override
+ public String getVersion() {
+ return etsProperties.getProperty("ets-version");
+ }
+
+ @Override
+ public String getTitle() {
+ return etsProperties.getProperty("ets-title");
+ }
+
+ @Override
+ public Source doTestRun(Document testRunArgs) throws Exception {
+ validateTestRunArgs(testRunArgs);
+ return executor.execute(testRunArgs);
+ }
+
+ /**
+ * Validates the test run arguments. The test run is aborted if any of these
+ * checks fail.
+ *
+ * @param testRunArgs
+ * A DOM Document containing a set of XML properties (key-value
+ * pairs).
+ * @throws IllegalArgumentException
+ * If any arguments are missing or invalid for some reason.
+ */
+ void validateTestRunArgs(Document testRunArgs) {
+ if (null == testRunArgs || !testRunArgs.getDocumentElement().getNodeName().equals("properties")) {
+ throw new IllegalArgumentException("Input is not an XML properties document.");
+ }
+ NodeList entries = testRunArgs.getDocumentElement().getElementsByTagName("entry");
+ if (entries.getLength() == 0) {
+ throw new IllegalArgumentException("No test run arguments found.");
+ }
+ Map args = new HashMap();
+ for (int i = 0; i < entries.getLength(); i++) {
+ Element entry = (Element) entries.item(i);
+ args.put(entry.getAttribute("key"), entry.getTextContent());
+ }
+ if (!args.containsKey(TestRunArg.IUT.toString())) {
+ throw new IllegalArgumentException(
+ String.format("Missing argument: '%s' must be present.", TestRunArg.IUT));
+ }
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/TestRunArg.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/TestRunArg.java
new file mode 100644
index 0000000..200312f
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/TestRunArg.java
@@ -0,0 +1,18 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+/**
+ * An enumerated type defining all recognized test run arguments.
+ */
+public enum TestRunArg {
+
+ /**
+ * An absolute URI that refers to a representation of the test subject or
+ * metadata about it.
+ */
+ IUT;
+
+ @Override
+ public String toString() {
+ return name().toLowerCase();
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/TestRunListener.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/TestRunListener.java
new file mode 100644
index 0000000..c7eb1cb
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/TestRunListener.java
@@ -0,0 +1,26 @@
+package org.opengis.cite.ogcapiprocesses10;
+
+import org.testng.IExecutionListener;
+
+/**
+ * A listener that is invoked before and after a test run. It is often used to
+ * configure a shared fixture that endures for the duration of the entire test
+ * run. A FixtureManager may be used to manage such a fixture.
+ *
+ *
A shared fixture should be used with caution in order to avoid undesirable
+ * test interactions. In general, it should be populated with "read-only"
+ * objects that are not modified during the test run.
+ *
+ * @see com.occamlab.te.spi.executors.FixtureManager FixtureManager
+ *
+ */
+public class TestRunListener implements IExecutionListener {
+
+ @Override
+ public void onExecutionStart() {
+ }
+
+ @Override
+ public void onExecutionFinish() {
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/level1/Capability1Tests.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/level1/Capability1Tests.java
new file mode 100644
index 0000000..9acc478
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/level1/Capability1Tests.java
@@ -0,0 +1,95 @@
+package org.opengis.cite.ogcapiprocesses10.level1;
+
+import java.io.IOException;
+import java.net.URL;
+import javax.xml.transform.Source;
+import javax.xml.transform.dom.DOMSource;
+import org.opengis.cite.ogcapiprocesses10.CommonFixture;
+import org.opengis.cite.ogcapiprocesses10.ErrorMessage;
+import org.opengis.cite.ogcapiprocesses10.ErrorMessageKeys;
+import org.opengis.cite.ogcapiprocesses10.SuiteAttribute;
+import org.opengis.cite.validation.RelaxNGValidator;
+import org.opengis.cite.validation.ValidationErrorHandler;
+import org.testng.Assert;
+import org.testng.ITestContext;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+/**
+ * Includes various tests of capability 1.
+ */
+public class Capability1Tests extends CommonFixture {
+
+ private Document testSubject;
+
+ /**
+ * Obtains the test subject from the ISuite context. The suite attribute
+ * {@link org.opengis.cite.ogcapiprocesses10.SuiteAttribute#TEST_SUBJECT} should
+ * evaluate to a DOM Document node.
+ *
+ * @param testContext
+ * The test (group) context.
+ */
+ @BeforeClass
+ public void obtainTestSubject(ITestContext testContext) {
+ Object obj = testContext.getSuite().getAttribute(
+ SuiteAttribute.TEST_SUBJECT.getName());
+ if ((null != obj) && Document.class.isAssignableFrom(obj.getClass())) {
+ this.testSubject = Document.class.cast(obj);
+ }
+ }
+
+ /**
+ * Sets the test subject. This method is intended to facilitate unit
+ * testing.
+ *
+ * @param testSubject A Document node representing the test subject or
+ * metadata about it.
+ */
+ public void setTestSubject(Document testSubject) {
+ this.testSubject = testSubject;
+ }
+
+ /**
+ * Verifies the string is empty.
+ */
+ @Test(description = "Implements ATC 1-1")
+ public void isEmpty() {
+ String str = " foo ";
+ Assert.assertTrue(str.isEmpty(),
+ ErrorMessage.get(ErrorMessageKeys.EMPTY_STRING));
+ }
+
+ /**
+ * Checks the behavior of the trim function.
+ */
+ @Test(description = "Implements ATC 1-2")
+ public void trim() {
+ String str = " foo ";
+ Assert.assertTrue("foo".equals(str.trim()));
+ }
+
+ /**
+ * Verify the test subject is a valid Atom feed.
+ *
+ * @throws SAXException
+ * If the resource cannot be parsed.
+ * @throws IOException
+ * If the resource is not accessible.
+ */
+ @Test(description = "Implements ATC 1-3")
+ public void docIsValidAtomFeed() throws SAXException, IOException {
+ URL schemaRef = getClass().getResource(
+ "/org/opengis/cite/ogcapiprocesses10/rnc/atom.rnc");
+ RelaxNGValidator rngValidator = new RelaxNGValidator(schemaRef);
+ Source xmlSource = (null != testSubject)
+ ? new DOMSource(testSubject) : null;
+ rngValidator.validate(xmlSource);
+ ValidationErrorHandler err = rngValidator.getErrorHandler();
+ Assert.assertFalse(err.errorsDetected(),
+ ErrorMessage.format(ErrorMessageKeys.NOT_SCHEMA_VALID,
+ err.getErrorCount(), err.toString()));
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/level1/package-info.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/level1/package-info.java
new file mode 100644
index 0000000..d75c227
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/level1/package-info.java
@@ -0,0 +1,14 @@
+/**
+ * Conformance Level 1 includes basic facilities. The following capabilities
+ * must be supported:
+ *
+ *
Capability 1.1
+ *
Capability 1.2
+ *
Capability 1.3
+ *
+ *
+ * @see HTML5
+ * - Conformance classes
+ */
+package org.opengis.cite.ogcapiprocesses10.level1;
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/package-info.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/package-info.java
new file mode 100644
index 0000000..bbb908e
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/package-info.java
@@ -0,0 +1,8 @@
+/**
+ * The root package includes supporting classes of general utility such as the
+ * main controller, listeners, and reporters.
+ *
+ *
Subsidiary packages correspond to distinct test groups such as conformance
+ * classes.
+ */
+package org.opengis.cite.ogcapiprocesses10;
\ No newline at end of file
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/util/ClientUtils.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/ClientUtils.java
new file mode 100644
index 0000000..693766c
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/ClientUtils.java
@@ -0,0 +1,173 @@
+package org.opengis.cite.ogcapiprocesses10.util;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+import java.net.SocketAddress;
+import java.net.URL;
+
+import com.sun.jersey.api.client.Client;
+import com.sun.jersey.api.client.ClientRequest;
+import com.sun.jersey.api.client.ClientResponse;
+import com.sun.jersey.api.client.config.ClientConfig;
+import com.sun.jersey.api.client.config.DefaultClientConfig;
+import com.sun.jersey.api.client.filter.LoggingFilter;
+import com.sun.jersey.client.urlconnection.HttpURLConnectionFactory;
+import com.sun.jersey.client.urlconnection.URLConnectionClientHandler;
+import java.net.URI;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.ws.rs.HttpMethod;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.UriBuilder;
+import javax.xml.transform.Source;
+import javax.xml.transform.dom.DOMSource;
+import org.opengis.cite.ogcapiprocesses10.ReusableEntityFilter;
+import org.w3c.dom.Document;
+
+/**
+ * Provides various utility methods for creating and configuring HTTP client
+ * components.
+ */
+public class ClientUtils {
+
+ /**
+ * Builds a client component for interacting with HTTP endpoints. The client
+ * will automatically redirect to the URI declared in 3xx responses. The
+ * connection timeout is 10 s. Request and response messages may be logged
+ * to a JDK logger (in the namespace "com.sun.jersey.api.client").
+ *
+ * @return A Client component.
+ */
+ public static Client buildClient() {
+ ClientConfig config = new DefaultClientConfig();
+ config.getProperties().put(
+ ClientConfig.PROPERTY_FOLLOW_REDIRECTS, true);
+ config.getProperties().put(
+ ClientConfig.PROPERTY_CONNECT_TIMEOUT, 10000);
+ Client client = Client.create(config);
+ client.addFilter(new ReusableEntityFilter());
+ client.addFilter(new LoggingFilter());
+ return client;
+ }
+
+ /**
+ * Constructs a client component that uses a specified web proxy. Proxy
+ * authentication is not supported. Configuring the client to use an
+ * intercepting proxy can be useful when debugging a test.
+ *
+ * @param proxyHost The host name or IP address of the proxy server.
+ * @param proxyPort The port number of the proxy listener.
+ *
+ * @return A Client component that submits requests through a web proxy.
+ */
+ public static Client buildClientWithProxy(final String proxyHost,
+ final int proxyPort) {
+ ClientConfig config = new DefaultClientConfig();
+ config.getProperties().put(
+ ClientConfig.PROPERTY_FOLLOW_REDIRECTS, true);
+ Client client = new Client(new URLConnectionClientHandler(
+ new HttpURLConnectionFactory() {
+ SocketAddress addr = new InetSocketAddress(proxyHost, proxyPort);
+ Proxy proxy = new Proxy(Proxy.Type.HTTP, addr);
+
+ @Override
+ public HttpURLConnection getHttpURLConnection(URL url) throws IOException {
+ return (HttpURLConnection) url.openConnection(proxy);
+ }
+ }), config);
+ client.addFilter(new LoggingFilter());
+ return client;
+ }
+
+ /**
+ * Builds an HTTP request message that uses the GET method.
+ *
+ * @param endpoint A URI indicating the target resource.
+ * @param qryParams A Map containing query parameters (may be null);
+ * @param mediaTypes A list of acceptable media types; if not specified,
+ * generic XML ("application/xml") is preferred.
+ *
+ * @return A ClientRequest object.
+ */
+ public static ClientRequest buildGetRequest(URI endpoint,
+ Map qryParams, MediaType... mediaTypes) {
+ UriBuilder uriBuilder = UriBuilder.fromUri(endpoint);
+ if (null != qryParams) {
+ for (Map.Entry param : qryParams.entrySet()) {
+ uriBuilder.queryParam(param.getKey(), param.getValue());
+ }
+ }
+ URI uri = uriBuilder.build();
+ ClientRequest.Builder reqBuilder = ClientRequest.create();
+ if (null == mediaTypes || mediaTypes.length == 0) {
+ reqBuilder = reqBuilder.accept(MediaType.APPLICATION_XML_TYPE);
+ } else {
+ reqBuilder = reqBuilder.accept(mediaTypes);
+ }
+ ClientRequest req = reqBuilder.build(uri, HttpMethod.GET);
+ return req;
+ }
+
+ /**
+ * Creates a copy of the given MediaType object but without any parameters.
+ *
+ * @param mediaType A MediaType descriptor.
+ * @return A new (immutable) MediaType object having the same type and
+ * subtype.
+ */
+ public static MediaType removeParameters(MediaType mediaType) {
+ return new MediaType(mediaType.getType(), mediaType.getSubtype());
+ }
+
+ /**
+ * Obtains the (XML) response entity as a JAXP Source object and resets the
+ * entity input stream for subsequent reads.
+ *
+ * @param response A representation of an HTTP response message.
+ * @param targetURI The target URI from which the entity was retrieved (may
+ * be null).
+ * @return A Source to read the entity from; its system identifier is set
+ * using the given targetURI value (this may be used to resolve any relative
+ * URIs found in the source).
+ */
+ public static Source getResponseEntityAsSource(ClientResponse response,
+ String targetURI) {
+ Source source = response.getEntity(DOMSource.class);
+ if (null != targetURI && !targetURI.isEmpty()) {
+ source.setSystemId(targetURI);
+ }
+ if (response.getEntityInputStream().markSupported()) {
+ try {
+ // NOTE: entity was buffered by client filter
+ response.getEntityInputStream().reset();
+ } catch (IOException ex) {
+ Logger.getLogger(ClientUtils.class.getName()).log(Level.WARNING,
+ "Failed to reset response entity.", ex);
+ }
+ }
+ return source;
+ }
+
+ /**
+ * Obtains the (XML) response entity as a DOM Document and resets the entity
+ * input stream for subsequent reads.
+ *
+ * @param response A representation of an HTTP response message.
+ * @param targetURI The target URI from which the entity was retrieved (may
+ * be null).
+ * @return A Document representing the entity; its base URI is set using the
+ * given targetURI value (this may be used to resolve any relative URIs
+ * found in the document).
+ */
+ public static Document getResponseEntityAsDocument(ClientResponse response,
+ String targetURI) {
+ DOMSource domSource = (DOMSource) getResponseEntityAsSource(response,
+ targetURI);
+ Document entityDoc = (Document) domSource.getNode();
+ entityDoc.setDocumentURI(domSource.getSystemId());
+ return entityDoc;
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/util/NamespaceBindings.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/NamespaceBindings.java
new file mode 100644
index 0000000..344e5c0
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/NamespaceBindings.java
@@ -0,0 +1,104 @@
+package org.opengis.cite.ogcapiprocesses10.util;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import javax.xml.namespace.NamespaceContext;
+import org.opengis.cite.ogcapiprocesses10.Namespaces;
+
+/**
+ * Provides namespace bindings for evaluating XPath 1.0 expressions using the
+ * JAXP XPath API. A namespace name (URI) may be bound to only one prefix.
+ */
+public class NamespaceBindings implements NamespaceContext {
+
+ private Map bindings = new HashMap();
+
+ @Override
+ public String getNamespaceURI(String prefix) {
+ String nsName = null;
+ for (Map.Entry binding : bindings.entrySet()) {
+ if (binding.getValue().equals(prefix)) {
+ nsName = binding.getKey();
+ break;
+ }
+ }
+ return nsName;
+ }
+
+ @Override
+ public String getPrefix(String namespaceURI) {
+ return bindings.get(namespaceURI);
+ }
+
+ @Override
+ public Iterator getPrefixes(String namespaceURI) {
+ return Arrays.asList(getPrefix(namespaceURI)).iterator();
+ }
+
+ /**
+ * Adds a namespace binding that associates a namespace name with a prefix.
+ * If a binding for a given namespace name already exists it will be
+ * replaced.
+ *
+ * @param namespaceURI
+ * A String denoting a namespace name (an absolute URI value).
+ * @param prefix
+ * A prefix associated with the namespace name.
+ */
+ public void addNamespaceBinding(String namespaceURI, String prefix) {
+ bindings.put(namespaceURI, prefix);
+ }
+
+ /**
+ * Adds all of the supplied namespace bindings to the existing set of
+ * entries.
+ *
+ * @param nsBindings
+ * A Map containing a collection of namespace bindings where the
+ * key is an absolute URI specifying the namespace name and the
+ * value denotes the associated prefix.
+ */
+ public void addAllBindings(Map nsBindings) {
+ if (null != nsBindings)
+ bindings.putAll(nsBindings);
+ }
+
+ /**
+ * Returns an unmodifiable view of the declared namespace bindings.
+ *
+ * @return An immutable Map containing zero or more namespace bindings where
+ * the key is an absolute URI specifying the namespace name and the
+ * value is the associated prefix.
+ */
+ public Map getAllBindings() {
+ return Collections.unmodifiableMap(this.bindings);
+ }
+
+ /**
+ * Creates a NamespaceBindings object that declares the following namespace
+ * bindings:
+ *
+ *
+ *
+ * @return A NamespaceBindings object.
+ */
+ public static NamespaceBindings withStandardBindings() {
+ NamespaceBindings nsBindings = new NamespaceBindings();
+ nsBindings.addNamespaceBinding(Namespaces.OWS, "ows");
+ nsBindings.addNamespaceBinding(Namespaces.XLINK, "xlink");
+ nsBindings.addNamespaceBinding(Namespaces.GML, "gml");
+ return nsBindings;
+ }
+
+ @Override
+ public String toString() {
+ return "NamespaceBindings:\n" + bindings;
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/util/TestSuiteLogger.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/TestSuiteLogger.java
new file mode 100644
index 0000000..186962c
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/TestSuiteLogger.java
@@ -0,0 +1,73 @@
+package org.opengis.cite.ogcapiprocesses10.util;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Logging utility class that provides simple access to the JDK Logging API. Set
+ * the "java.util.logging.config.file" system property to specify the location
+ * of the desired logging configuration file. A sample configuration file is
+ * available at {@code src/main/config/logging.properties}.
+ *
+ * @see java.util.logging.LogManager LogManager
+ */
+public class TestSuiteLogger {
+
+ private static final Logger LOGR =
+ Logger.getLogger(TestSuiteLogger.class.getPackage().getName());
+
+ /**
+ * Logs a message at the specified logging level with the given message
+ * parameters.
+ *
+ * @param level The logging {@link Level level}.
+ * @param message A String representing the content of the log message.
+ * @param params An array of message parameters.
+ */
+ public static void log(Level level, String message, Object[] params) {
+ if (LOGR.isLoggable(level)) {
+ LOGR.log(level, message, params);
+ }
+ }
+
+ /**
+ * Logs a message at the specified logging level with the given Exception
+ * object that represents a noteworthy error condition.
+ *
+ * @param level The logging {@link Level level}.
+ * @param message A String representing the content of the log message.
+ * @param except An object that indicates an exceptional situation.
+ */
+ public static void log(Level level, String message, Exception except) {
+ if (LOGR.isLoggable(level)) {
+ LOGR.log(level, message, except);
+ }
+ }
+
+ /**
+ * Logs a simple message at the specified logging level.
+ *
+ * @param level The logging {@link Level level}.
+ * @param message A String representing the content of the log message.
+ */
+ public static void log(Level level, String message) {
+ if (LOGR.isLoggable(level)) {
+ LOGR.log(level, message);
+ }
+ }
+
+ /**
+ * Indicates if the logger is enabled at a given logging level. Message
+ * levels lower than this value will be discarded.
+ *
+ * @param level The logging {@link Level level}.
+ * @return true if the logger is currently enabled for this logging level;
+ * false otherwise.
+ */
+ public static boolean isLoggable(Level level) {
+ return LOGR.isLoggable(level);
+ }
+
+ private TestSuiteLogger() {
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/util/URIUtils.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/URIUtils.java
new file mode 100644
index 0000000..ed996ea
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/URIUtils.java
@@ -0,0 +1,137 @@
+package org.opengis.cite.ogcapiprocesses10.util;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URI;
+import java.util.logging.Level;
+
+import javax.ws.rs.core.HttpHeaders;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+import com.sun.jersey.api.client.Client;
+import com.sun.jersey.api.client.ClientResponse;
+import com.sun.jersey.api.client.WebResource;
+
+/**
+ * Provides a collection of utility methods for manipulating or resolving URI
+ * references.
+ */
+public class URIUtils {
+
+ private static final String FIXUP_BASE_URI = "http://apache.org/xml/features/xinclude/fixup-base-uris";
+
+ /**
+ * Parses the content of the given URI as an XML document and returns a new
+ * DOM Document object. Entity reference nodes will not be expanded. XML
+ * inclusions (xi:include elements) will be processed if present.
+ *
+ * @param uriRef
+ * An absolute URI specifying the location of an XML resource.
+ * @return A DOM Document node representing an XML resource.
+ * @throws SAXException
+ * If the resource cannot be parsed.
+ * @throws IOException
+ * If the resource is not accessible.
+ */
+ public static Document parseURI(URI uriRef) throws SAXException,
+ IOException {
+ if ((null == uriRef) || !uriRef.isAbsolute()) {
+ throw new IllegalArgumentException(
+ "Absolute URI is required, but received " + uriRef);
+ }
+ DocumentBuilderFactory docFactory = DocumentBuilderFactory
+ .newInstance();
+ docFactory.setNamespaceAware(true);
+ docFactory.setExpandEntityReferences(false);
+ docFactory.setXIncludeAware(true);
+ Document doc = null;
+ try {
+ // XInclude processor will not add xml:base attributes
+ docFactory.setFeature(FIXUP_BASE_URI, false);
+ DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
+ doc = docBuilder.parse(uriRef.toString());
+ } catch (ParserConfigurationException x) {
+ TestSuiteLogger.log(Level.WARNING,
+ "Failed to create DocumentBuilder." + x);
+ }
+ if (null != doc) {
+ doc.setDocumentURI(uriRef.toString());
+ }
+ return doc;
+ }
+
+ /**
+ * Dereferences the given URI and stores the resulting resource
+ * representation in a local file. The file will be located in the default
+ * temporary file directory.
+ *
+ * @param uriRef
+ * An absolute URI specifying the location of some resource.
+ * @return A File containing the content of the resource; it may be empty if
+ * resolution failed for any reason.
+ * @throws IOException
+ * If an IO error occurred.
+ */
+ public static File dereferenceURI(URI uriRef) throws IOException {
+ if ((null == uriRef) || !uriRef.isAbsolute()) {
+ throw new IllegalArgumentException(
+ "Absolute URI is required, but received " + uriRef);
+ }
+ if (uriRef.getScheme().equalsIgnoreCase("file")) {
+ return new File(uriRef);
+ }
+ Client client = Client.create();
+ WebResource webRes = client.resource(uriRef);
+ ClientResponse rsp = webRes.get(ClientResponse.class);
+ String suffix = null;
+ if (rsp.getHeaders().getFirst(HttpHeaders.CONTENT_TYPE).endsWith("xml")) {
+ suffix = ".xml";
+ }
+ File destFile = File.createTempFile("entity-", suffix);
+ if (rsp.hasEntity()) {
+ InputStream is = rsp.getEntityInputStream();
+ OutputStream os = new FileOutputStream(destFile);
+ byte[] buffer = new byte[8 * 1024];
+ int bytesRead;
+ while ((bytesRead = is.read(buffer)) != -1) {
+ os.write(buffer, 0, bytesRead);
+ }
+ is.close();
+ os.flush();
+ os.close();
+ }
+ TestSuiteLogger.log(Level.FINE, "Wrote " + destFile.length()
+ + " bytes to file at " + destFile.getAbsolutePath());
+ return destFile;
+ }
+
+ /**
+ * Constructs an absolute URI from the given URI reference and a base URI.
+ *
+ * @see RFC 3986,
+ * 5.2
+ *
+ * @param baseURI
+ * The base URI; if present, it must be an absolute URI.
+ * @param uriRef
+ * A URI reference that may be relative to the given base URI.
+ * @return The resulting URI.
+ *
+ */
+ public static URI resolveRelativeURI(String baseURI, String uriRef) {
+ URI uri = (null != baseURI) ? URI.create(baseURI) : URI.create("");
+ if (null != baseURI && null == uri.getScheme()) {
+ throw new IllegalArgumentException(
+ "Base URI has no scheme component: " + baseURI);
+ }
+ return uri.resolve(uriRef);
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/util/ValidationUtils.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/ValidationUtils.java
new file mode 100644
index 0000000..da72a73
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/ValidationUtils.java
@@ -0,0 +1,162 @@
+package org.opengis.cite.ogcapiprocesses10.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URL;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.logging.Level;
+
+import javax.xml.XMLConstants;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLEventReader;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.Attribute;
+import javax.xml.stream.events.StartElement;
+import javax.xml.transform.Source;
+import javax.xml.transform.stream.StreamSource;
+
+import org.apache.xerces.util.XMLCatalogResolver;
+import org.opengis.cite.ogcapiprocesses10.Namespaces;
+import org.opengis.cite.validation.SchematronValidator;
+import org.w3c.dom.ls.LSResourceResolver;
+
+/**
+ * A utility class that provides convenience methods to support schema
+ * validation.
+ */
+public class ValidationUtils {
+
+ static final String ROOT_PKG = "/org/opengis/cite/ogcapiprocesses10/";
+ private static final XMLCatalogResolver SCH_RESOLVER = initCatalogResolver();
+
+ private static XMLCatalogResolver initCatalogResolver() {
+ return (XMLCatalogResolver) createSchemaResolver(Namespaces.SCH);
+ }
+
+ /**
+ * Creates a resource resolver suitable for locating schemas using an entity
+ * catalog. In effect, local copies of standard schemas are returned instead
+ * of retrieving them from external repositories.
+ *
+ * @param schemaLanguage
+ * A URI that identifies a schema language by namespace name.
+ * @return A {@code LSResourceResolver} object that is configured to use an
+ * OASIS entity catalog.
+ */
+ public static LSResourceResolver createSchemaResolver(URI schemaLanguage) {
+ String catalogFileName;
+ if (schemaLanguage.equals(Namespaces.XSD)) {
+ catalogFileName = "schema-catalog.xml";
+ } else {
+ catalogFileName = "schematron-catalog.xml";
+ }
+ URL catalogURL = ValidationUtils.class.getResource(ROOT_PKG
+ + catalogFileName);
+ XMLCatalogResolver resolver = new XMLCatalogResolver();
+ resolver.setCatalogList(new String[] { catalogURL.toString() });
+ return resolver;
+ }
+
+ /**
+ * Constructs a SchematronValidator that will check an XML resource against
+ * the rules defined in a Schematron schema. An attempt is made to resolve
+ * the schema reference using an entity catalog; if this fails the reference
+ * is used as given.
+ *
+ * @param schemaRef
+ * A reference to a Schematron schema; this is expected to be a
+ * relative or absolute URI value, possibly matching the system
+ * identifier for some entry in an entity catalog.
+ * @param phase
+ * The name of the phase to invoke.
+ * @return A SchematronValidator instance, or {@code null} if the validator
+ * cannot be constructed (e.g. invalid schema reference or phase
+ * name).
+ */
+ public static SchematronValidator buildSchematronValidator(
+ String schemaRef, String phase) {
+ Source source = null;
+ try {
+ String catalogRef = SCH_RESOLVER
+ .resolveSystem(schemaRef.toString());
+ if (null != catalogRef) {
+ source = new StreamSource(URI.create(catalogRef).toString());
+ } else {
+ source = new StreamSource(schemaRef);
+ }
+ } catch (IOException x) {
+ TestSuiteLogger.log(Level.WARNING,
+ "Error reading Schematron schema catalog.", x);
+ }
+ SchematronValidator validator = null;
+ try {
+ validator = new SchematronValidator(source, phase);
+ } catch (Exception e) {
+ TestSuiteLogger.log(Level.WARNING,
+ "Error creating Schematron validator.", e);
+ }
+ return validator;
+ }
+
+ /**
+ * Extracts a set of XML Schema references from a source XML document. The
+ * document element is expected to include the standard xsi:schemaLocation
+ * attribute.
+ *
+ * @param source
+ * The source instance to read from; its base URI (systemId)
+ * should be set.
+ * @param baseURI
+ * An alternative base URI to use if the source does not have a
+ * system identifier set or if its system id is a {@code file}
+ * URI. This will usually be the URI used to retrieve the
+ * resource; it may be null.
+ * @return A Set containing absolute URI references that specify the
+ * locations of XML Schema resources.
+ * @throws XMLStreamException
+ * If an error occurs while reading the source instance.
+ */
+ public static Set extractSchemaReferences(Source source, String baseURI)
+ throws XMLStreamException {
+ XMLInputFactory factory = XMLInputFactory.newInstance();
+ XMLEventReader reader = factory.createXMLEventReader(source);
+ // advance to document element
+ StartElement docElem = reader.nextTag().asStartElement();
+ Attribute schemaLoc = docElem.getAttributeByName(new QName(
+ XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI, "schemaLocation"));
+ if (null == schemaLoc) {
+ throw new RuntimeException(
+ "No xsi:schemaLocation attribute found. See ISO 19136, A.3.1.");
+ }
+ String[] uriValues = schemaLoc.getValue().split("\\s+");
+ if (uriValues.length % 2 != 0) {
+ throw new RuntimeException(
+ "xsi:schemaLocation attribute contains an odd number of URI values:\n"
+ + Arrays.toString(uriValues));
+ }
+ Set schemaURIs = new HashSet();
+ // one or more pairs of [namespace name] [schema location]
+ for (int i = 0; i < uriValues.length; i += 2) {
+ URI schemaURI = null;
+ if (!URI.create(uriValues[i + 1]).isAbsolute()
+ && (null != source.getSystemId())) {
+ String schemaRef = URIUtils.resolveRelativeURI(
+ source.getSystemId(), uriValues[i + 1]).toString();
+ if (schemaRef.startsWith("file")
+ && !new File(schemaRef).exists() && (null != baseURI)) {
+ schemaRef = URIUtils.resolveRelativeURI(baseURI,
+ uriValues[i + 1]).toString();
+ }
+ schemaURI = URI.create(schemaRef);
+ } else {
+ schemaURI = URI.create(uriValues[i + 1]);
+ }
+ schemaURIs.add(schemaURI);
+ }
+ return schemaURIs;
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/util/XMLUtils.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/XMLUtils.java
new file mode 100644
index 0000000..6486c79
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/XMLUtils.java
@@ -0,0 +1,410 @@
+package org.opengis.cite.ogcapiprocesses10.util;
+
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import net.sf.saxon.s9api.DOMDestination;
+import net.sf.saxon.s9api.DocumentBuilder;
+import net.sf.saxon.s9api.Processor;
+import net.sf.saxon.s9api.SaxonApiException;
+import net.sf.saxon.s9api.XPathCompiler;
+import net.sf.saxon.s9api.XPathSelector;
+import net.sf.saxon.s9api.XQueryCompiler;
+import net.sf.saxon.s9api.XQueryEvaluator;
+import net.sf.saxon.s9api.XQueryExecutable;
+import net.sf.saxon.s9api.XdmNode;
+import net.sf.saxon.s9api.XdmValue;
+import net.sf.saxon.s9api.XsltCompiler;
+import net.sf.saxon.s9api.XsltExecutable;
+import net.sf.saxon.s9api.XsltTransformer;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * Provides various utility methods for accessing or manipulating XML
+ * representations.
+ */
+public class XMLUtils {
+
+ private static final Logger LOGR = Logger.getLogger(XMLUtils.class.getPackage().getName());
+ private static final XMLInputFactory STAX_FACTORY = initXMLInputFactory();
+ private static final XPathFactory XPATH_FACTORY = initXPathFactory();
+
+ private static XPathFactory initXPathFactory() {
+ XPathFactory factory = XPathFactory.newInstance();
+ return factory;
+ }
+
+ private static XMLInputFactory initXMLInputFactory() {
+ XMLInputFactory factory = XMLInputFactory.newInstance();
+ factory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
+ return factory;
+ }
+
+ /**
+ * Writes the content of a DOM Node to a string. The XML declaration is
+ * omitted and the character encoding is set to "US-ASCII" (any character
+ * outside of this set is serialized as a numeric character reference).
+ *
+ * @param node
+ * The DOM Node to be serialized.
+ * @return A String representing the content of the given node.
+ */
+ public static String writeNodeToString(Node node) {
+ if (null == node) {
+ return "";
+ }
+ Writer writer = null;
+ try {
+ Transformer idTransformer = TransformerFactory.newInstance().newTransformer();
+ Properties outProps = new Properties();
+ outProps.setProperty(OutputKeys.ENCODING, "US-ASCII");
+ outProps.setProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
+ outProps.setProperty(OutputKeys.INDENT, "yes");
+ idTransformer.setOutputProperties(outProps);
+ writer = new StringWriter();
+ idTransformer.transform(new DOMSource(node), new StreamResult(writer));
+ } catch (TransformerException ex) {
+ TestSuiteLogger.log(Level.WARNING, "Failed to serialize node " + node.getNodeName(), ex);
+ }
+ return writer.toString();
+ }
+
+ /**
+ * Writes the content of a DOM Node to a byte stream. An XML declaration is
+ * always omitted.
+ *
+ * @param node
+ * The DOM Node to be serialized.
+ * @param outputStream
+ * The destination OutputStream reference.
+ */
+ public static void writeNode(Node node, OutputStream outputStream) {
+ try {
+ Transformer idTransformer = TransformerFactory.newInstance().newTransformer();
+ Properties outProps = new Properties();
+ outProps.setProperty(OutputKeys.METHOD, "xml");
+ outProps.setProperty(OutputKeys.ENCODING, "UTF-8");
+ outProps.setProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
+ outProps.setProperty(OutputKeys.INDENT, "yes");
+ idTransformer.setOutputProperties(outProps);
+ idTransformer.transform(new DOMSource(node), new StreamResult(outputStream));
+ } catch (TransformerException ex) {
+ String nodeName = (node.getNodeType() == Node.DOCUMENT_NODE)
+ ? Document.class.cast(node).getDocumentElement().getNodeName() : node.getNodeName();
+ TestSuiteLogger.log(Level.WARNING, "Failed to serialize DOM node: " + nodeName, ex);
+ }
+ }
+
+ /**
+ * Evaluates an XPath 1.0 expression using the given context and returns the
+ * result as a node set.
+ *
+ * @param context
+ * The context node.
+ * @param expr
+ * An XPath expression.
+ * @param namespaceBindings
+ * A collection of namespace bindings for the XPath expression,
+ * where each entry maps a namespace URI (key) to a prefix
+ * (value). Standard bindings do not need to be declared (see
+ * {@link NamespaceBindings#withStandardBindings()}.
+ * @return A NodeList containing nodes that satisfy the expression (it may
+ * be empty).
+ * @throws XPathExpressionException
+ * If the expression cannot be evaluated for any reason.
+ */
+ public static NodeList evaluateXPath(Node context, String expr, Map namespaceBindings)
+ throws XPathExpressionException {
+ Object result = evaluateXPath(context, expr, namespaceBindings, XPathConstants.NODESET);
+ if (!NodeList.class.isInstance(result)) {
+ throw new XPathExpressionException("Expression does not evaluate to a NodeList: " + expr);
+ }
+ return (NodeList) result;
+ }
+
+ /**
+ * Evaluates an XPath expression using the given context and returns the
+ * result as the specified type.
+ *
+ *
+ * Note: The Saxon implementation supports XPath 2.0
+ * expressions when using the JAXP XPath APIs (the default implementation
+ * will throw an exception).
+ *
+ *
+ * @param context
+ * The context node.
+ * @param expr
+ * An XPath expression.
+ * @param namespaceBindings
+ * A collection of namespace bindings for the XPath expression,
+ * where each entry maps a namespace URI (key) to a prefix
+ * (value). Standard bindings do not need to be declared (see
+ * {@link NamespaceBindings#withStandardBindings()}.
+ * @param returnType
+ * The desired return type (as declared in {@link XPathConstants}
+ * ).
+ * @return The result converted to the desired returnType.
+ * @throws XPathExpressionException
+ * If the expression cannot be evaluated for any reason.
+ */
+ public static Object evaluateXPath(Node context, String expr, Map namespaceBindings,
+ QName returnType) throws XPathExpressionException {
+ NamespaceBindings bindings = NamespaceBindings.withStandardBindings();
+ bindings.addAllBindings(namespaceBindings);
+ XPathFactory factory = XPATH_FACTORY;
+ // WARNING: If context node is Saxon NodeOverNodeInfo, the factory must
+ // use the same Configuration object to avoid IllegalArgumentException
+ XPath xpath = factory.newXPath();
+ xpath.setNamespaceContext(bindings);
+ Object result = xpath.evaluate(expr, context, returnType);
+ return result;
+ }
+
+ /**
+ * Evaluates an XPath 2.0 expression using the Saxon s9api interfaces.
+ *
+ * @param xmlSource
+ * The XML Source.
+ * @param expr
+ * The XPath expression to be evaluated.
+ * @param nsBindings
+ * A collection of namespace bindings required to evaluate the
+ * XPath expression, where each entry maps a namespace URI (key)
+ * to a prefix (value); this may be {@code null} if not needed.
+ * @return An XdmValue object representing a value in the XDM data model;
+ * this is a sequence of zero or more items, where each item is
+ * either an atomic value or a node.
+ * @throws SaxonApiException
+ * If an error occurs while evaluating the expression; this
+ * always wraps some other underlying exception.
+ */
+ public static XdmValue evaluateXPath2(Source xmlSource, String expr, Map nsBindings)
+ throws SaxonApiException {
+ Processor proc = new Processor(false);
+ XPathCompiler compiler = proc.newXPathCompiler();
+ if (null != nsBindings) {
+ for (String nsURI : nsBindings.keySet()) {
+ compiler.declareNamespace(nsBindings.get(nsURI), nsURI);
+ }
+ }
+ XPathSelector xpath = compiler.compile(expr).load();
+ DocumentBuilder builder = proc.newDocumentBuilder();
+ XdmNode node = null;
+ if (DOMSource.class.isInstance(xmlSource)) {
+ DOMSource domSource = (DOMSource) xmlSource;
+ node = builder.wrap(domSource.getNode());
+ } else {
+ node = builder.build(xmlSource);
+ }
+ xpath.setContextItem(node);
+ return xpath.evaluate();
+ }
+
+ /**
+ * Evaluates an XQuery 1.0 expression using the Saxon s9api interfaces.
+ *
+ * @param source
+ * The XML Source.
+ * @param query
+ * The query expression.
+ * @param nsBindings
+ * A collection of namespace bindings required to evaluate the
+ * query, where each entry maps a namespace URI (key) to a prefix
+ * (value).
+ * @return An XdmValue object representing a value in the XDM data model.
+ * @throws SaxonApiException
+ * If an error occurs while evaluating the query (this always
+ * wraps some other underlying exception).
+ */
+ public static XdmValue evaluateXQuery(Source source, String query, Map nsBindings)
+ throws SaxonApiException {
+ Processor proc = new Processor(false);
+ XQueryCompiler xqCompiler = proc.newXQueryCompiler();
+ if (null != nsBindings) {
+ for (String nsURI : nsBindings.keySet()) {
+ xqCompiler.declareNamespace(nsBindings.get(nsURI), nsURI);
+ }
+ }
+ XQueryExecutable xqExec = xqCompiler.compile(query);
+ XQueryEvaluator xqEval = xqExec.load();
+ xqEval.setSource(source);
+ return xqEval.evaluate();
+ }
+
+ /**
+ * Creates a new Element having the specified qualified name. The element
+ * must be {@link Document#adoptNode(Node) adopted} when inserted into
+ * another Document.
+ *
+ * @param qName
+ * A QName object.
+ * @return An Element node (with a Document owner but no parent).
+ */
+ public static Element createElement(QName qName) {
+ Document doc = null;
+ try {
+ doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
+ } catch (ParserConfigurationException e) {
+ throw new RuntimeException(e);
+ }
+ Element elem = doc.createElementNS(qName.getNamespaceURI(), qName.getLocalPart());
+ return elem;
+ }
+
+ /**
+ * Returns a List of all descendant Element nodes having the specified
+ * [namespace name] property. The elements are listed in document order.
+ *
+ * @param node
+ * The node to search from.
+ * @param namespaceURI
+ * An absolute URI denoting a namespace name.
+ * @return A List containing elements in the specified namespace; the list
+ * is empty if there are no elements in the namespace.
+ */
+ public static List getElementsByNamespaceURI(Node node, String namespaceURI) {
+ List list = new ArrayList();
+ NodeList children = node.getChildNodes();
+ for (int i = 0; i < children.getLength(); i++) {
+ Node child = children.item(i);
+ if (child.getNodeType() != Node.ELEMENT_NODE)
+ continue;
+ if (child.getNamespaceURI().equals(namespaceURI))
+ list.add((Element) child);
+ }
+ return list;
+ }
+
+ /**
+ * Transforms the content of a DOM Node using a specified XSLT stylesheet.
+ *
+ * @param xslt
+ * A Source object representing a stylesheet (XSLT 1.0 or 2.0).
+ * @param source
+ * A Node representing the XML source. If it is an Element node
+ * it will be imported into a new DOM Document.
+ * @return A DOM Document containing the result of the transformation.
+ */
+ public static Document transform(Source xslt, Node source) {
+ Document sourceDoc = null;
+ Document resultDoc = null;
+ try {
+ resultDoc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
+ if (source.getNodeType() == Node.DOCUMENT_NODE) {
+ sourceDoc = (Document) source;
+ } else {
+ sourceDoc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
+ sourceDoc.appendChild(sourceDoc.importNode(source, true));
+ }
+ } catch (ParserConfigurationException pce) {
+ throw new RuntimeException(pce);
+ }
+ Processor processor = new Processor(false);
+ XsltCompiler compiler = processor.newXsltCompiler();
+ try {
+ XsltExecutable exec = compiler.compile(xslt);
+ XsltTransformer transformer = exec.load();
+ transformer.setSource(new DOMSource(sourceDoc));
+ transformer.setDestination(new DOMDestination(resultDoc));
+ transformer.transform();
+ } catch (SaxonApiException e) {
+ throw new RuntimeException(e);
+ }
+ return resultDoc;
+ }
+
+ /**
+ * Expands character entity ({@literal &name;}) and numeric references (
+ * {@literal &#xhhhh;} or {@literal &dddd;}) that occur within a given
+ * string value. It may be necessary to do this before processing an XPath
+ * expression.
+ *
+ * @param value
+ * A string representing text content.
+ * @return A string with all included references expanded.
+ */
+ public static String expandReferencesInText(String value) {
+ StringBuilder wrapper = new StringBuilder("");
+ wrapper.append(value).append("");
+ Reader reader = new StringReader(wrapper.toString());
+ String str = null;
+ try {
+ XMLStreamReader xsr = STAX_FACTORY.createXMLStreamReader(reader);
+ xsr.nextTag(); // document element
+ str = xsr.getElementText();
+ } catch (XMLStreamException xse) {
+ LOGR.log(Level.WARNING, xse.getMessage(), xse);
+ }
+ return str;
+ }
+
+ /**
+ * Creates a DOM Document with the given Element as the document element. A
+ * deep copy of the element is imported; the source element is not altered.
+ *
+ * @param elem
+ * An Element node.
+ * @return A Document node.
+ */
+ public static Document importElement(Element elem) {
+ javax.xml.parsers.DocumentBuilder docBuilder = null;
+ try {
+ DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+ factory.setNamespaceAware(true);
+ docBuilder = factory.newDocumentBuilder();
+ } catch (ParserConfigurationException ex) {
+ LOGR.log(Level.WARNING, null, ex);
+ }
+ Document newDoc = docBuilder.newDocument();
+ Node newNode = newDoc.importNode(elem, true);
+ newDoc.appendChild(newNode);
+ return newDoc;
+ }
+
+ /**
+ * Returns a List view of the nodes in the given NodeList collection.
+ *
+ * @param nodeList
+ * An ordered collection of DOM nodes.
+ * @return A List containing the original sequence of Node objects.
+ */
+ public static List asList(NodeList nodeList) {
+ List nodes = new ArrayList<>();
+ for (int i = 0; i < nodeList.getLength(); i++) {
+ nodes.add(nodeList.item(i));
+ }
+ return nodes;
+ }
+}
diff --git a/src/main/java/org/opengis/cite/ogcapiprocesses10/util/package-info.java b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/package-info.java
new file mode 100644
index 0000000..26ceb85
--- /dev/null
+++ b/src/main/java/org/opengis/cite/ogcapiprocesses10/util/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * This package includes miscellaneous utility classes to support testing.
+ */
+package org.opengis.cite.ogcapiprocesses10.util;
diff --git a/src/main/javadoc/index.html b/src/main/javadoc/index.html
new file mode 100644
index 0000000..5143475
--- /dev/null
+++ b/src/main/javadoc/index.html
@@ -0,0 +1,10 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/javadoc/overview.html b/src/main/javadoc/overview.html
new file mode 100644
index 0000000..13f0d6a
--- /dev/null
+++ b/src/main/javadoc/overview.html
@@ -0,0 +1,96 @@
+
+
+
+ OGC API - Processes Standard 1.0 Conformance Test Suite
+
+
+
+
+
OGC API - Processes Standard 1.0 Conformance Test Suite
+
This executable test suite (ETS) verifies the conformance of the implementation
+ under test (IUT) with respect to all relevant specifications. Conformance testing
+ is a kind of "black box" testing that examines externally visible characteristics
+ or behaviors of the IUT and is independent of any implementation details.
+
+
The test run arguments are summarized in the following table. The Obligation
+ descriptor can have the following values: M (mandatory), O (optional), or C
+ (conditional).
+
+
+
Test run arguments
+
+
+
Name
+
Value domain
+
Obligation
+
Description
+
+
+
+
+
iut
+
URI
+
M
+
A URI that refers to the implementation under test or metadata about it.
+ Ampersand ('&') characters must be percent-encoded as '%26'.
+
+
+
ics
+
A comma-separated list of string values.
+
O
+
An implementation conformance statement that indicates which conformance
+ classes or options are supported.
+
+
+
+
+
+
diff --git a/src/main/resources/META-INF/services/com.occamlab.te.spi.jaxrs.TestSuiteController b/src/main/resources/META-INF/services/com.occamlab.te.spi.jaxrs.TestSuiteController
new file mode 100644
index 0000000..7483210
--- /dev/null
+++ b/src/main/resources/META-INF/services/com.occamlab.te.spi.jaxrs.TestSuiteController
@@ -0,0 +1 @@
+org.opengis.cite.ogcapiprocesses10.TestNGController
\ No newline at end of file
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/MessageBundle.properties b/src/main/resources/org/opengis/cite/ogcapiprocesses10/MessageBundle.properties
new file mode 100644
index 0000000..0aa5996
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/MessageBundle.properties
@@ -0,0 +1,12 @@
+# assertion error messages in English (default)
+NotSchemaValid = {0} schema validation error(s) detected.\n {1}
+EmptyString = Expected empty string.
+XPathResult = Unexpected result evaluating XPath expression with context node {0}: {1}
+NamespaceName = Node has unexpected [namespace name] value.
+LocalName = Node has unexpected [local name] value.
+XMLError = Failed to read XML resource. {0}
+XPathError = XPath expression cannot be evaluated: {0}. {1}
+MissingInfosetItem = Infoset item is missing or empty: {0}. Location: {1}
+UnexpectedStatus = Unexpected HTTP status code.
+UnexpectedMediaType = Response entity has unexpected media type.
+MissingEntity = Response entity is missing.
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/MessageBundle_en.properties b/src/main/resources/org/opengis/cite/ogcapiprocesses10/MessageBundle_en.properties
new file mode 100644
index 0000000..0aa5996
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/MessageBundle_en.properties
@@ -0,0 +1,12 @@
+# assertion error messages in English (default)
+NotSchemaValid = {0} schema validation error(s) detected.\n {1}
+EmptyString = Expected empty string.
+XPathResult = Unexpected result evaluating XPath expression with context node {0}: {1}
+NamespaceName = Node has unexpected [namespace name] value.
+LocalName = Node has unexpected [local name] value.
+XMLError = Failed to read XML resource. {0}
+XPathError = XPath expression cannot be evaluated: {0}. {1}
+MissingInfosetItem = Infoset item is missing or empty: {0}. Location: {1}
+UnexpectedStatus = Unexpected HTTP status code.
+UnexpectedMediaType = Response entity has unexpected media type.
+MissingEntity = Response entity is missing.
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/ets.properties b/src/main/resources/org/opengis/cite/ogcapiprocesses10/ets.properties
new file mode 100644
index 0000000..e06e192
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/ets.properties
@@ -0,0 +1,3 @@
+ets-title = ${project.name}
+ets-version = ${project.version}
+ets-code = ${ets-code}
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/rnc/atom.rnc b/src/main/resources/org/opengis/cite/ogcapiprocesses10/rnc/atom.rnc
new file mode 100644
index 0000000..3777e94
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/rnc/atom.rnc
@@ -0,0 +1,283 @@
+# RELAX NG Compact Syntax Grammar for the Atom Format Specification
+# See
+
+ namespace atom = "http://www.w3.org/2005/Atom"
+ namespace xhtml = "http://www.w3.org/1999/xhtml"
+ namespace s = "http://www.ascc.net/xml/schematron"
+ namespace local = ""
+
+ start = atomFeed | atomEntry
+
+ atomCommonAttributes =
+ attribute xml:base { atomUri }?,
+ attribute xml:lang { atomLanguageTag }?,
+ undefinedAttribute*
+
+ atomPlainTextConstruct =
+ atomCommonAttributes,
+ attribute type { "text" | "html" }?,
+ text
+
+ atomXHTMLTextConstruct =
+ atomCommonAttributes,
+ attribute type { "xhtml" },
+ xhtmlDiv
+
+ atomTextConstruct = atomPlainTextConstruct | atomXHTMLTextConstruct
+
+ atomPersonConstruct =
+ atomCommonAttributes,
+ (element atom:name { text }
+ & element atom:uri { atomUri }?
+ & element atom:email { atomEmailAddress }?
+ & extensionElement*)
+
+ atomDateConstruct =
+ atomCommonAttributes,
+ xsd:dateTime
+
+ atomFeed =
+ [
+ s:rule [
+ context = "atom:feed"
+ s:assert [
+ test = "atom:author or not(atom:entry[not(atom:author)])"
+ "An atom:feed must have an atom:author unless all "
+ ~ "of its atom:entry children have an atom:author."
+ ]
+ ]
+ ]
+ element atom:feed {
+ atomCommonAttributes,
+ (atomAuthor*
+ & atomCategory*
+ & atomContributor*
+ & atomGenerator?
+ & atomIcon?
+ & atomId
+ & atomLink*
+ & atomLogo?
+ & atomRights?
+ & atomSubtitle?
+ & atomTitle
+ & atomUpdated
+ & extensionElement*),
+ atomEntry*
+ }
+
+ atomEntry =
+ [
+ s:rule [
+ context = "atom:entry"
+ s:assert [
+ test = "atom:link[@rel='alternate'] "
+ ~ "or atom:link[not(@rel)] "
+ ~ "or atom:content"
+ "An atom:entry must have at least one atom:link element "
+ ~ "with a rel attribute of 'alternate' "
+ ~ "or an atom:content."
+ ]
+ ]
+ s:rule [
+ context = "atom:entry"
+ s:assert [
+ test = "atom:author or "
+ ~ "../atom:author or atom:source/atom:author"
+ "An atom:entry must have an atom:author "
+ ~ "if its feed does not."
+ ]
+ ]
+ ]
+ element atom:entry {
+ atomCommonAttributes,
+ (atomAuthor*
+ & atomCategory*
+ & atomContent?
+ & atomContributor*
+ & atomId
+ & atomLink*
+ & atomPublished?
+ & atomRights?
+ & atomSource?
+ & atomSummary?
+ & atomTitle
+ & atomUpdated
+ & extensionElement*)
+ }
+
+ atomInlineTextContent =
+ element atom:content {
+ atomCommonAttributes,
+ attribute type { "text" | "html" }?,
+ (text)*
+ }
+
+ atomInlineXHTMLContent =
+ element atom:content {
+ atomCommonAttributes,
+ attribute type { "xhtml" },
+ xhtmlDiv
+ }
+
+ atomInlineOtherContent =
+ element atom:content {
+ atomCommonAttributes,
+ attribute type { atomMediaType }?,
+ (text|anyElement)*
+ }
+
+ atomOutOfLineContent =
+ element atom:content {
+ atomCommonAttributes,
+ attribute type { atomMediaType }?,
+ attribute src { atomUri },
+ empty
+ }
+
+ atomContent = atomInlineTextContent
+ | atomInlineXHTMLContent
+ | atomInlineOtherContent
+ | atomOutOfLineContent
+
+ atomAuthor = element atom:author { atomPersonConstruct }
+
+ # atom:category
+
+ atomCategory =
+ element atom:category {
+ atomCommonAttributes,
+ attribute term { text },
+ attribute scheme { atomUri }?,
+ attribute label { text }?,
+ undefinedContent
+ }
+
+ atomContributor = element atom:contributor { atomPersonConstruct }
+
+ atomGenerator = element atom:generator {
+ atomCommonAttributes,
+ attribute uri { atomUri }?,
+ attribute version { text }?,
+ text
+ }
+
+ atomIcon = element atom:icon {
+ atomCommonAttributes,
+ (atomUri)
+ }
+
+ atomId = element atom:id {
+ atomCommonAttributes,
+ (atomUri)
+ }
+
+ atomLogo = element atom:logo {
+ atomCommonAttributes,
+ (atomUri)
+ }
+
+ atomLink =
+ element atom:link {
+ atomCommonAttributes,
+ attribute href { atomUri },
+ attribute rel { atomNCName | atomUri }?,
+ attribute type { atomMediaType }?,
+ attribute hreflang { atomLanguageTag }?,
+ attribute title { text }?,
+ attribute length { text }?,
+ undefinedContent
+ }
+
+ atomPublished = element atom:published { atomDateConstruct }
+
+ atomRights = element atom:rights { atomTextConstruct }
+
+ atomSource =
+ element atom:source {
+ atomCommonAttributes,
+ (atomAuthor*
+ & atomCategory*
+ & atomContributor*
+ & atomGenerator?
+ & atomIcon?
+ & atomId?
+ & atomLink*
+ & atomLogo?
+ & atomRights?
+ & atomSubtitle?
+ & atomTitle?
+ & atomUpdated?
+ & extensionElement*)
+ }
+
+ atomSubtitle = element atom:subtitle { atomTextConstruct }
+
+ atomSummary = element atom:summary { atomTextConstruct }
+
+ atomTitle = element atom:title { atomTextConstruct }
+
+ atomUpdated = element atom:updated { atomDateConstruct }
+
+ atomNCName = xsd:string { minLength = "1" pattern = "[^:]*" }
+
+ # Whatever a media type is, it contains at least one slash
+ atomMediaType = xsd:string { pattern = ".+/.+" }
+
+ # As defined in RFC 3066
+ atomLanguageTag = xsd:string {
+ pattern = "[A-Za-z]{1,8}(-[A-Za-z0-9]{1,8})*"
+ }
+
+ # Unconstrained; it's not entirely clear how IRI fit into
+ # xsd:anyURI so let's not try to constrain it here
+ atomUri = text
+
+ # Whatever an email address is, it contains at least one @
+ atomEmailAddress = xsd:string { pattern = ".+@.+" }
+
+ simpleExtensionElement =
+ element * - atom:* {
+ text
+ }
+
+ structuredExtensionElement =
+ element * - atom:* {
+ (attribute * { text }+,
+ (text|anyElement)*)
+ | (attribute * { text }*,
+ (text?, anyElement+, (text|anyElement)*))
+ }
+
+ extensionElement =
+ simpleExtensionElement | structuredExtensionElement
+
+ undefinedAttribute =
+ attribute * - (xml:base | xml:lang | local:*) { text }
+
+ undefinedContent = (text|anyForeignElement)*
+
+ anyElement =
+ element * {
+ (attribute * { text }
+ | text
+ | anyElement)*
+ }
+
+ anyForeignElement =
+ element * - atom:* {
+ (attribute * { text }
+ | text
+ | anyElement)*
+ }
+
+ anyXHTML = element xhtml:* {
+ (attribute * { text }
+ | text
+ | anyXHTML)*
+ }
+
+ xhtmlDiv = element xhtml:div {
+ (attribute * { text }
+ | text
+ | anyXHTML)*
+ }
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/sch/gml-3.2.1.sch b/src/main/resources/org/opengis/cite/ogcapiprocesses10/sch/gml-3.2.1.sch
new file mode 100644
index 0000000..3e16139
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/sch/gml-3.2.1.sch
@@ -0,0 +1,110 @@
+
+
+ Schematron constraints for GML 3.2 (ISO 19136)
+
+
+
+
+
+ ValueArray may not carry both a reference to a
+ codeSpace and a uom
+
+
+
+
+ All components shall be of the same type
+ All components shall be of the same type
+
+
+
+
+ The presence of a dimension attribute
+ implies the presence of the srsName attribute.
+ The presence of an axisLabels attribute
+ implies the presence of the srsName attribute.
+ The presence of an uomLabels attribute implies
+ the presence of the srsName attribute.
+ The
+ presence of an uomLabels attribute implies the presence of the axisLabels attribute and vice
+ versa.
+
+
+
+
+ All patches shall
+ be gml:PolygonPatch elements or an element in the substitution group of gml:PolygonPatch.
+ Note that the test currently does not identify substitutable elements correctly, this will
+ require the use of XPath 2 in the future.
+
+
+
+
+ All patches shall be
+ gml:Triangle elements or an element in the substitution group of gml:PolygonPatch. Note that
+ the test currently does not identify substitutable elements correctly, this will require the
+ use of XPath 2 in the future.
+
+
+
+
+ Property element may not carry both a
+ reference to an object and contain an object.
+ Property element shall either carry a reference to
+ an object or contain an object.
+
+
+
+
+ All values in
+ the domain set shall be gml:MultiPoint elements or an element in its substitution group.
+ Note that the test currently does not identify substitutable elements correctly, this will
+ require the use of XPath 2 in the future.
+
+
+
+
+ All values in
+ the domain set shall be gml:MultiCurve elements or an element in its substitution group.
+ Note that the test currently does not identify substitutable elements correctly, this will
+ require the use of XPath 2 in the future.
+
+
+
+
+ All values in
+ the domain set shall be gml:MultiSurface elements or an element in its substitution group.
+ Note that the test currently does not identify substitutable elements correctly, this will
+ require the use of XPath 2 in the future.
+
+
+
+
+ All values in
+ the domain set shall be gml:MultiSolid elements or an element in its substitution group.
+ Note that the test currently does not identify substitutable elements correctly, this will
+ require the use of XPath 2 in the future.
+
+
+
+
+ All values in the
+ domain set shall be gml:Grid elements or an element in its substitution group. Note that the
+ test currently does not identify substitutable elements correctly, this will require the use
+ of XPath 2 in the future.
+
+
+
+
+ All values in
+ the domain set shall be gml:RectifiedGrid elements or an element in its substitution group.
+ Note that the test currently does not identify substitutable elements correctly, this will
+ require the use of XPath 2 in the future.
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/schema-catalog.xml b/src/main/resources/org/opengis/cite/ogcapiprocesses10/schema-catalog.xml
new file mode 100644
index 0000000..d1a9389
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/schema-catalog.xml
@@ -0,0 +1,40 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/schematron-catalog.xml b/src/main/resources/org/opengis/cite/ogcapiprocesses10/schematron-catalog.xml
new file mode 100644
index 0000000..7520f85
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/schematron-catalog.xml
@@ -0,0 +1,10 @@
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/testng.xml b/src/main/resources/org/opengis/cite/ogcapiprocesses10/testng.xml
new file mode 100644
index 0000000..21c3e08
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/testng.xml
@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gco-2007.xsd b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gco-2007.xsd
new file mode 100644
index 0000000..7037f53
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gco-2007.xsd
@@ -0,0 +1,428 @@
+
+
+
+ Geographic information -- Metadata -- XML schema implementation (ISO/TS
+ 19139:2007)
+ All include statements have been resolved.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A TypeName is a LocalName that references either a recordType or object type
+ in some form of schema. The stored value "aName" is the returned value for the "aName()"
+ operation. This is the types name. - For parsing from types (or objects) the parsible name
+ normally uses a "." navigation separator, so that it is of the form
+ [class].[member].[memberOfMember]. ...)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A MemberName is a LocalName that references either an attribute slot in a
+ record or recordType or an attribute, operation, or association role in an object instance
+ or type description in some form of schema. The stored value "aName" is the returned value
+ for the "aName()" operation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Use to represent the possible cardinality of a relation. Represented by a
+ set of simple multiplicity ranges.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A component of a multiplicity, consisting of an non-negative lower bound,
+ and a potentially infinite upper bound.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gmd-2007.xsd b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gmd-2007.xsd
new file mode 100644
index 0000000..058ee25
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gmd-2007.xsd
@@ -0,0 +1,2857 @@
+
+
+
+ Geographic information -- Metadata -- XML schema implementation (ISO/TS
+ 19139:2007)
+ All include statements have been resolved.
+
+
+
+
+
+
+
+ Types and numbers of raster spatial objects in the
+ dataset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about the vector spatial objects in the
+ dataset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Digital mechanism used to represent spatial information
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ New metadata element, not found in ISO 19115, which is required to describe
+ geographic data
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information describing metadata extensions.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information identifing the feature catalogue
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about the domain of the raster cell
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about an image's suitability for use
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Set of adjacent wavelengths in the electro-magnetic spectrum with a common
+ characteristic, such as the visible band
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about the application schema used to build the
+ dataset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information identifing the portrayal catalogue used
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ quantitative_result from Quality Procedures - - renamed to remove implied
+ use limitiation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Quantitative_conformance_measure from Quality Procedures. - - Renamed to
+ remove implied use limitation - - OCL - -- result is type specified by valueDomain -
+ result.tupleType = valueDomain
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Restrictions on the access and use of a dataset or
+ metadata
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Restrictions and legal prerequisites for accessing and using the
+ dataset.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Handling restrictions imposed on the dataset because of national security,
+ privacy, or other concerns
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about the media on which the data can be
+ distributed
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Technical means and media by which a dataset is obtained from the
+ distributor
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Common ways in which the dataset may be obtained or received, and related
+ instructions and fee information
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about the distributor
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about the distributor of and options for obtaining the
+ dataset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Description of the form of the data to be distributed
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Time period covered by the content of the dataset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Vertical domain of dataset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Boundary enclosing the dataset expressed as the closed set of (x,y)
+ coordinates of the polygon (last point replicates first point)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about spatial, vertical, and temporal extent
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Geographic area of the dataset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Geographic area of the entire dataset referenced to WGS
+ 84
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Extent with respect to date and time
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Description of the spatial and temporal reference systems used in the
+ dataset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Identification of, and means of communication with, person(s) and
+ organisations associated with the dataset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Standardized resource reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Location of the responsible individual or organisation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about online sources from which the dataset, specification, or
+ community profile name and extended metadata elements can be obtained.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information required enabling contact with the responsible person and/or
+ organisation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Telephone numbers for contacting the responsible individual or
+ organisation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about the scope and frequency of updating
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Description of the class of information covered by the
+ information
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Basic information about data
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Graphic that provides an illustration of the dataset (should include a
+ legend for the graphic)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ See 19119 for further info
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Brief description of ways in which the dataset is currently
+ used.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keywords, their type and reference source
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Encapsulates the dataset aggregation information
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ High-level geospatial data thematic classification to assist in the grouping
+ and search of available geospatial datasets
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information about the metadata
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Identifiable collection of datasets
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Identifiable collection of data
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gsr-2007.xsd b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gsr-2007.xsd
new file mode 100644
index 0000000..6bad300
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gsr-2007.xsd
@@ -0,0 +1,25 @@
+
+
+
+
+ Geographic information -- Metadata -- XML schema implementation (ISO/TS
+ 19139:2007)
+ All include statements have been resolved.
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gss-2007.xsd b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gss-2007.xsd
new file mode 100644
index 0000000..6b8763a
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gss-2007.xsd
@@ -0,0 +1,33 @@
+
+
+
+
+ Geographic information -- Metadata -- XML schema implementation (ISO/TS
+ 19139:2007)
+ All include statements have been resolved.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gts-2007.xsd b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gts-2007.xsd
new file mode 100644
index 0000000..dc8600d
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/iso/19139/2007/gts-2007.xsd
@@ -0,0 +1,32 @@
+
+
+
+
+ Geographic information -- Metadata -- XML schema implementation (ISO/TS
+ 19139:2007)
+ All include statements have been resolved.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/opengis/gml/3.2.1/gml-3.2.1.xsd b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/opengis/gml/3.2.1/gml-3.2.1.xsd
new file mode 100644
index 0000000..a0bd81e
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/opengis/gml/3.2.1/gml-3.2.1.xsd
@@ -0,0 +1,7806 @@
+
+
+
+ gml.xsd
+ Geographic information -- Geography Markup Language (ISO/TS
+ 19136:2007)
+ Also published
+ as OGC 07-036 (GML 3.2.1)
+ All include statements have been resolved.
+
+
+
+
+
+
+
+ Evidence is represented by a simple gml:dataSource or gml:dataSourceReference
+ property that indicates the source of the temporal data. The remote link attributes of the
+ gml:dataSource element have been deprecated along with its current type.
+
+
+
+
+ Evidence is represented by a simple gml:dataSource or gml:dataSourceReference
+ property that indicates the source of the temporal data.
+
+
+
+
+ A convenience group. This allows an application schema developer to include
+ dynamic properties in a content model in a standard fashion.
+
+
+
+
+
+
+
+
+
+
+ States are captured by time-stamped instances of a feature. The content model
+ extends the standard gml:AbstractFeatureType with the gml:dynamicProperties model group.
+ Each time-stamped instance represents a 'snapshot' of a feature. The dynamic feature classes
+ will normally be extended to suit particular applications. A dynamic feature bears either a
+ time stamp or a history.
+
+
+
+
+
+
+
+
+
+
+
+ A gml:DynamicFeatureCollection is a feature collection that has a gml:validTime
+ property (i.e. is a snapshot of the feature collection) or which has a gml:history property
+ that contains one or more gml:AbstractTimeSlices each of which contain values of the time
+ varying properties of the feature collection. Note that the gml:DynamicFeatureCollection may
+ be one of the following: 1. A feature collection which consists of static feature members
+ (members do not change in time) but which has properties of the collection object as a whole
+ that do change in time . 2. A feature collection which consists of dynamic feature members
+ (the members are gml:DynamicFeatures) but which also has properties of the collection as a
+ whole that vary in time.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ To describe an event — an action that occurs at an instant or over an interval
+ of time — GML provides the gml:AbtractTimeSlice element. A timeslice encapsulates the
+ time-varying properties of a dynamic feature -- it shall be extended to represent a time
+ stamped projection of a specific feature. The gml:dataSource property describes how the
+ temporal data was acquired. A gml:AbstractTimeSlice instance is a GML object that
+ encapsulates updates of the dynamic—or volatile—properties that reflect some change event;
+ it thus includes only those feature properties that have actually changed due to some
+ process. gml:AbstractTimeSlice basically provides a facility for attribute-level time
+ stamping, in contrast to the object-level time stamping of dynamic feature instances. The
+ time slice can thus be viewed as event or process-oriented, whereas a snapshot is more state
+ or structure-oriented. A timeslice has richer causality, whereas a snapshot merely portrays
+ the status of the whole.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A generic sequence of events constitute a gml:history of an object. The
+ gml:history element contains a set of elements in the substitution group headed by the
+ abstract element gml:AbstractTimeSlice, representing the time-varying properties of
+ interest. The history property of a dynamic feature associates a feature instance with a
+ sequence of time slices (i.e. change events) that encapsulate the evolution of the
+ feature.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A property that has a geometric complex as its value domain may either be an
+ appropriate geometry element encapsulated in an element of this type or an XLink reference
+ to a remote geometry element (where remote includes geometry elements located elsewhere in
+ the same document). Either the reference or the contained element shall be given, but
+ neither both nor none.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:CompositeCurve is represented by a sequence of (orientable) curves such
+ that each curve in the sequence terminates at the start point of the subsequent curve in the
+ list. curveMember references or contains inline one curve in the composite curve. The curves
+ are contiguous, the collection of curves is ordered. Therefore, if provided, the
+ aggregationType attribute shall have the value "sequence".
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:CompositeSurface is represented by a set of orientable surfaces. It is
+ geometry type with all the geometric properties of a (primitive) surface. Essentially, a
+ composite surface is a collection of surfaces that join in pairs on common boundary curves
+ and which, when considered as a whole, form a single surface. surfaceMember references or
+ contains inline one surface in the composite surface. The surfaces are
+ contiguous.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:CompositeSolid implements ISO 19107 GM_CompositeSolid (see ISO 19107:2003,
+ 6.6.7) as specified in D.2.3.6. A gml:CompositeSolid is represented by a set of orientable
+ surfaces. It is a geometry type with all the geometric properties of a (primitive) solid.
+ Essentially, a composite solid is a collection of solids that join in pairs on common
+ boundary surfaces and which, when considered as a whole, form a single solid. solidMember
+ references or contains one solid in the composite solid. The solids are
+ contiguous.
+
+
+
+
+ This abstract type supplies the root or base type for all topological elements
+ including primitives and complexes. It inherits AbstractGMLType and hence can be identified
+ using the gml:id attribute.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:AbstractTopoPrimitive acts as the base type for all topological primitives.
+ Topology primitives are the atomic (smallest possible) units of a topology complex. Each
+ topology primitive may contain references to other topology primitives of codimension 2 or
+ more (gml:isolated). Conversely, nodes may have faces as containers and nodes and edges may
+ have solids as containers (gml:container).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ In the case of planar topology, a gml:Node must have a clockwise
+ sequence of gml:directedEdge properties, to ensure a lossless topology
+ representation as defined by Kuijpers, et. al. (see OGC 05-102 Topology
+ IPR).
+
+
+
+
+
+
+
+
+
+
+ gml:Node represents the 0-dimensional primitive. The optional coboundary of a
+ node (gml:directedEdge) is a sequence of directed edges which are incident on this node.
+ Edges emanating from this node appear in the node coboundary with a negative orientation. If
+ provided, the aggregationType attribute shall have the value "sequence". A node may
+ optionally be realised by a 0-dimensional geometric primitive
+ (gml:pointProperty).
+
+
+
+
+ A gml:directedNode property element describes the boundary of topology edges
+ and is used in the support of topological point features via the gml:TopoPoint expression,
+ see below. The orientation attribute of type gml:SignType expresses the sense in which the
+ included node is used: start ("-") or end ("+") node.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:Edge represents the 1-dimensional primitive. The topological boundary of an
+ Edge (gml:directedNode) consists of a negatively directed start Node and a positively
+ directed end Node. The optional coboundary of an edge (gml:directedFace) is a circular
+ sequence of directed faces which are incident on this edge in document order. In the 2D
+ case, the orientation of the face on the left of the edge is "+"; the orientation of the
+ face on the right on its right is "-". If provided, the aggregationType attribute shall have
+ the value "sequence". An edge may optionally be realised by a 1-dimensional geometric
+ primitive (gml:curveProperty).
+
+
+
+
+ A gml:directedEdge property element describes the boundary of topology faces,
+ the coBoundary of topology nodes and is used in the support of topological line features via
+ the gml:TopoCurve expression, see below. The orientation attribute of type gml:SignType
+ expresses the sense in which the included edge is used, i.e. forward or
+ reverse.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ If the topological representation exists an unbounded manifold (e.g.
+ Euclidean plane), a gml:Face must indicate whether it is a universal face or not, to
+ ensure a lossless topology representation as defined by Kuijpers, et. al. (see OGC
+ 05-102 Topology IPR). The optional universal attribute of type boolean is used to
+ indicate this. NOTE The universal face is normally not part of any feature, and is
+ used to represent the unbounded portion of the data set. Its interior boundary (it has
+ no exterior boundary) would normally be considered the exterior boundary of the map
+ represented by the data set.
+
+
+
+
+
+
+
+ gml:Face represents the 2-dimensional topology primitive. The topological
+ boundary of a face (gml:directedEdge) consists of a sequence of directed edges. If provided,
+ the aggregationType attribute shall have the value "sequence". The optional coboundary of a
+ face (gml:directedTopoSolid) is a pair of directed solids which are bounded by this face. A
+ positively directed solid corresponds to a solid which lies in the direction of the
+ negatively directed normal to the face in any geometric realisation. A face may optionally
+ be realised by a 2-dimensional geometric primitive (gml:surfaceProperty).
+
+
+
+
+ The gml:directedFace property element describes the boundary of topology
+ solids, in the coBoundary of topology edges and is used in the support of surface features
+ via the gml:TopoSurface expression, see below. The orientation attribute of type
+ gml:SignType expresses the sense in which the included face is used i.e. inward or outward
+ with respect to the surface normal in any geometric realisation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:TopoSolid must indicate whether it is a universal topo-solid or
+ not, to ensure a lossless topology representation as defined by Kuijpers, et. al. (see
+ OGC 05-102 Topology IPR). The optional universal attribute of type boolean is used to
+ indicate this and the default is fault. NOTE The universal topo-solid is normally not
+ part of any feature, and is used to represent the unbounded portion of the data set.
+ Its interior boundary (it has no exterior boundary) would normally be considered the
+ exterior boundary of the data set.
+
+
+
+
+
+
+
+ gml:TopoSolid represents the 3-dimensional topology primitive. The topological
+ boundary of a solid (gml:directedFace) consists of a set of directed faces. A solid may
+ optionally be realised by a 3-dimensional geometric primitive
+ (gml:solidProperty).
+
+
+
+
+ The gml:directedSolid property element describes the coBoundary of topology
+ faces and is used in the support of volume features via the gml:TopoVolume expression, see
+ below. The orientation attribute of type gml:SignType expresses the sense in which the
+ included solid appears in the face coboundary. In the context of a gml:TopoVolume the
+ orientation attribute has no meaning.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The intended use of gml:TopoPoint is to appear within a point feature to
+ express the structural and possibly geometric relationships of this feature to other
+ features via shared node definitions.
+
+
+
+
+
+
+
+
+
+
+ The gml:topoPointProperty property element may be used in features to express
+ their relationship to the referenced topology node.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TopoCurve represents a homogeneous topological expression, a sequence of
+ directed edges, which if realised are isomorphic to a geometric curve primitive. The
+ intended use of gml:TopoCurve is to appear within a line feature to express the structural
+ and geometric relationships of this feature to other features via the shared edge
+ definitions. If provided, the aggregationType attribute shall have the value
+ "sequence".
+
+
+
+
+
+
+
+
+
+
+ The gml:topoCurveProperty property element may be used in features to express
+ their relationship to the referenced topology edges.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TopoSurface represents a homogeneous topological expression, a set of
+ directed faces, which if realised are isomorphic to a geometric surface primitive. The
+ intended use of gml:TopoSurface is to appear within a surface feature to express the
+ structural and possibly geometric relationships of this surface feature to other features
+ via the shared face definitions.
+
+
+
+
+
+
+
+
+
+
+ The gml:topoSurfaceProperty property element may be used in features to express
+ their relationship to the referenced topology faces.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TopoVolume represents a homogeneous topological expression, a set of
+ directed topologic solids, which if realised are isomorphic to a geometric solid primitive.
+ The intended use of gml:TopoVolume is to appear within a solid feature to express the
+ structural and geometric relationships of this solid feature to other features via the
+ shared solid definitions.
+
+
+
+
+
+
+
+
+
+
+ The gml:topoVolumeProperty element may be used in features to express their
+ relationship to the referenced topology volume.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TopoComplex is a collection of topological primitives. Each complex holds a
+ reference to its maximal complex (gml:maximalComplex) and optionally to sub- or
+ super-complexes (gml:subComplex, gml:superComplex). A topology complex contains its
+ primitive and sub-complex members.
+
+
+
+
+ The property elements gml:subComplex, gml:superComplex and gml:maximalComplex
+ provide an encoding for relationships between topology complexes as described for
+ gml:TopoComplex above.
+
+
+
+
+ The property elements gml:subComplex, gml:superComplex and gml:maximalComplex
+ provide an encoding for relationships between topology complexes as described for
+ gml:TopoComplex above.
+
+
+
+
+ The property elements gml:subComplex, gml:superComplex and gml:maximalComplex
+ provide an encoding for relationships between topology complexes as described for
+ gml:TopoComplex above.
+
+
+
+
+ The gml:topoPrimitiveMember property element encodes for the relationship
+ between a topology complex and a single topology primitive.
+
+
+
+
+
+
+
+
+
+
+
+ The gml:topoPrimitiveMembers property element encodes the relationship between
+ a topology complex and an arbitrary number of topology primitives.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The gml:Grid implicitly defines an unrectified grid, which is a network
+ composed of two or more sets of curves in which the members of each set intersect the
+ members of the other sets in an algorithmic way. The region of interest within the grid is
+ given in terms of its gml:limits, being the grid coordinates of diagonally opposed corners
+ of a rectangular region. gml:axisLabels is provided with a list of labels of the axes of the
+ grid (gml:axisName has been deprecated). gml:dimension specifies the dimension of the grid.
+ The gml:limits element contains a single gml:GridEnvelope. The gml:low and gml:high property
+ elements of the envelope are each integerLists, which are coordinate tuples, the coordinates
+ being measured as offsets from the origin of the grid along each axis, of the diagonally
+ opposing corners of a "rectangular" region of interest.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A rectified grid is a grid for which there is an affine transformation between
+ the grid coordinates and the coordinates of an external coordinate reference system. It is
+ defined by specifying the position (in some geometric space) of the grid "origin" and of the
+ vectors that specify the post locations. Note that the grid limits (post indexes) and axis
+ name properties are inherited from gml:GridType and that gml:RectifiedGrid adds a gml:origin
+ property (contains or references a gml:Point) and a set of gml:offsetVector
+ properties.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The base type for coverages is gml:AbstractCoverageType. The basic elements of
+ a coverage can be seen in this content model: the coverage contains gml:domainSet and
+ gml:rangeSet properties. The gml:domainSet property describes the domain of the coverage and
+ the gml:rangeSet property describes the range of the coverage.
+
+
+
+
+
+
+
+
+
+
+
+
+ This element serves as the head of a substitution group which may contain any
+ coverage whose type is derived from gml:AbstractCoverageType. It may act as a variable in
+ the definition of content models where it is required to permit any coverage to be
+ valid.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A discrete coverage consists of a domain set, range set and optionally a
+ coverage function. The domain set consists of either spatial or temporal geometry objects,
+ finite in number. The range set is comprised of a finite number of attribute values each of
+ which is associated to every direct position within any single spatiotemporal object in the
+ domain. In other words, the range values are constant on each spatiotemporal object in the
+ domain. This coverage function maps each element from the coverage domain to an element in
+ its range. The coverageFunction element describes the mapping function. This element serves
+ as the head of a substitution group which may contain any discrete coverage whose type is
+ derived from gml:DiscreteCoverageType.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A continuous coverage as defined in ISO 19123 is a coverage that can return
+ different values for the same feature attribute at different direct positions within a
+ single spatiotemporal object in its spatiotemporal domain. The base type for continuous
+ coverages is AbstractContinuousCoverageType. The coverageFunction element describes the
+ mapping function. The abstract element gml:AbstractContinuousCoverage serves as the head of
+ a substitution group which may contain any continuous coverage whose type is derived from
+ gml:AbstractContinuousCoverageType.
+
+
+
+
+ The gml:domainSet property element describes the spatio-temporal region of
+ interest, within which the coverage is defined. Its content model is given by
+ gml:DomainSetType. The value of the domain is thus a choice between a gml:AbstractGeometry
+ and a gml:AbstractTimeObject. In the instance these abstract elements will normally be
+ substituted by a geometry complex or temporal complex, to represent spatial coverages and
+ time-series, respectively. The presence of the gml:AssociationAttributeGroup means that
+ domainSet follows the usual GML property model and may use the xlink:href attribute to point
+ to the domain, as an alternative to describing the domain inline. Ownership semantics may be
+ provided using the gml:OwnershipAttributeGroup.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The gml:rangeSet property element contains the values of the coverage
+ (sometimes called the attribute values). Its content model is given by gml:RangeSetType.
+ This content model supports a structural description of the range. The semantic information
+ describing the range set is embedded using a uniform method, as part of the explicit values,
+ or as a template value accompanying the representation using gml:DataBlock and gml:File. The
+ values from each component (or "band") in the range may be encoded within a gml:ValueArray
+ element or a concrete member of the gml:AbstractScalarValueList substitution group . Use of
+ these elements satisfies the value-type homogeneity requirement.
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:DataBlock describes the Range as a block of text encoded values similar to
+ a Common Separated Value (CSV) representation. The range set parameterization is described
+ by the property gml:rangeParameters.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:CoordinatesType consists of a list of coordinate tuples, with each
+ coordinate tuple separated by the ts or tuple separator (whitespace), and each coordinate in
+ the tuple by the cs or coordinate separator (comma). The gml:tupleList encoding is
+ effectively "band-interleaved".
+
+
+
+
+ gml:doubleOrNilReasonList consists of a list of gml:doubleOrNilReason values,
+ each separated by a whitespace. The gml:doubleOrNilReason values are grouped into tuples
+ where the dimension of each tuple in the list is equal to the number of range
+ parameters.
+
+
+
+
+ for efficiency reasons, GML also provides a means of encoding the range set in
+ an arbitrary external encoding, such as a binary file. This encoding may be "well-known" but
+ this is not required. This mode uses the gml:File element. The values of the coverage
+ (attribute values in the range set) are transmitted in a external file that is referenced
+ from the XML structure described by gml:FileType. The external file is referenced by the
+ gml:fileReference property that is an anyURI (the gml:fileName property has been
+ deprecated). This means that the external file may be located remotely from the referencing
+ GML instance. The gml:compression property points to a definition of a compression algorithm
+ through an anyURI. This may be a retrievable, computable definition or simply a reference to
+ an unambiguous name for the compression method. The gml:mimeType property points to a
+ definition of the file mime type. The gml:fileStructure property is defined by a codelist.
+ Note further that all values shall be enclosed in a single file. Multi-file structures for
+ values are not supported in GML. The semantics of the range set is described as above using
+ the gml:rangeParameters property. Note that if any compression algorithm is applied, the
+ structure above applies only to the pre-compression or post-decompression structure of the
+ file. Note that the fields within a record match the gml:valueComponents of the
+ gml:CompositeValue in document order.
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+ The gml:coverageFunction property describes the mapping function from the
+ domain to the range of the coverage. The value of the CoverageFunction is one of
+ gml:CoverageMappingRule and gml:GridFunction. If the gml:coverageFunction property is
+ omitted for a gridded coverage (including rectified gridded coverages) the gml:startPoint is
+ assumed to be the value of the gml:low property in the gml:Grid geometry, and the
+ gml:sequenceRule is assumed to be linear and the gml:axisOrder property is assumed to be "+1
+ +2".
+
+
+
+
+
+
+
+
+
+
+
+ gml:CoverageMappingRule provides a formal or informal description of the
+ coverage function. The mapping rule may be defined as an in-line string (gml:ruleDefinition)
+ or via a remote reference through xlink:href (gml:ruleReference). If no rule name is
+ specified, the default is 'Linear' with respect to members of the domain in document
+ order.
+
+
+
+
+
+
+
+
+
+
+ gml:GridFunction provides an explicit mapping rule for grid geometries, i.e.
+ the domain shall be a geometry of type grid. It describes the mapping of grid posts
+ (discrete point grid coverage) or grid cells (discrete surface coverage) to the values in
+ the range set. The gml:startPoint is the index position of a point in the grid that is
+ mapped to the first point in the range set (this is also the index position of the first
+ grid post). If the gml:startPoint property is omitted the gml:startPoint is assumed to be
+ equal to the value of gml:low in the gml:Grid geometry. Subsequent points in the mapping are
+ determined by the value of the gml:sequenceRule.
+
+
+
+
+
+
+
+
+
+
+ The gml:SequenceRuleType is derived from the gml:SequenceRuleEnumeration
+ through the addition of an axisOrder attribute. The gml:SequenceRuleEnumeration is an
+ enumerated type. The rule names are defined in ISO 19123. If no rule name is specified the
+ default is "Linear".
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The different values in a gml:AxisDirectionList indicate the incrementation
+ order to be used on all axes of the grid. Each axis shall be mentioned once and only
+ once.
+
+
+
+
+
+ The value of a gml:AxisDirection indicates the incrementation order to be used
+ on an axis of the grid.
+
+
+
+
+
+
+
+ In a gml:MultiPointCoverage the domain set is a gml:MultiPoint, that is a
+ collection of arbitrarily distributed geometric points. The content model is identical with
+ gml:DiscreteCoverageType, but that gml:domainSet shall have values gml:MultiPoint. In a
+ gml:MultiPointCoverage the mapping from the domain to the range is straightforward. - For
+ gml:DataBlock encodings the points of the gml:MultiPoint are mapped in document order to the
+ tuples of the data block. - For gml:CompositeValue encodings the points of the
+ gml:MultiPoint are mapped to the members of the composite value in document order. - For
+ gml:File encodings the points of the gml:MultiPoint are mapped to the records of the file in
+ sequential order.
+
+
+
+
+ In a gml:MultiCurveCoverage the domain is partioned into a collection of curves
+ comprising a gml:MultiCurve. The coverage function then maps each curve in the collection to
+ a value in the range set. The content model is identical with gml:DiscreteCoverageType, but
+ that gml:domainSet shall have values gml:MultiCurve. In a gml:MultiCurveCoverage the mapping
+ from the domain to the range is straightforward. - For gml:DataBlock encodings the curves of
+ the gml:MultiCurve are mapped in document order to the tuples of the data block. - For
+ gml:CompositeValue encodings the curves of the gml:MultiCurve are mapped to the members of
+ the composite value in document order. - For gml:File encodings the curves of the
+ gml:MultiCurve are mapped to the records of the file in sequential order.
+
+
+
+
+ In a gml:MultiSurfaceCoverage the domain is partioned into a collection of
+ surfaces comprising a gml:MultiSurface. The coverage function than maps each surface in the
+ collection to a value in the range set. The content model is identical with
+ gml:DiscreteCoverageType, but that gml:domainSet shall have values gml:MultiSurface. In a
+ gml:MultiSurfaceCoverage the mapping from the domain to the range is straightforward. - For
+ gml:DataBlock encodings the surfaces of the gml:MultiSurface are mapped in document order to
+ the tuples of the data block. - For gml:CompositeValue encodings the surfaces of the
+ gml:MultiSurface are mapped to the members of the composite value in document order. - For
+ gml:File encodings the surfaces of the gml:MultiSurface are mapped to the records of the
+ file in sequential order.
+
+
+
+
+ In a gml:MultiSolidCoverage the domain is partioned into a collection of solids
+ comprising a gml:MultiSolid. The coverage function than maps each solid in the collection to
+ a value in the range set. The content model is identical with gml:DiscreteCoverageType, but
+ that gml:domainSet shall have values gml:MultiSolid. In a gml:MultiSolidCoverage the mapping
+ from the domain to the range is straightforward. - For gml:DataBlock encodings the solids of
+ the gml:MultiSolid are mapped in document order to the tuples of the data block. - For
+ gml:CompositeValue encodings the solids of the gml:MultiSolid are mapped to the members of
+ the composite value in document order. - For gml:File encodings the solids of the
+ gml:MultiSolid are mapped to the records of the file in sequential order.
+
+
+
+
+ A gml:GriddedCoverage is a discrete point coverage in which the domain set is a
+ geometric grid of points. Note that this is the same as the gml:MultiPointCoverage except
+ that we have a gml:Grid to describe the domain. The simple gridded coverage is not
+ geometrically referenced and hence no geometric positions are assignable to the points in
+ the grid. Such geometric positioning is introduced in the
+ gml:RectifiedGridCoverage.
+
+
+
+
+ The gml:RectifiedGridCoverage is a discrete point coverage based on a rectified
+ grid. It is similar to the grid coverage except that the points of the grid are
+ geometrically referenced. The rectified grid coverage has a domain that is a
+ gml:RectifiedGrid geometry.
+
+
+
+
+ gml:CoordinateSystemAxis is a definition of a coordinate system
+ axis.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The uom attribute provides an identifier of the unit of measure used for
+ this coordinate system axis. The value of this coordinate in a coordinate tuple shall
+ be recorded using this unit of measure, whenever those coordinates use a coordinate
+ reference system that uses a coordinate system that uses this axis.
+
+
+
+
+
+
+
+ gml:axisAbbrev is the abbreviation used for this coordinate system axis; this
+ abbreviation is also used to identify the coordinates in the coordinate tuple. The codeSpace
+ attribute may reference a source of more information on a set of standardized abbreviations,
+ or on this abbreviation.
+
+
+
+
+ gml:axisDirection is the direction of this coordinate system axis (or in the
+ case of Cartesian projected coordinates, the direction of this coordinate system axis at the
+ origin). Within any set of coordinate system axes, only one of each pair of terms may be
+ used. For earth-fixed CRSs, this direction is often approximate and intended to provide a
+ human interpretable meaning to the axis. When a geodetic datum is used, the precise
+ directions of the axes may therefore vary slightly from this approximate direction. The
+ codeSpace attribute shall reference a source of information specifying the values and
+ meanings of all the allowed string values for this property.
+
+
+
+
+ The gml:minimumValue and gml:maximumValue properties allow the specification of
+ minimum and maximum value normally allowed for this axis, in the unit of measure for the
+ axis. For a continuous angular axis such as longitude, the values wrap-around at this value.
+ Also, values beyond this minimum/maximum can be used for specified purposes, such as in a
+ bounding box. A value of minus infinity shall be allowed for the gml:minimumValue element, a
+ value of plus infiniy for the gml:maximumValue element. If these elements are omitted, the
+ value is unspecified.
+
+
+
+
+ The gml:minimumValue and gml:maximumValue properties allow the specification of
+ minimum and maximum value normally allowed for this axis, in the unit of measure for the
+ axis. For a continuous angular axis such as longitude, the values wrap-around at this value.
+ Also, values beyond this minimum/maximum can be used for specified purposes, such as in a
+ bounding box. A value of minus infinity shall be allowed for the gml:minimumValue element, a
+ value of plus infiniy for the gml:maximumValue element. If these elements are omitted, the
+ value is unspecified.
+
+
+
+
+ gml:rangeMeaning describes the meaning of axis value range specified by
+ gml:minimumValue and gml:maximumValue. This element shall be omitted when both
+ gml:minimumValue and gml:maximumValue are omitted. This element should be included when
+ gml:minimumValue and/or gml:maximumValue are included. If this element is omitted when the
+ gml:minimumValue and/or gml:maximumValue are included, the meaning is unspecified. The
+ codeSpace attribute shall reference a source of information specifying the values and
+ meanings of all the allowed string values for this property.
+
+
+
+
+ gml:CoordinateSystemAxisPropertyType is a property type for association roles
+ to a coordinate system axis, either referencing or containing the definition of that
+ axis.
+
+
+
+
+
+
+
+
+ gml:AbstractCoordinateSystem is a coordinate system (CS) is the non-repeating
+ sequence of coordinate system axes that spans a given coordinate space. A CS is derived from
+ a set of mathematical rules for specifying how coordinates in a given space are to be
+ assigned to points. The coordinate values in a coordinate tuple shall be recorded in the
+ order in which the coordinate system axes associations are recorded. This abstract complex
+ type shall not be used, extended, or restricted, in an Application Schema, to define a
+ concrete subtype with a meaning equivalent to a concrete subtype specified in this
+ document.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The gml:axis property is an association role (ordered sequence) to the
+ coordinate system axes included in this coordinate system. The coordinate values in a
+ coordinate tuple shall be recorded in the order in which the coordinate system axes
+ associations are recorded, whenever those coordinates use a coordinate reference system that
+ uses this coordinate system. The gml:AggregationAttributeGroup should be used to specify
+ that the axis objects are ordered.
+
+
+
+
+ gml:CoordinateSystemPropertyType is a property type for association roles to a
+ coordinate system, either referencing or containing the definition of that coordinate
+ system.
+
+
+
+
+
+
+
+
+ gml:EllipsoidalCS is a two- or three-dimensional coordinate system in which
+ position is specified by geodetic latitude, geodetic longitude, and (in the
+ three-dimensional case) ellipsoidal height. An EllipsoidalCS shall have two or three
+ gml:axis property elements; the number of associations shall equal the dimension of the
+ CS.
+
+
+
+
+
+
+
+
+
+ gml:EllipsoidalCSPropertyType is a property type for association roles to an
+ ellipsoidal coordinate system, either referencing or containing the definition of that
+ coordinate system.
+
+
+
+
+
+
+
+
+ gml:CartesianCS is a 1-, 2-, or 3-dimensional coordinate system. In the
+ 1-dimensional case, it contains a single straight coordinate axis. In the 2- and
+ 3-dimensional cases gives the position of points relative to orthogonal straight axes. In
+ the multi-dimensional case, all axes shall have the same length unit of measure. A
+ CartesianCS shall have one, two, or three gml:axis property elements.
+
+
+
+
+
+
+
+
+
+ gml:CartesianCSPropertyType is a property type for association roles to a
+ Cartesian coordinate system, either referencing or containing the definition of that
+ coordinate system.
+
+
+
+
+
+
+
+
+ gml:VerticalCS is a one-dimensional coordinate system used to record the
+ heights or depths of points. Such a coordinate system is usually dependent on the Earth's
+ gravity field, perhaps loosely as when atmospheric pressure is the basis for the vertical
+ coordinate system axis. A VerticalCS shall have one gml:axis property
+ element.
+
+
+
+
+
+
+
+
+
+ gml:VerticalCSPropertyType is a property type for association roles to a
+ vertical coordinate system, either referencing or containing the definition of that
+ coordinate system.
+
+
+
+
+
+
+
+
+ gml:TimeCS is a one-dimensional coordinate system containing a time axis, used
+ to describe the temporal position of a point in the specified time units from a specified
+ time origin. A TimeCS shall have one gml:axis property element.
+
+
+
+
+
+
+
+
+
+ gml:TimeCSPropertyType is a property type for association roles to a time
+ coordinate system, either referencing or containing the definition of that coordinate
+ system.
+
+
+
+
+
+
+
+
+ gml:LinearCS is a one-dimensional coordinate system that consists of the points
+ that lie on the single axis described. The associated coordinate is the distance – with or
+ without offset – from the specified datum to the point along the axis. A LinearCS shall have
+ one gml:axis property element.
+
+
+
+
+
+
+
+
+
+ gml:LinearCSPropertyType is a property type for association roles to a linear
+ coordinate system, either referencing or containing the definition of that coordinate
+ system.
+
+
+
+
+
+
+
+
+ gml:UserDefinedCS is a two- or three-dimensional coordinate system that
+ consists of any combination of coordinate axes not covered by any other coordinate system
+ type. A UserDefinedCS shall have two or three gml:axis property elements; the number of
+ property elements shall equal the dimension of the CS.
+
+
+
+
+
+
+
+
+
+ gml:UserDefinedCSPropertyType is a property type for association roles to a
+ user-defined coordinate system, either referencing or containing the definition of that
+ coordinate system.
+
+
+
+
+
+
+
+
+ gml:SphericalCS is a three-dimensional coordinate system with one distance
+ measured from the origin and two angular coordinates. A SphericalCS shall have three
+ gml:axis property elements.
+
+
+
+
+
+
+
+
+
+ gml:SphericalCSPropertyType is property type for association roles to a
+ spherical coordinate system, either referencing or containing the definition of that
+ coordinate system.
+
+
+
+
+
+
+
+
+ gml:PolarCS ia s two-dimensional coordinate system in which position is
+ specified by the distance from the origin and the angle between the line from the origin to
+ a point and a reference direction. A PolarCS shall have two gml:axis property
+ elements.
+
+
+
+
+
+
+
+
+
+ gml:PolarCSPropertyType is a property type for association roles to a polar
+ coordinate system, either referencing or containing the definition of that coordinate
+ system.
+
+
+
+
+
+
+
+
+ gml:CylindricalCS is a three-dimensional coordinate system consisting of a
+ polar coordinate system extended by a straight coordinate axis perpendicular to the plane
+ spanned by the polar coordinate system. A CylindricalCS shall have three gml:axis property
+ elements.
+
+
+
+
+
+
+
+
+
+ gml:CylindricalCSPropertyType is a property type for association roles to a
+ cylindrical coordinate system, either referencing or containing the definition of that
+ coordinate system.
+
+
+
+
+
+
+
+
+ gml:AffineCS is a two- or three-dimensional coordinate system with straight
+ axes that are not necessarily orthogonal. An AffineCS shall have two or three gml:axis
+ property elements; the number of property elements shall equal the dimension of the
+ CS.
+
+
+
+
+
+
+
+
+
+ gml:AffineCSPropertyType is a property type for association roles to an affine
+ coordinate system, either referencing or containing the definition of that coordinate
+ system.
+
+
+
+
+
+
+
+
+ A gml:AbstractDatum specifies the relationship of a coordinate system to the
+ earth, thus creating a coordinate reference system. A datum uses a parameter or set of
+ parameters that determine the location of the origin of the coordinate reference system.
+ Each datum subtype may be associated with only specific types of coordinate systems. This
+ abstract complex type shall not be used, extended, or restricted, in a GML Application
+ Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype
+ specified in this document.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:anchorDefinition is a description, possibly including coordinates, of the
+ definition used to anchor the datum to the Earth. Also known as the "origin", especially for
+ engineering and image datums. The codeSpace attribute may be used to reference a source of
+ more detailed on this point or surface, or on a set of such descriptions. - For a geodetic
+ datum, this point is also known as the fundamental point, which is traditionally the point
+ where the relationship between geoid and ellipsoid is defined. In some cases, the
+ "fundamental point" may consist of a number of points. In those cases, the parameters
+ defining the geoid/ellipsoid relationship have been averaged for these points, and the
+ averages adopted as the datum definition. - For an engineering datum, the anchor definition
+ may be a physical point, or it may be a point with defined coordinates in another CRS.may -
+ For an image datum, the anchor definition is usually either the centre of the image or the
+ corner of the image. - For a temporal datum, this attribute is not defined. Instead of the
+ anchor definition, a temporal datum carries a separate time origin of type
+ DateTime.
+
+
+
+
+ gml:realizationEpoch is the time after which this datum definition is valid.
+ See ISO 19111 Table 32 for details.
+
+
+
+
+ gml:DatumPropertyType is a property type for association roles to a datum,
+ either referencing or containing the definition of that datum.
+
+
+
+
+
+
+
+
+ gml:GeodeticDatum is a geodetic datum defines the precise location and
+ orientation in 3-dimensional space of a defined ellipsoid (or sphere), or of a Cartesian
+ coordinate system centered in this ellipsoid (or sphere).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:primeMeridian is an association role to the prime meridian used by this
+ geodetic datum.
+
+
+
+
+ gml:ellipsoid is an association role to the ellipsoid used by this geodetic
+ datum.
+
+
+
+
+ gml:GeodeticDatumPropertyType is a property type for association roles to a
+ geodetic datum, either referencing or containing the definition of that
+ datum.
+
+
+
+
+
+
+
+
+ A gml:Ellipsoid is a geometric figure that may be used to describe the
+ approximate shape of the earth. In mathematical terms, it is a surface formed by the
+ rotation of an ellipse about its minor axis.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:semiMajorAxis specifies the length of the semi-major axis of the ellipsoid,
+ with its units. Uses the MeasureType with the restriction that the unit of measure
+ referenced by uom must be suitable for a length, such as metres or feet.
+
+
+
+
+ gml:secondDefiningParameter is a property containing the definition of the
+ second parameter that defines the shape of an ellipsoid. An ellipsoid requires two defining
+ parameters: semi-major axis and inverse flattening or semi-major axis and semi-minor axis.
+ When the reference body is a sphere rather than an ellipsoid, only a single defining
+ parameter is required, namely the radius of the sphere; in that case, the semi-major axis
+ "degenerates" into the radius of the sphere. The inverseFlattening element contains the
+ inverse flattening value of the ellipsoid. This value is a scale factor (or ratio). It uses
+ gml:LengthType with the restriction that the unit of measure referenced by the uom attribute
+ must be suitable for a scale factor, such as percent, permil, or parts-per-million. The
+ semiMinorAxis element contains the length of the semi-minor axis of the ellipsoid. When the
+ isSphere element is included, the ellipsoid is degenerate and is actually a sphere. The
+ sphere is completely defined by the semi-major axis, which is the radius of the
+ sphere.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:EllipsoidPropertyType is a property type for association roles to an
+ ellipsoid, either referencing or containing the definition of that
+ ellipsoid.
+
+
+
+
+
+
+
+
+ A gml:PrimeMeridian defines the origin from which longitude values are
+ determined. The default value for the prime meridian gml:identifier value is
+ "Greenwich".
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:greenwichLongitude is the longitude of the prime meridian measured from the
+ Greenwich meridian, positive eastward. If the value of the prime meridian "name" is
+ "Greenwich" then the value of greenwichLongitude shall be 0 degrees.
+
+
+
+
+ gml:PrimeMeridianPropertyType is a property type for association roles to a
+ prime meridian, either referencing or containing the definition of that
+ meridian.
+
+
+
+
+
+
+
+
+ gml:EngineeringDatum defines the origin of an engineering coordinate reference
+ system, and is used in a region around that origin. This origin may be fixed with respect to
+ the earth (such as a defined point at a construction site), or be a defined point on a
+ moving vehicle (such as on a ship or satellite).
+
+
+
+
+
+
+
+
+
+ gml:EngineeringDatumPropertyType is a property type for association roles to an
+ engineering datum, either referencing or containing the definition of that
+ datum.
+
+
+
+
+
+
+
+
+ gml:ImageDatum defines the origin of an image coordinate reference system, and
+ is used in a local context only. For an image datum, the anchor definition is usually either
+ the centre of the image or the corner of the image. For more information, see ISO 19111
+ B.3.5.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:pixelInCell is a specification of the way an image grid is associated with
+ the image data attributes. The required codeSpace attribute shall reference a source of
+ information specifying the values and meanings of all the allowed string values for this
+ property.
+
+
+
+
+ gml:ImageDatumPropertyType is a property type for association roles to an image
+ datum, either referencing or containing the definition of that datum.
+
+
+
+
+
+
+
+
+ gml:VerticalDatum is a textual description and/or a set of parameters
+ identifying a particular reference level surface used as a zero-height surface, including
+ its position with respect to the Earth for any of the height types recognized by this
+ International Standard.
+
+
+
+
+
+
+
+
+
+ gml:VerticalDatumPropertyType is property type for association roles to a
+ vertical datum, either referencing or containing the definition of that
+ datum.
+
+
+
+
+
+
+
+
+ A gml:TemporalDatum defines the origin of a Temporal Reference System. This
+ type omits the "anchorDefinition" and "realizationEpoch" elements and adds the "origin"
+ element with the dateTime type.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The TemporalDatumBaseType partially defines the origin of a temporal coordinate
+ reference system. This type restricts the AbstractDatumType to remove the "anchorDefinition"
+ and "realizationEpoch" elements.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:origin is the date and time origin of this temporal datum.
+
+
+
+
+ gml:TemporalDatumPropertyType is a property type for association roles to a
+ temporal datum, either referencing or containing the definition of that
+ datum.
+
+
+
+
+
+
+
+
+ gml:IdentifiedObjectType provides identification properties of a CRS-related
+ object. In gml:DefinitionType, the gml:identifier element shall be the primary name by which
+ this object is identified, encoding the "name" attribute in the UML model. Zero or more of
+ the gml:name elements can be an unordered set of "identifiers", encoding the "identifier"
+ attribute in the UML model. Each of these gml:name elements can reference elsewhere the
+ object's defining information or be an identifier by which this object can be referenced.
+ Zero or more other gml:name elements can be an unordered set of "alias" alternative names by
+ which this CRS related object is identified, encoding the "alias" attributes in the UML
+ model. An object may have several aliases, typically used in different contexts. The context
+ for an alias is indicated by the value of its (optional) codeSpace attribute. Any needed
+ version information shall be included in the codeSpace attribute of a gml:identifier and
+ gml:name elements. In this use, the gml:remarks element in the gml:DefinitionType shall
+ contain comments on or information about this object, including data source
+ information.
+
+
+
+
+
+
+
+ gml:AbstractCRS specifies a coordinate reference system which is usually single
+ but may be compound. This abstract complex type shall not be used, extended, or restricted,
+ in a GML Application Schema, to define a concrete subtype with a meaning equivalent to a
+ concrete subtype specified in this document.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The gml:domainOfValidity property implements an association role to an
+ EX_Extent object as encoded in ISO/TS 19139, either referencing or containing the definition
+ of that extent.
+
+
+
+
+
+
+
+
+
+
+ The gml:scope property provides a description of the usage, or limitations of
+ usage, for which this CRS-related object is valid. If unknown, enter "not
+ known".
+
+
+
+
+ gml:CRSPropertyType is a property type for association roles to a CRS abstract
+ coordinate reference system, either referencing or containing the definition of that
+ CRS.
+
+
+
+
+
+
+
+
+ gml:AbstractCoordinateOperation is a mathematical operation on coordinates that
+ transforms or converts coordinates to another coordinate reference system. Many but not all
+ coordinate operations (from CRS A to CRS B) also uniquely define the inverse operation (from
+ CRS B to CRS A). In some cases, the operation method algorithm for the inverse operation is
+ the same as for the forward algorithm, but the signs of some operation parameter values
+ shall be reversed. In other cases, different algorithms are required for the forward and
+ inverse operations, but the same operation parameter values are used. If (some) entirely
+ different parameter values are needed, a different coordinate operation shall be defined.
+ The optional coordinateOperationAccuracy property elements provide estimates of the impact
+ of this coordinate operation on point position accuracy.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:operationVersion is the version of the coordinate transformation (i.e.,
+ instantiation due to the stochastic nature of the parameters). Mandatory when describing a
+ transformation, and should not be supplied for a conversion.
+
+
+
+
+ gml:coordinateOperationAccuracy is an association role to a
+ DQ_PositionalAccuracy object as encoded in ISO/TS 19139, either referencing or containing
+ the definition of that positional accuracy. That object contains an estimate of the impact
+ of this coordinate operation on point accuracy. That is, it gives position error estimates
+ for the target coordinates of this coordinate operation, assuming no errors in the source
+ coordinates.
+
+
+
+
+
+
+
+
+
+
+ gml:sourceCRS is an association role to the source CRS (coordinate reference
+ system) of this coordinate operation.
+
+
+
+
+ gml:targetCRS is an association role to the target CRS (coordinate reference
+ system) of this coordinate operation.
+
+
+
+
+ gml:CoordinateOperationPropertyType is a property type for association roles to
+ a coordinate operation, either referencing or containing the definition of that coordinate
+ operation.
+
+
+
+
+
+
+
+
+ gml:AbstractSingleOperation is a single (not concatenated) coordinate
+ operation.
+
+
+
+
+ gml:SingleOperationPropertyType is a property type for association roles to a
+ single operation, either referencing or containing the definition of that single
+ operation.
+
+
+
+
+
+
+
+
+ gm:AbstractGeneralConversion is an abstract operation on coordinates that does
+ not include any change of datum. The best-known example of a coordinate conversion is a map
+ projection. The parameters describing coordinate conversions are defined rather than
+ empirically derived. Note that some conversions have no parameters. The operationVersion,
+ sourceCRS, and targetCRS elements are omitted in a coordinate conversion. This abstract
+ complex type is expected to be extended for well-known operation methods with many
+ Conversion instances, in GML Application Schemas that define operation-method-specialized
+ element names and contents. This conversion uses an operation method, usually with
+ associated parameter values. However, operation methods and parameter values are directly
+ associated with concrete subtypes, not with this abstract type. All concrete types derived
+ from this type shall extend this type to include a "usesMethod" element that references the
+ "OperationMethod" element. Similarly, all concrete types derived from this type shall extend
+ this type to include zero or more elements each named "uses...Value" that each use the type
+ of an element substitutable for the "AbstractGeneralParameterValue" element.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:GeneralConversionPropertyType is a property type for association roles to a
+ general conversion, either referencing or containing the definition of that
+ conversion.
+
+
+
+
+
+
+
+
+ gml:AbstractGeneralTransformation is an abstract operation on coordinates that
+ usually includes a change of Datum. The parameters of a coordinate transformation are
+ empirically derived from data containing the coordinates of a series of points in both
+ coordinate reference systems. This computational process is usually "over-determined",
+ allowing derivation of error (or accuracy) estimates for the transformation. Also, the
+ stochastic nature of the parameters may result in multiple (different) versions of the same
+ coordinate transformation. The operationVersion, sourceCRS, and targetCRS proeprty elements
+ are mandatory in a coordinate transformation. This abstract complex type is expected to be
+ extended for well-known operation methods with many Transformation instances, in Application
+ Schemas that define operation-method-specialized value element names and contents. This
+ transformation uses an operation method with associated parameter values. However, operation
+ methods and parameter values are directly associated with concrete subtypes, not with this
+ abstract type. All concrete types derived from this type shall extend this type to include a
+ "usesMethod" element that references one "OperationMethod" element. Similarly, all concrete
+ types derived from this type shall extend this type to include one or more elements each
+ named "uses...Value" that each use the type of an element substitutable for the
+ "AbstractGeneralParameterValue" element.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:GeneralTransformationPropertyType is a property type for association roles
+ to a general transformation, either referencing or containing the definition of that
+ transformation.
+
+
+
+
+
+
+
+
+
+ gml:ConcatenatedOperation is an ordered sequence of two or more coordinate
+ operations. This sequence of operations is constrained by the requirement that the source
+ coordinate reference system of step (n+1) must be the same as the target coordinate
+ reference system of step (n). The source coordinate reference system of the first step and
+ the target coordinate reference system of the last step are the source and target coordinate
+ reference system associated with the concatenated operation. Instead of a forward operation,
+ an inverse operation may be used for one or more of the operation steps mentioned above, if
+ the inverse operation is uniquely defined by the forward operation. The gml:coordOperation
+ property elements are an ordered sequence of associations to the two or more operations used
+ by this concatenated operation. The AggregationAttributeGroup should be used to specify that
+ the coordOperation associations are ordered.
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:coordOperation is an association role to a coordinate
+ operation.
+
+
+
+
+ gml:ConcatenatedOperationPropertyType is a property type for association roles
+ to a concatenated operation, either referencing or containing the definition of that
+ concatenated operation.
+
+
+
+
+
+
+
+
+ gml:PassThroughOperation is a pass-through operation specifies that a subset of
+ a coordinate tuple is subject to a specific coordinate operation. The modifiedCoordinate
+ property elements are an ordered sequence of positive integers defining the positions in a
+ coordinate tuple of the coordinates affected by this pass-through operation. The
+ AggregationAttributeGroup should be used to specify that the modifiedCoordinate elements are
+ ordered.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:modifiedCoordinate is a positive integer defining a position in a
+ coordinate tuple.
+
+
+
+
+ gml:PassThroughOperationPropertyType is a property type for association roles
+ to a pass through operation, either referencing or containing the definition of that pass
+ through operation.
+
+
+
+
+
+
+
+
+ gml:Conversion is a concrete operation on coordinates that does not include any
+ change of Datum. The best-known example of a coordinate conversion is a map projection. The
+ parameters describing coordinate conversions are defined rather than empirically derived.
+ Note that some conversions have no parameters. This concrete complex type can be used
+ without using a GML Application Schema that defines operation-method-specialized element
+ names and contents, especially for methods with only one Conversion instance. The usesValue
+ property elements are an unordered list of composition associations to the set of parameter
+ values used by this conversion operation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:method is an association role to the operation method used by a coordinate
+ operation.
+
+
+
+
+ gml:parameterValue is a composition association to a parameter value or group
+ of parameter values used by a coordinate operation.
+
+
+
+
+ gml:ConversionPropertyType is a property type for association roles to a
+ concrete general-purpose conversion, either referencing or containing the definition of that
+ conversion.
+
+
+
+
+
+
+
+
+ gml:Transformation is a concrete object element derived from
+ gml:GeneralTransformation (13.6.2.13). This concrete object can be used for all operation
+ methods, without using a GML Application Schema that defines operation-method-specialized
+ element names and contents, especially for methods with only one Transformation instance.
+ The parameterValue elements are an unordered list of composition associations to the set of
+ parameter values used by this conversion operation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TransformationPropertyType is a property type for association roles to a
+ transformation, either referencing or containing the definition of that
+ transformation.
+
+
+
+
+
+
+
+
+ gml:AbstractGeneralParameterValue is an abstract parameter value or group of
+ parameter values. This abstract complexType is expected to be extended and restricted for
+ well-known operation methods with many instances, in Application Schemas that define
+ operation-method-specialized element names and contents. Specific parameter value elements
+ are directly contained in concrete subtypes, not in this abstract type. All concrete types
+ derived from this type shall extend this type to include one "...Value" element with an
+ appropriate type, which should be one of the element types allowed in the
+ ParameterValueType. In addition, all derived concrete types shall extend this type to
+ include a "operationParameter" property element that references one element substitutable
+ for the "OperationParameter" object element.
+
+
+
+
+
+
+
+ gml:AbstractGeneralParameterValuePropertyType is a property type for inline
+ association roles to a parameter value or group of parameter values, always containing the
+ values.
+
+
+
+
+
+
+
+ gml:ParameterValue is a parameter value, an ordered sequence of values, or a
+ reference to a file of parameter values. This concrete complex type may be used for
+ operation methods without using an Application Schema that defines
+ operation-method-specialized element names and contents, especially for methods with only
+ one instance. This complex type may be used, extended, or restricted for well-known
+ operation methods, especially for methods with many instances.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:value is a numeric value of an operation parameter, with its associated
+ unit of measure.
+
+
+
+
+ gml:stringValue is a character string value of an operation parameter. A string
+ value does not have an associated unit of measure.
+
+
+
+
+ gml:integerValue is a positive integer value of an operation parameter, usually
+ used for a count. An integer value does not have an associated unit of
+ measure.
+
+
+
+
+ gml:booleanValue is a boolean value of an operation parameter. A Boolean value
+ does not have an associated unit of measure.
+
+
+
+
+ gml:valueList is an ordered sequence of two or more numeric values of an
+ operation parameter list, where each value has the same associated unit of measure. An
+ element of this type contains a space-separated sequence of double values.
+
+
+
+
+ gml:integerValueList is an ordered sequence of two or more integer values of an
+ operation parameter list, usually used for counts. These integer values do not have an
+ associated unit of measure. An element of this type contains a space-separated sequence of
+ integer values.
+
+
+
+
+ gml:valueFile is a reference to a file or a part of a file containing one or
+ more parameter values, each numeric value with its associated unit of measure. When
+ referencing a part of a file, that file shall contain multiple identified parts, such as an
+ XML encoded document. Furthermore, the referenced file or part of a file may reference
+ another part of the same or different files, as allowed in XML documents.
+
+
+
+
+ gml:operationParameter is an association role to the operation parameter of
+ which this is a value.
+
+
+
+
+ gml:ParameterValueGroup is a group of related parameter values. The same group
+ can be repeated more than once in a Conversion, Transformation, or higher level
+ ParameterValueGroup, if those instances contain different values of one or more
+ parameterValues which suitably distinquish among those groups. This concrete complex type
+ can be used for operation methods without using an Application Schema that defines
+ operation-method-specialized element names and contents. This complex type may be used,
+ extended, or restricted for well-known operation methods, especially for methods with only
+ one instance. The parameterValue elements are an unordered set of composition association
+ roles to the parameter values and groups of values included in this group.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:group is an association role to the operation parameter group for which
+ this element provides parameter values.
+
+
+
+
+ gml:OperationMethod is a method (algorithm or procedure) used to perform a
+ coordinate operation. Most operation methods use a number of operation parameters, although
+ some coordinate conversions use none. Each coordinate operation using the method assigns
+ values to these parameters. The parameter elements are an unordered list of associations to
+ the set of operation parameters and parameter groups used by this operation
+ method.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:formulaCitation provides a reference to a publication giving the formula(s)
+ or procedure used by an coordinate operation method.
+
+
+
+
+
+
+
+
+
+
+ gml:formula Formula(s) or procedure used by an operation method. The use of the
+ codespace attribite has been deprecated. The property value shall be a character
+ string.
+
+
+
+
+ gml:sourceDimensions is the number of dimensions in the source CRS of this
+ operation method.
+
+
+
+
+ gml:targetDimensions is the number of dimensions in the target CRS of this
+ operation method.
+
+
+
+
+ gml:parameter is an association to an operation parameter or parameter
+ group.
+
+
+
+
+ gml:OperationMethodPropertyType is a property type for association roles to a
+ concrete general-purpose operation method, either referencing or containing the definition
+ of that method.
+
+
+
+
+
+
+
+
+ gml:GeneralOperationParameter is the abstract definition of a parameter or
+ group of parameters used by an operation method.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:minimumOccurs is the minimum number of times that values for this parameter
+ group or parameter are required. If this attribute is omitted, the minimum number shall be
+ one.
+
+
+
+
+ gml:AbstractGeneralOperationParameterPropertyType is a property type for
+ association roles to an operation parameter or group, either referencing or containing the
+ definition of that parameter or group.
+
+
+
+
+
+
+
+
+ gml:OperationParameter is the definition of a parameter used by an operation
+ method. Most parameter values are numeric, but other types of parameter values are possible.
+ This complex type is expected to be used or extended for all operation methods, without
+ defining operation-method-specialized element names.
+
+
+
+
+
+
+
+
+
+
+
+ gml:OperationParameterPropertyType is a property type for association roles to
+ an operation parameter, either referencing or containing the definition of that
+ parameter.
+
+
+
+
+
+
+
+
+ gml:OperationParameterGroup is the definition of a group of parameters used by
+ an operation method. This complex type is expected to be used or extended for all applicable
+ operation methods, without defining operation-method-specialized element names. The
+ generalOperationParameter elements are an unordered list of associations to the set of
+ operation parameters that are members of this group.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:maximumOccurs is the maximum number of times that values for this parameter
+ group may be included. If this attribute is omitted, the maximum number shall be
+ one.
+
+
+
+
+ gml:OperationParameterPropertyType is a property type for association roles to
+ an operation parameter group, either referencing or containing the definition of that
+ parameter group.
+
+
+
+
+
+
+
+
+ gml:AbstractSingleCRS implements a coordinate reference system consisting of
+ one coordinate system and one datum (as opposed to a Compound CRS).
+
+
+
+
+ gml:SingleCRSPropertyType is a property type for association roles to a single
+ coordinate reference system, either referencing or containing the definition of that
+ coordinate reference system.
+
+
+
+
+
+
+
+
+ gml:AbstractGeneralDerivedCRS is a coordinate reference system that is defined
+ by its coordinate conversion from another coordinate reference system. This abstract complex
+ type shall not be used, extended, or restricted, in a GML Application Schema, to define a
+ concrete subtype with a meaning equivalent to a concrete subtype specified in this
+ document.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:conversion is an association role to the coordinate conversion used to
+ define the derived CRS.
+
+
+
+
+ gml:CompundCRS is a coordinate reference system describing the position of
+ points through two or more independent coordinate reference systems. It is associated with a
+ non-repeating sequence of two or more instances of SingleCRS.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The gml:componentReferenceSystem elements are an ordered sequence of
+ associations to all the component coordinate reference systems included in this compound
+ coordinate reference system. The gml:AggregationAttributeGroup should be used to specify
+ that the gml:componentReferenceSystem properties are ordered.
+
+
+
+
+ gml:CompoundCRSPropertyType is a property type for association roles to a
+ compound coordinate reference system, either referencing or containing the definition of
+ that reference system.
+
+
+
+
+
+
+
+
+
+ gml:GeodeticCRS is a coordinate reference system based on a geodetic
+ datum.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:ellipsoidalCS is an association role to the ellipsoidal coordinate system
+ used by this CRS.
+
+
+
+
+ gml:cartesianCS is an association role to the Cartesian coordinate system used
+ by this CRS.
+
+
+
+
+ gml:sphericalCS is an association role to the spherical coordinate system used
+ by this CRS.
+
+
+
+
+ gml:geodeticDatum is an association role to the geodetic datum used by this
+ CRS.
+
+
+
+
+ gml:GeodeticCRSPropertyType is a property type for association roles to a
+ geodetic coordinate reference system, either referencing or containing the definition of
+ that reference system.
+
+
+
+
+
+
+
+
+ gml:VerticalCRS is a 1D coordinate reference system used for recording heights
+ or depths. Vertical CRSs make use of the direction of gravity to define the concept of
+ height or depth, but the relationship with gravity may not be straightforward. By
+ implication, ellipsoidal heights (h) cannot be captured in a vertical coordinate reference
+ system. Ellipsoidal heights cannot exist independently, but only as an inseparable part of a
+ 3D coordinate tuple defined in a geographic 3D coordinate reference system.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:verticalCS is an association role to the vertical coordinate system used by
+ this CRS.
+
+
+
+
+ gml:verticalDatum is an association role to the vertical datum used by this
+ CRS.
+
+
+
+
+ gml:VerticalCRSPropertyType is a property type for association roles to a
+ vertical coordinate reference system, either referencing or containing the definition of
+ that reference system.
+
+
+
+
+
+
+
+
+ gml:ProjectedCRS is a 2D coordinate reference system used to approximate the
+ shape of the earth on a planar surface, but in such a way that the distortion that is
+ inherent to the approximation is carefully controlled and known. Distortion correction is
+ commonly applied to calculated bearings and distances to produce values that are a close
+ match to actual field values.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:baseGeodeticCRS is an association role to the geodetic coordinate reference
+ system used by this projected CRS.
+
+
+
+
+ gml:ProjectedCRSPropertyType is a property type for association roles to a
+ projected coordinate reference system, either referencing or containing the definition of
+ that reference system.
+
+
+
+
+
+
+
+
+ gml:DerivedCRS is a single coordinate reference system that is defined by its
+ coordinate conversion from another single coordinate reference system known as the base CRS.
+ The base CRS can be a projected coordinate reference system, if this DerivedCRS is used for
+ a georectified grid coverage as described in ISO 19123, Clause 8.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:baseCRS is an association role to the coordinate reference system used by
+ this derived CRS.
+
+
+
+
+ The gml:derivedCRSType property describes the type of a derived coordinate
+ reference system. The required codeSpace attribute shall reference a source of information
+ specifying the values and meanings of all the allowed string values for this
+ property.
+
+
+
+
+ An association role to the coordinate system used by this CRS.
+
+
+
+
+ gml:DerivedCRSPropertyType is a property type for association roles to a
+ non-projected derived coordinate reference system, either referencing or containing the
+ definition of that reference system.
+
+
+
+
+
+
+
+
+ gml:EngineeringCRS is a contextually local coordinate reference system which
+ can be divided into two broad categories: - earth-fixed systems applied to engineering
+ activities on or near the surface of the earth; - CRSs on moving platforms such as road
+ vehicles, vessels, aircraft, or spacecraft, see ISO 19111 8.3.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+ gml:cylindricalCS is an association role to the cylindrical coordinate system
+ used by this CRS.
+
+
+
+
+ gml:linearCS is an association role to the linear coordinate system used by
+ this CRS.
+
+
+
+
+ gml:polarCS is an association role to the polar coordinate system used by this
+ CRS.
+
+
+
+
+ gml:userDefinedCS is an association role to the user defined coordinate system
+ used by this CRS.
+
+
+
+
+ gml:engineeringDatum is an association role to the engineering datum used by
+ this CRS.
+
+
+
+
+ gml:EngineeringCRSPropertyType is a property type for association roles to an
+ engineering coordinate reference system, either referencing or containing the definition of
+ that reference system.
+
+
+
+
+
+
+
+
+ gml:ImageCRS is an engineering coordinate reference system applied to locations
+ in images. Image coordinate reference systems are treated as a separate sub-type because the
+ definition of the associated image datum contains two attributes not relevant to other
+ engineering datums.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:affineCS is an association role to the affine coordinate system used by
+ this CRS.
+
+
+
+
+ gml:imageDatum is an association role to the image datum used by this
+ CRS.
+
+
+
+
+ gml:ImageCRSPropertyType is a property type for association roles to an image
+ coordinate reference system, either referencing or containing the definition of that
+ reference system.
+
+
+
+
+
+
+
+
+ gml:TemporalCRS is a 1D coordinate reference system used for the recording of
+ time.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:timeCS is an association role to the time coordinate system used by this
+ CRS.
+
+
+
+
+ gml:temporalDatum is an association role to the temporal datum used by this
+ CRS.
+
+
+
+
+ gml:TemporalCRSPropertyType is a property type for association roles to a
+ temporal coordinate reference system, either referencing or containing the definition of
+ that reference system.
+
+
+
+
+
+
+
+
+ gml:AbstractSurfaceType is an abstraction of a surface to support the different
+ levels of complexity. A surface is always a continuous region of a plane.
+
+
+
+
+
+
+
+ The AbstractSurface element is the abstract head of the substitution group for
+ all (continuous) surface elements.
+
+
+
+
+ A property that has a surface as its value domain may either be an appropriate
+ geometry element encapsulated in an element of this type or an XLink reference to a remote
+ geometry element (where remote includes geometry elements located elsewhere in the same
+ document). Either the reference or the contained element shall be given, but neither both
+ nor none.
+
+
+
+
+
+
+
+
+
+ This property element either references a surface via the XLink-attributes or
+ contains the surface element. surfaceProperty is the predefined property which may be used
+ by GML Application Schemas whenever a GML feature has a property with a value that is
+ substitutable for AbstractSurface.
+
+
+
+
+ gml:SurfaceArrayPropertyType is a container for an array of surfaces. The
+ elements are always contained in the array property, referencing geometry elements or arrays
+ of geometry elements via XLinks is not supported.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Polygon is a special surface that is defined by a single surface patch (see
+ D.3.6). The boundary of this patch is coplanar and the polygon uses planar interpolation in
+ its interior. The elements exterior and interior describe the surface boundary of the
+ polygon.
+
+
+
+
+ A boundary of a surface consists of a number of rings. In the normal 2D case,
+ one of these rings is distinguished as being the exterior boundary. In a general manifold
+ this is not always possible, in which case all boundaries shall be listed as interior
+ boundaries, and the exterior will be empty.
+
+
+
+
+ A boundary of a surface consists of a number of rings. The "interior" rings
+ separate the surface / surface patch from the area enclosed by the rings.
+
+
+
+
+
+
+
+ An abstraction of a ring to support surface boundaries of different complexity.
+ The AbstractRing element is the abstract head of the substituition group for all closed
+ boundaries of a surface patch.
+
+
+
+
+ A property with the content model of gml:AbstractRingPropertyType encapsulates
+ a ring to represent the surface boundary property of a surface.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A LinearRing is defined by four or more coordinate tuples, with linear
+ interpolation between them; the first and last coordinates shall be coincident. The number
+ of direct positions in the list shall be at least four.
+
+
+
+
+ A property with the content model of gml:LinearRingPropertyType encapsulates a
+ linear ring to represent a component of a surface boundary.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A curve is a 1-dimensional primitive. Curves are continuous, connected, and
+ have a measurable length in terms of the coordinate system. A curve is composed of one or
+ more curve segments. Each curve segment within a curve may be defined using a different
+ interpolation method. The curve segments are connected to one another, with the end point of
+ each segment except the last being the start point of the next segment in the segment list.
+ The orientation of the curve is positive. The element segments encapsulates the segments of
+ the curve.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The property baseCurve references or contains the base curve, i.e. it either
+ references the base curve via the XLink-attributes or contains the curve element. A curve
+ element is any element which is substitutable for AbstractCurve. The base curve has positive
+ orientation.
+
+
+
+
+ OrientableCurve consists of a curve and an orientation. If the orientation is
+ "+", then the OrientableCurve is identical to the baseCurve. If the orientation is "-", then
+ the OrientableCurve is related to another AbstractCurve with a parameterization that
+ reverses the sense of the curve traversal.
+
+
+
+
+
+
+
+
+
+ A curve segment defines a homogeneous segment of a curve. The attributes
+ numDerivativesAtStart, numDerivativesAtEnd and numDerivativesInterior specify the type of
+ continuity as specified in ISO 19107:2003, 6.4.9.3. The AbstractCurveSegment element is the
+ abstract head of the substituition group for all curve segment elements, i.e. continuous
+ segments of the same interpolation mechanism. All curve segments shall have an attribute
+ interpolation with type gml:CurveInterpolationType specifying the curve interpolation
+ mechanism used for this segment. This mechanism uses the control points and control
+ parameters to determine the position of this curve segment.
+
+
+
+
+ gml:CurveSegmentArrayPropertyType is a container for an array of curve
+ segments.
+
+
+
+
+
+
+
+ This property element contains a list of curve segments. The order of the
+ elements is significant and shall be preserved when processing the array.
+
+
+
+
+ gml:CurveInterpolationType is a list of codes that may be used to identify the
+ interpolation mechanisms specified by an application schema.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A LineStringSegment is a curve segment that is defined by two or more control
+ points including the start and end point, with linear interpolation between them. The
+ content model follows the general pattern for the encoding of curve
+ segments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ An ArcString is a curve segment that uses three-point circular arc
+ interpolation ("circularArc3Points"). The number of arcs in the arc string may be explicitly
+ stated in the attribute numArc. The number of control points in the arc string shall be 2 *
+ numArc + 1. The content model follows the general pattern for the encoding of curve
+ segments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ An Arc is an arc string with only one arc unit, i.e. three control points
+ including the start and end point. As arc is an arc string consisting of a single arc, the
+ attribute "numArc" is fixed to "1".
+
+
+
+
+
+
+
+
+
+ A Circle is an arc whose ends coincide to form a simple closed loop. The three
+ control points shall be distinct non-co-linear points for the circle to be unambiguously
+ defined. The arc is simply extended past the third control point until the first control
+ point is encountered.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This variant of the arc computes the mid points of the arcs instead of storing
+ the coordinates directly. The control point sequence consists of the start and end points of
+ each arc plus the bulge (see ISO 19107:2003, 6.4.17.2). The normal is a vector normal
+ (perpendicular) to the chord of the arc (see ISO 19107:2003, 6.4.17.4). The interpolation is
+ fixed as "circularArc2PointWithBulge". The number of arcs in the arc string may be
+ explicitly stated in the attribute numArc. The number of control points in the arc string
+ shall be numArc + 1. The content model follows the general pattern for the encoding of curve
+ segments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ An ArcByBulge is an arc string with only one arc unit, i.e. two control points,
+ one bulge and one normal vector. As arc is an arc string consisting of a single arc, the
+ attribute "numArc" is fixed to "1".
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This variant of the arc requires that the points on the arc shall be computed
+ instead of storing the coordinates directly. The single control point is the center point of
+ the arc plus the radius and the bearing at start and end. This representation can be used
+ only in 2D. The element radius specifies the radius of the arc. The element startAngle
+ specifies the bearing of the arc at the start. The element endAngle specifies the bearing of
+ the arc at the end. The interpolation is fixed as "circularArcCenterPointWithRadius". Since
+ this type describes always a single arc, the attribute "numArc" is fixed to "1". The content
+ model follows the general pattern for the encoding of curve segments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:CircleByCenterPoint is an gml:ArcByCenterPoint with identical start and
+ end angle to form a full circle. Again, this representation can be used only in
+ 2D.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The number of control points shall be at least three. vectorAtStart is the unit
+ tangent vector at the start point of the spline. vectorAtEnd is the unit tangent vector at
+ the end point of the spline. Only the direction of the vectors shall be used to determine
+ the shape of the cubic spline, not their length. interpolation is fixed as "cubicSpline".
+ degree shall be the degree of the polynomial used for the interpolation in this spline.
+ Therefore the degree for a cubic spline is fixed to "3". The content model follows the
+ general pattern for the encoding of curve segments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A B-Spline is a piecewise parametric polynomial or rational curve described in
+ terms of control points and basis functions as specified in ISO 19107:2003, 6.4.30.
+ Therefore, interpolation may be either "polynomialSpline" or "rationalSpline" depending on
+ the interpolation type; default is "polynomialSpline". degree shall be the degree of the
+ polynomial used for interpolation in this spline. knot shall be the sequence of distinct
+ knots used to define the spline basis functions (see ISO 19107:2003, 6.4.26.2). The
+ attribute isPolynomial shall be set to "true" if this is a polynomial spline (see ISO
+ 19107:2003, 6.4.30.5). The attribute knotType shall provide the type of knot distribution
+ used in defining this spline (see ISO 19107:2003, 6.4.30.4). The content model follows the
+ general pattern for the encoding of curve segments.
+
+
+
+
+
+
+
+
+
+
+
+ gml:KnotPropertyType encapsulates a knot to use it in a geometric
+ type.
+
+
+
+
+ A knot is a breakpoint on a piecewise spline curve. value is the value of
+ the parameter at the knot of the spline (see ISO 19107:2003, 6.4.24.2). multiplicity is
+ the multiplicity of this knot used in the definition of the spline (with the same
+ weight). weight is the value of the averaging weight used for this knot of the
+ spline.
+
+
+
+
+
+
+ This enumeration type specifies values for the knots' type (see ISO 19107:2003,
+ 6.4.25).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Bezier curves are polynomial splines that use Bezier or Bernstein polynomials
+ for interpolation purposes. It is a special case of the B-Spline curve with two knots.
+ degree shall be the degree of the polynomial used for interpolation in this spline. knot
+ shall be the sequence of distinct knots used to define the spline basis functions.
+ interpolation is fixed as "polynomialSpline". isPolynomial is fixed as "true". knotType is
+ not relevant for Bezier curve segments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ An offset curve is a curve at a constant distance from the basis curve.
+ offsetBase is the base curve from which this curve is defined as an offset. distance and
+ refDirection have the same meaning as specified in ISO 19107:2003, 6.4.23. The content model
+ follows the general pattern for the encoding of curve segments.
+
+
+
+
+
+
+
+
+
+
+
+
+ location, refDirection, inDimension and outDimension have the same meaning as
+ specified in ISO 19107:2003, 6.4.21.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A clothoid, or Cornu's spiral, is plane curve whose curvature is a fixed
+ function of its length. refLocation, startParameter, endParameter and scaleFactor have the
+ same meaning as specified in ISO 19107:2003, 6.4.22. interpolation is fixed as "clothoid".
+ The content model follows the general pattern for the encoding of curve
+ segments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A sequence of geodesic segments. The number of control points shall be at least
+ two. interpolation is fixed as "geodesic". The content model follows the general pattern for
+ the encoding of curve segments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Surface is a 2-dimensional primitive and is composed of one or more surface
+ patches as specified in ISO 19107:2003, 6.3.17.1. The surface patches are connected to one
+ another. patches encapsulates the patches of the surface.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The property baseSurface references or contains the base surface. The property
+ baseSurface either references the base surface via the XLink-attributes or contains the
+ surface element. A surface element is any element which is substitutable for
+ gml:AbstractSurface. The base surface has positive orientation.
+
+
+
+
+ OrientableSurface consists of a surface and an orientation. If the orientation
+ is "+", then the OrientableSurface is identical to the baseSurface. If the orientation is
+ "-", then the OrientableSurface is a reference to a gml:AbstractSurface with an up-normal
+ that reverses the direction for this OrientableSurface, the sense of "the top of the
+ surface".
+
+
+
+
+
+ A surface patch defines a homogenuous portion of a surface. The
+ AbstractSurfacePatch element is the abstract head of the substituition group for all surface
+ patch elements describing a continuous portion of a surface. All surface patches shall have
+ an attribute interpolation (declared in the types derived from gml:AbstractSurfacePatchType)
+ specifying the interpolation mechanism used for the patch using
+ gml:SurfaceInterpolationType.
+
+
+
+
+ gml:SurfacePatchArrayPropertyType is a container for a sequence of surface
+ patches.
+
+
+
+
+
+
+
+ The patches property element contains the sequence of surface patches. The
+ order of the elements is significant and shall be preserved when processing the
+ array.
+
+
+
+
+ gml:SurfaceInterpolationType is a list of codes that may be used to identify
+ the interpolation mechanisms specified by an application schema.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:PolygonPatch is a surface patch that is defined by a set of boundary
+ curves and an underlying surface to which these curves adhere. The curves shall be coplanar
+ and the polygon uses planar interpolation in its interior. interpolation is fixed to
+ "planar", i.e. an interpolation shall return points on a single plane. The boundary of the
+ patch shall be contained within that plane.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:Triangle represents a triangle as a surface patch with an outer boundary
+ consisting of a linear ring. Note that this is a polygon (subtype) with no inner boundaries.
+ The number of points in the linear ring shall be four. The ring (element exterior) shall be
+ a gml:LinearRing and shall form a triangle, the first and the last position shall be
+ coincident. interpolation is fixed to "planar", i.e. an interpolation shall return points on
+ a single plane. The boundary of the patch shall be contained within that
+ plane.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:Rectangle represents a rectangle as a surface patch with an outer boundary
+ consisting of a linear ring. Note that this is a polygon (subtype) with no inner boundaries.
+ The number of points in the linear ring shall be five. The ring (element exterior) shall be
+ a gml:LinearRing and shall form a rectangle; the first and the last position shall be
+ coincident. interpolation is fixed to "planar", i.e. an interpolation shall return points on
+ a single plane. The boundary of the patch shall be contained within that
+ plane.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A ring is used to represent a single connected component of a surface boundary
+ as specified in ISO 19107:2003, 6.3.6. Every gml:curveMember references or contains one
+ curve, i.e. any element which is substitutable for gml:AbstractCurve. In the context of a
+ ring, the curves describe the boundary of the surface. The sequence of curves shall be
+ contiguous and connected in a cycle. If provided, the aggregationType attribute shall have
+ the value "sequence".
+
+
+
+
+
+ A property with the content model of gml:RingPropertyType encapsulates a ring
+ to represent a component of a surface boundary.
+
+
+
+
+
+
+
+ A gml:PointGrid group contains or references points or positions which are
+ organised into sequences or grids. All rows shall have the same number of positions
+ (columns).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The element provides a substitution group head for the surface patches based on
+ parametric curves. All properties are specified in the derived subtypes. All derived
+ subtypes shall conform to the constraints specified in ISO 19107:2003, 6.4.40. If provided,
+ the aggregationType attribute shall have the value "set".
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ if provided, rows gives the number of rows, columns the number of columns in
+ the parameter grid. The parameter grid is represented by an instance of the gml:PointGrid
+ group. The element provides a substitution group head for the surface patches based on a
+ grid. All derived subtypes shall conform to the constraints specified in ISO 19107:2003,
+ 6.4.41.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A polyhedral surface is a surface composed of polygon patches connected along
+ their common boundary curves. This differs from the surface type only in the restriction on
+ the types of surface patches acceptable. polygonPatches encapsulates the polygon patches of
+ the polyhedral surface.
+
+
+
+
+ A triangulated surface is a polyhedral surface that is composed only of
+ triangles. There is no restriction on how the triangulation is derived. trianglePatches
+ encapsulates the triangles of the triangulated surface.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A tin is a triangulated surface that uses the Delauny algorithm or a similar
+ algorithm complemented with consideration of stoplines (stopLines), breaklines (breakLines),
+ and maximum length of triangle sides (maxLength). controlPoint shall contain a set of the
+ positions (three or more) used as posts for this TIN (corners of the triangles in the TIN).
+ See ISO 19107:2003, 6.4.39 for details.
+
+
+
+
+ gml:LineStringSegmentArrayPropertyType provides a container for line
+ strings.
+
+
+
+
+
+
+
+ gml:AbstractSolidType is an abstraction of a solid to support the different
+ levels of complexity. The solid may always be viewed as a geometric primitive, i.e. is
+ contiguous.
+
+
+
+
+
+
+
+ The AbstractSolid element is the abstract head of the substituition group for
+ all (continuous) solid elements.
+
+
+
+
+ A property that has a solid as its value domain may either be an appropriate
+ geometry element encapsulated in an element of this type or an XLink reference to a remote
+ geometry element (where remote includes geometry elements located elsewhere in the same
+ document). Either the reference or the contained element shall be given, but neither both
+ nor none.
+
+
+
+
+
+
+
+
+
+ This property element either references a solid via the XLink-attributes or
+ contains the solid element. solidProperty is the predefined property which may be used by
+ GML Application Schemas whenever a GML feature has a property with a value that is
+ substitutable for AbstractSolid.
+
+
+
+
+ gml:SolidArrayPropertyType is a container for an array of solids. The elements
+ are always contained in the array property, referencing geometry elements or arrays of
+ geometry elements is not supported.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A solid is the basis for 3-dimensional geometry. The extent of a solid is
+ defined by the boundary surfaces as specified in ISO 19107:2003, 6.3.18. exterior specifies
+ the outer boundary, interior the inner boundary of the solid.
+
+
+
+
+
+
+
+
+
+
+ A shell is used to represent a single connected component of a solid boundary
+ as specified in ISO 19107:2003, 6.3.8. Every gml:surfaceMember references or contains one
+ surface, i.e. any element which is substitutable for gml:AbstractSurface. In the context of
+ a shell, the surfaces describe the boundary of the solid. If provided, the aggregationType
+ attribute shall have the value "set".
+
+
+
+
+ This property element either references a surface via the XLink-attributes or
+ contains the surface element. A surface element is any element, which is substitutable for
+ gml:AbstractSurface.
+
+
+
+
+ A property with the content model of gml:ShellPropertyType encapsulates a shell
+ to represent a component of a solid boundary.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:AbstractGeometricAggregate is the abstract head of the substitution group
+ for all geometric aggregates.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:MultiGeometry is a collection of one or more GML geometry objects of
+ arbitrary type. The members of the geometric aggregate may be specified either using the
+ "standard" property (gml:geometryMember) or the array property (gml:geometryMembers). It is
+ also valid to use both the "standard" and the array properties in the same
+ collection.
+
+
+
+
+ This property element either references a geometry element via the
+ XLink-attributes or contains the geometry element.
+
+
+
+
+ This property element contains a list of geometry elements. The order of the
+ elements is significant and shall be preserved when processing the array.
+
+
+
+
+ A property that has a geometric aggregate as its value domain may either be an
+ appropriate geometry element encapsulated in an element of this type or an XLink reference
+ to a remote geometry element (where remote includes geometry elements located elsewhere in
+ the same document). Either the reference or the contained element shall be given, but
+ neither both nor none.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:MultiPoint consists of one or more gml:Points. The members of the
+ geometric aggregate may be specified either using the "standard" property (gml:pointMember)
+ or the array property (gml:pointMembers). It is also valid to use both the "standard" and
+ the array properties in the same collection.
+
+
+
+
+ This property element either references a Point via the XLink-attributes or
+ contains the Point element.
+
+
+
+
+ This property element contains a list of points. The order of the elements is
+ significant and shall be preserved when processing the array.
+
+
+
+
+ A property that has a collection of points as its value domain may either be an
+ appropriate geometry element encapsulated in an element of this type or an XLink reference
+ to a remote geometry element (where remote includes geometry elements located elsewhere in
+ the same document). Either the reference or the contained element shall be given, but
+ neither both nor none.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:MultiCurve is defined by one or more gml:AbstractCurves. The members of
+ the geometric aggregate may be specified either using the "standard" property
+ (gml:curveMember) or the array property (gml:curveMembers). It is also valid to use both the
+ "standard" and the array properties in the same collection.
+
+
+
+
+ This property element contains a list of curves. The order of the elements is
+ significant and shall be preserved when processing the array.
+
+
+
+
+ A property that has a collection of curves as its value domain may either be an
+ appropriate geometry element encapsulated in an element of this type or an XLink reference
+ to a remote geometry element (where remote includes geometry elements located elsewhere in
+ the same document). Either the reference or the contained element shall be given, but
+ neither both nor none.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:MultiSurface is defined by one or more gml:AbstractSurfaces. The members
+ of the geometric aggregate may be specified either using the "standard" property
+ (gml:surfaceMember) or the array property (gml:surfaceMembers). It is also valid to use both
+ the "standard" and the array properties in the same collection.
+
+
+
+
+ This property element contains a list of surfaces. The order of the elements is
+ significant and shall be preserved when processing the array.
+
+
+
+
+ A property that has a collection of surfaces as its value domain may either be
+ an appropriate geometry element encapsulated in an element of this type or an XLink
+ reference to a remote geometry element (where remote includes geometry elements located
+ elsewhere in the same document). Either the reference or the contained element shall be
+ given, but neither both nor none.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:MultiSolid is defined by one or more gml:AbstractSolids. The members of
+ the geometric aggregate may be specified either using the "standard" property
+ (gml:solidMember) or the array property (gml:solidMembers). It is also valid to use both the
+ "standard" and the array properties in the same collection.
+
+
+
+
+ This property element either references a solid via the XLink-attributes or
+ contains the solid element. A solid element is any element, which is substitutable for
+ gml:AbstractSolid.
+
+
+
+
+ This property element contains a list of solids. The order of the elements is
+ significant and shall be preserved when processing the array.
+
+
+
+
+ A property that has a collection of solids as its value domain may either be an
+ appropriate geometry element encapsulated in an element of this type or an XLink reference
+ to a remote geometry element (where remote includes geometry elements located elsewhere in
+ the same document). Either the reference or the contained element shall be given, but
+ neither both nor none.
+
+
+
+
+
+
+
+
+
+ The basic feature model is given by the gml:AbstractFeatureType. The content
+ model for gml:AbstractFeatureType adds two specific properties suitable for geographic
+ features to the content model defined in gml:AbstractGMLType. The value of the gml:boundedBy
+ property describes an envelope that encloses the entire feature instance, and is primarily
+ useful for supporting rapid searching for features that occur in a particular location. The
+ value of the gml:location property describes the extent, position or relative location of
+ the feature.
+
+
+
+
+
+
+
+
+
+
+
+
+ This abstract element serves as the head of a substitution group which may
+ contain any elements whose content model is derived from gml:AbstractFeatureType. This may
+ be used as a variable in the construction of content models. gml:AbstractFeature may be
+ thought of as "anything that is a GML feature" and may be used to define variables or
+ templates in which the value of a GML property is "any feature". This occurs in particular
+ in a GML feature collection where the feature member properties contain one or multiple
+ copies of gml:AbstractFeature respectively.
+
+
+
+
+
+
+
+
+
+
+
+ This property describes the minimum bounding box or rectangle that encloses the
+ entire feature.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:EnvelopeWithTimePeriod is provided for envelopes that include a temporal
+ extent. It adds two time position properties, gml:beginPosition and gml:endPosition, which
+ describe the extent of a time-envelope. Since gml:EnvelopeWithTimePeriod is assigned to the
+ substitution group headed by gml:Envelope, it may be used whenever gml:Envelope is
+ valid.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The gml:locationName property element is a convenience property where the text
+ value describes the location of the feature. If the location names are selected from a
+ controlled list, then the list shall be identified in the codeSpace
+ attribute.
+
+
+
+
+ The gml:locationReference property element is a convenience property where the
+ text value referenced by the xlink:href attribute describes the location of the
+ feature.
+
+
+
+
+ To create a collection of GML features, a property type shall be derived by
+ extension from gml:AbstractFeatureMemberType. By default, this abstract property type does
+ not imply any ownership of the features in the collection. The owns attribute of
+ gml:OwnershipAttributeGroup may be used on a property element instance to assert ownership
+ of a feature in the collection. A collection shall not own a feature already owned by
+ another object.
+
+
+
+
+
+
+ The property gml:direction is intended as a pre-defined property expressing a
+ direction to be assigned to features defined in a GML application schema.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Direction vectors are specified by providing components of a
+ vector.
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ direction descriptions are specified by a compass point code, a keyword, a
+ textual description or a reference to a description. A gml:compassPoint is specified by a
+ simple enumeration. In addition, thre elements to contain text-based descriptions of
+ direction are provided. If the direction is specified using a term from a list, gml:keyword
+ should be used, and the list indicated using the value of the codeSpace attribute. if the
+ direction is decribed in prose, gml:direction or gml:reference should be used, allowing the
+ value to be included inline or by reference.
+
+
+
+
+
+
+
+
+
+
+ These directions are necessarily approximate, giving direction with a precision
+ of 22.5°. It is thus generally unnecessary to specify the reference frame, though this may
+ be detailed in the definition of a GML application language.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The element gml:unitOfMeasure is a property element to refer to a unit of
+ measure. This is an empty element which carries a reference to a unit of measure
+ definition.
+
+
+
+
+
+
+
+
+ A gml:UnitDefinition is a general definition of a unit of measure. This generic
+ element is used only for units for which no relationship with other units or units systems
+ is known. The content model of gml:UnitDefinition adds three additional properties to
+ gml:Definition, gml:quantityType, gml:quantityTypeReference and gml:catalogSymbol. The
+ gml:catalogSymbol property optionally gives the short symbol used for this unit. This
+ element is usually used when the relationship of this unit to other units or units systems
+ is unknown.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The gml:quantityType property indicates the phenomenon to which the units
+ apply. This element contains an informal description of the phenomenon or type of physical
+ quantity that is measured or observed. When the physical quantity is the result of an
+ observation or measurement, this term is known as observable type or measurand. The use of
+ gml:quantityType for references to remote values is deprecated.
+
+
+
+
+ The gml:quantityTypeReference property indicates the phenomenon to which the
+ units apply. The content is a reference to a remote value.
+
+
+
+
+ The catalogSymbol is the preferred lexical symbol used for this unit of
+ measure. The codeSpace attribute in gml:CodeType identifies a namespace for the catalog
+ symbol value, and might reference the external catalog. The string value in gml:CodeType
+ contains the value of a symbol that should be unique within this catalog namespace. This
+ symbol often appears explicitly in the catalog, but it could be a combination of symbols
+ using a specified algebra of units.
+
+
+
+
+ A base unit is a unit of measure that cannot be derived by combination of other
+ base units within a particular system of units. For example, in the SI system of units, the
+ base units are metre, kilogram, second, Ampere, Kelvin, mole, and candela, for the physical
+ quantity types length, mass, time interval, electric current, thermodynamic temperature,
+ amount of substance and luminous intensity, respectively. gml:BaseUnit extends generic
+ gml:UnitDefinition with the property gml:unitsSystem, which carries a reference to the units
+ system to which this base unit is asserted to belong.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Derived units are defined by combination of other units. Derived units are used
+ for quantities other than those corresponding to the base units, such as hertz (s-1) for
+ frequency, Newton (kg.m/s2) for force. Derived units based directly on base units are
+ usually preferred for quantities other than the fundamental quantities within a system. If a
+ derived unit is not the preferred unit, the gml:ConventionalUnit element should be used
+ instead. The gml:DerivedUnit extends gml:UnitDefinition with the property
+ gml:derivationUnitTerms.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A set of gml:derivationUnitTerm elements describes a derived unit of measure.
+ Each element carries an integer exponent. The terms are combined by raising each referenced
+ unit to the power of its exponent and forming the product. This unit term references another
+ unit of measure (uom) and provides an integer exponent applied to that unit in defining the
+ compound unit. The exponent may be positive or negative, but not zero.
+
+
+
+
+
+
+
+
+
+
+
+ Conventional units that are neither base units nor defined by direct
+ combination of base units are used in many application domains. For example electronVolt for
+ energy, feet and nautical miles for length. In most cases there is a known, usually linear,
+ conversion to a preferred unit which is either a base unit or derived by direct combination
+ of base units. The gml:ConventionalUnit extends gml:UnitDefinition with a property that
+ describes a conversion to a preferred unit for this physical quantity. When the conversion
+ is exact, the element gml:conversionToPreferredUnit should be used, or when the conversion
+ is not exact the element gml:roughConversionToPreferredUnit is available. Both of these
+ elements have the same content model. The gml:derivationUnitTerm property defined above is
+ included to allow a user to optionally record how this unit may be derived from other ("more
+ primitive") units.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The elements gml:conversionToPreferredUnit and
+ gml:roughConversionToPreferredUnit represent parameters used to convert conventional units
+ to preferred units for this physical quantity type. A preferred unit is either a Base Unit
+ or a Derived Unit that is selected for all values of one physical quantity
+ type.
+
+
+
+
+ The elements gml:conversionToPreferredUnit and
+ gml:roughConversionToPreferredUnit represent parameters used to convert conventional units
+ to preferred units for this physical quantity type. A preferred unit is either a Base Unit
+ or a Derived Unit that is selected for all values of one physical quantity
+ type.
+
+
+
+
+ The inherited attribute uom references the preferred unit that this conversion
+ applies to. The conversion of a unit to the preferred unit for this physical quantity type
+ is specified by an arithmetic conversion (scaling and/or offset). The content model extends
+ gml:UnitOfMeasureType, which has a mandatory attribute uom which identifies the preferred
+ unit for the physical quantity type that this conversion applies to. The conversion is
+ specified by a choice of - gml:factor, which defines the scale factor, or - gml:formula,
+ which defines a formula by which a value using the conventional unit of measure can be
+ converted to obtain the corresponding value using the preferred unit of measure. The formula
+ defines the parameters of a simple formula by which a value using the conventional unit of
+ measure can be converted to the corresponding value using the preferred unit of measure. The
+ formula element contains elements a, b, c and d, whose values use the XML Schema type
+ double. These values are used in the formula y = (a + bx) / (c + dx), where x is a value
+ using this unit, and y is the corresponding value using the base unit. The elements a and d
+ are optional, and if values are not provided, those parameters are considered to be zero. If
+ values are not provided for both a and d, the formula is equivalent to a fraction with
+ numerator and denominator parameters.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The value of a physical quantity, together with its unit.
+
+
+
+
+ This is a prototypical definition for a specific measure type defined as a
+ vacuous extension (i.e. aliases) of gml:MeasureType. In this case, the content model
+ supports the description of a length (or distance) quantity, with its units. The unit of
+ measure referenced by uom shall be suitable for a length, such as metres or
+ feet.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The gml:angle property element is used to record the value of an angle quantity
+ as a single number, with its units.
+
+
+
+
+ All geometry elements are derived directly or indirectly from this abstract
+ supertype. A geometry element may have an identifying attribute (gml:id), one or more names
+ (elements identifier and name) and a description (elements description and
+ descriptionReference) . It may be associated with a spatial reference system (attribute
+ group gml:SRSReferenceGroup). The following rules shall be adhered to: - Every geometry type
+ shall derive from this abstract type. - Every geometry element (i.e. an element of a
+ geometry type) shall be directly or indirectly in the substitution group of
+ AbstractGeometry.
+
+
+
+
+
+
+
+
+
+ The attribute group SRSReferenceGroup is an optional reference to the CRS used
+ by this geometry, with optional additional information to simplify the processing of the
+ coordinates when a more complete definition of the CRS is not needed. In general the
+ attribute srsName points to a CRS instance of gml:AbstractCoordinateReferenceSystem. For
+ well-known references it is not required that the CRS description exists at the location the
+ URI points to. If no srsName attribute is given, the CRS shall be specified as part of the
+ larger context this geometry element is part of.
+
+
+
+
+
+
+
+ The attributes uomLabels and axisLabels, defined in the SRSInformationGroup
+ attribute group, are optional additional and redundant information for a CRS to simplify the
+ processing of the coordinate values when a more complete definition of the CRS is not
+ needed. This information shall be the same as included in the complete definition of the
+ CRS, referenced by the srsName attribute. When the srsName attribute is included, either
+ both or neither of the axisLabels and uomLabels attributes shall be included. When the
+ srsName attribute is omitted, both of these attributes shall be omitted. The attribute
+ axisLabels is an ordered list of labels for all the axes of this CRS. The gml:axisAbbrev
+ value should be used for these axis labels, after spaces and forbidden characters are
+ removed. When the srsName attribute is included, this attribute is optional. When the
+ srsName attribute is omitted, this attribute shall also be omitted. The attribute uomLabels
+ is an ordered list of unit of measure (uom) labels for all the axes of this CRS. The value
+ of the string in the gml:catalogSymbol should be used for this uom labels, after spaces and
+ forbidden characters are removed. When the axisLabels attribute is included, this attribute
+ shall also be included. When the axisLabels attribute is omitted, this attribute shall also
+ be omitted.
+
+
+
+
+
+
+ The AbstractGeometry element is the abstract head of the substitution group for
+ all geometry elements of GML. This includes pre-defined and user-defined geometry elements.
+ Any geometry element shall be a direct or indirect extension/restriction of
+ AbstractGeometryType and shall be directly or indirectly in the substitution group of
+ AbstractGeometry.
+
+
+
+
+ A geometric property may either be any geometry element encapsulated in an
+ element of this type or an XLink reference to a remote geometry element (where remote
+ includes geometry elements located elsewhere in the same or another document). Note that
+ either the reference or the contained element shall be given, but not both or none. If a
+ feature has a property that takes a geometry element as its value, this is called a geometry
+ property. A generic type for such a geometry property is
+ GeometryPropertyType.
+
+
+
+
+
+
+
+
+
+ If a feature has a property which takes an array of geometry elements as its
+ value, this is called a geometry array property. A generic type for such a geometry property
+ is GeometryArrayPropertyType. The elements are always contained inline in the array
+ property, referencing geometry elements or arrays of geometry elements via XLinks is not
+ supported.
+
+
+
+
+
+
+
+
+ Direct position instances hold the coordinates for a position within some
+ coordinate reference system (CRS). Since direct positions, as data types, will often be
+ included in larger objects (such as geometry elements) that have references to CRS, the
+ srsName attribute will in general be missing, if this particular direct position is included
+ in a larger element with such a reference to a CRS. In this case, the CRS is implicitly
+ assumed to take on the value of the containing object's CRS. if no srsName attribute is
+ given, the CRS shall be specified as part of the larger context this geometry element is
+ part of, typically a geometric object like a point, curve, etc.
+
+
+
+
+
+
+
+
+
+
+ posList instances (and other instances with the content model specified by
+ DirectPositionListType) hold the coordinates for a sequence of direct positions within the
+ same coordinate reference system (CRS). if no srsName attribute is given, the CRS shall be
+ specified as part of the larger context this geometry element is part of, typically a
+ geometric object like a point, curve, etc. The optional attribute count specifies the number
+ of direct positions in the list. If the attribute count is present then the attribute
+ srsDimension shall be present, too. The number of entries in the list is equal to the
+ product of the dimensionality of the coordinate reference system (i.e. it is a derived value
+ of the coordinate reference system definition) and the number of direct
+ positions.
+
+
+
+
+
+
+
+
+
+
+
+ GML supports two different ways to specify a geometric position: either by a
+ direct position (a data type) or a point (a geometric object). pos elements are positions
+ that are "owned" by the geometric primitive encapsulating this geometric position.
+ pointProperty elements contain a point that may be referenced from other geometry elements
+ or reference another point defined elsewhere (reuse of existing points).
+
+
+
+
+
+
+
+
+ GML supports two different ways to specify a list of geometric positions:
+ either by a sequence of geometric positions (by reusing the group definition) or a sequence
+ of direct positions (element posList). The posList element allows for a compact way to
+ specify the coordinates of the positions, if all positions are represented in the same
+ coordinate reference system.
+
+
+
+
+
+
+
+
+ For some applications the components of the position may be adjusted to yield a
+ unit vector.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ Envelope defines an extent using a pair of positions defining opposite corners
+ in arbitrary dimensions. The first direct position is the "lower corner" (a coordinate
+ position consisting of all the minimal ordinates for each dimension for all points within
+ the envelope), the second one the "upper corner" (a coordinate position consisting of all
+ the maximal ordinates for each dimension for all points within the envelope). The use of the
+ properties "coordinates" and "pos" has been deprecated. The explicitly named properties
+ "lowerCorner" and "upperCorner" shall be used instead.
+
+
+
+
+ gml:AbstractGeometricPrimitiveType is the abstract root type of the geometric
+ primitives. A geometric primitive is a geometric object that is not decomposed further into
+ other primitives in the system. All primitives are oriented in the direction implied by the
+ sequence of their coordinate tuples.
+
+
+
+
+
+
+
+ The AbstractGeometricPrimitive element is the abstract head of the substitution
+ group for all (pre- and user-defined) geometric primitives.
+
+
+
+
+ A property that has a geometric primitive as its value domain may either be an
+ appropriate geometry element encapsulated in an element of this type or an XLink reference
+ to a remote geometry element (where remote includes geometry elements located elsewhere in
+ the same document). Either the reference or the contained element shall be given, but
+ neither both nor none.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Point is defined by a single coordinate tuple. The direct position of a point
+ is specified by the pos element which is of type DirectPositionType.
+
+
+
+
+ A property that has a point as its value domain may either be an appropriate
+ geometry element encapsulated in an element of this type or an XLink reference to a remote
+ geometry element (where remote includes geometry elements located elsewhere in the same
+ document). Either the reference or the contained element shall be given, but neither both
+ nor none.
+
+
+
+
+
+
+
+
+
+ This property element either references a point via the XLink-attributes or
+ contains the point element. pointProperty is the predefined property which may be used by
+ GML Application Schemas whenever a GML feature has a property with a value that is
+ substitutable for Point.
+
+
+
+
+ gml:PointArrayPropertyType is a container for an array of points. The elements
+ are always contained inline in the array property, referencing geometry elements or arrays
+ of geometry elements via XLinks is not supported.
+
+
+
+
+
+
+
+
+ gml:AbstractCurveType is an abstraction of a curve to support the different
+ levels of complexity. The curve may always be viewed as a geometric primitive, i.e. is
+ continuous.
+
+
+
+
+
+
+
+ The AbstractCurve element is the abstract head of the substitution group for
+ all (continuous) curve elements.
+
+
+
+
+ A property that has a curve as its value domain may either be an appropriate
+ geometry element encapsulated in an element of this type or an XLink reference to a remote
+ geometry element (where remote includes geometry elements located elsewhere in the same
+ document). Either the reference or the contained element shall be given, but neither both
+ nor none.
+
+
+
+
+
+
+
+
+
+ This property element either references a curve via the XLink-attributes or
+ contains the curve element. curveProperty is the predefined property which may be used by
+ GML Application Schemas whenever a GML feature has a property with a value that is
+ substitutable for AbstractCurve.
+
+
+
+
+ A container for an array of curves. The elements are always contained in the
+ array property, referencing geometry elements or arrays of geometry elements via XLinks is
+ not supported.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A LineString is a special curve that consists of a single segment with linear
+ interpolation. It is defined by two or more coordinate tuples, with linear interpolation
+ between them. The number of direct positions in the list shall be at least
+ two.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:Category has an optional XML attribute codeSpace, whose value is a URI
+ which identifies a dictionary, codelist or authority for the term.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ An XML attribute uom ("unit of measure") is required, whose value is a URI
+ which identifies the definition of a ratio scale or units by which the numeric value shall
+ be multiplied, or an interval or position scale on which the value occurs.
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:AbstractValue is an abstract element which acts as the head of a
+ substitution group which contains gml:AbstractScalarValue, gml:AbstractScalarValueList,
+ gml:CompositeValue and gml:ValueExtent, and (transitively) the elements in their
+ substitution groups. These elements may be used in an application schema as variables, so
+ that in an XML instance document any member of its substitution group may
+ occur.
+
+
+
+
+ gml:AbstractScalarValue is an abstract element which acts as the head of a
+ substitution group which contains gml:Boolean, gml:Category, gml:Count and gml:Quantity, and
+ (transitively) the elements in their substitution groups.
+
+
+
+
+ gml:AbstractScalarValueList is an abstract element which acts as the head of a
+ substitution group which contains gml:BooleanList, gml:CategoryList, gml:CountList and
+ gml:QuantityList, and (transitively) the elements in their substitution
+ groups.
+
+
+
+
+ This is a convenience choice group which unifies generic values defined in this
+ Clause with spatial and temporal objects and the measures described above, so that any of
+ these may be used within aggregate values.
+
+
+
+
+
+
+
+
+
+
+ Property that refers to, or contains, a Value. Convenience element for general
+ use.
+
+
+
+
+ Property that refers to, or contains, a Value.
+
+
+
+
+
+
+
+
+
+
+
+ Property that contains Values.
+
+
+
+
+
+
+
+
+
+
+ gml:CompositeValue is an aggregate value built from other values . It contains
+ zero or an arbitrary number of gml:valueComponent elements, and zero or one
+ gml:valueComponents property elements. It may be used for strongly coupled aggregates
+ (vectors, tensors) or for arbitrary collections of values.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Value Array is used for homogeneous arrays of primitive and aggregate values.
+ The member values may be scalars, composites, arrays or lists. ValueArray has the same
+ content model as CompositeValue, but the member values shall be homogeneous. The element
+ declaration contains a Schematron constraint which expresses this restriction precisely.
+ Since the members are homogeneous, the gml:referenceSystem (uom, codeSpace) may be specified
+ on the gml:ValueArray itself and inherited by all the members if desired.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The content model is a straightforward extension of gml:AbstractFeatureType; it
+ automatically has the gml:identifier, gml:description, gml:descriptionReference, gml:name,
+ and gml:boundedBy properties. The gml:validTime element describes the time of the
+ observation. Note that this may be a time instant or a time period. The gml:using property
+ contains or references a description of a sensor, instrument or procedure used for the
+ observation. The gml:target property contains or references the specimen, region or station
+ which is the object of the observation. This property is particularly useful for remote
+ observations, such as photographs, where a generic location property might apply to the
+ location of the camera or the location of the field of view, and thus may be ambiguous. The
+ gml:subject element is provided as a convenient synonym for gml:target. This is the term
+ commonly used in phtotography. The gml:resultOf property indicates the result of the
+ observation. The value may be inline, or a reference to a value elsewhere.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A gml:DirectedObservation is the same as an observation except that it adds an
+ additional gml:direction property. This is the direction in which the observation was
+ acquired. Clearly this applies only to certain types of observations such as visual
+ observations by people, or observations obtained from terrestrial cameras.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:DirectedObservationAtDistance adds an additional distance property. This is
+ the distance from the observer to the subject of the observation. Clearly this applies only
+ to certain types of observations such as visual observations by people, or observations
+ obtained from terrestrial cameras.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The basic gml:Definition element specifies a definition, which can be included
+ in or referenced by a dictionary. The content model for a generic definition is a derivation
+ from gml:AbstractGMLType. The gml:description property element shall hold the definition if
+ this can be captured in a simple text string, or the gml:descriptionReference property
+ element may carry a link to a description elsewhere. The gml:identifier element shall
+ provide one identifier identifying this definition. The identifier shall be unique within
+ the dictionaries using this definition. The gml:name elements shall provide zero or more
+ terms and synonyms for which this is the definition. The gml:remarks element shall be used
+ to hold additional textual information that is not conceptually part of the definition but
+ is useful in understanding the definition.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sets of definitions may be collected into dictionaries or collections. A
+ gml:Dictionary is a non-abstract collection of definitions. The gml:Dictionary content model
+ adds a list of gml:dictionaryEntry properties that contain or reference gml:Definition
+ objects. A database handle (gml:id attribute) is required, in order that this collection may
+ be referred to. The standard gml:identifier, gml:description, gml:descriptionReference and
+ gml:name properties are available to reference or contain more information about this
+ dictionary. The gml:description and gml:descriptionReference property elements may be used
+ for a description of this dictionary. The derived gml:name element may be used for the
+ name(s) of this dictionary. for remote definiton references gml:dictionaryEntry shall be
+ used. If a Definition object contained within a Dictionary uses the descriptionReference
+ property to refer to a remote definition, then this enables the inclusion of a remote
+ definition in a local dictionary, giving a handle and identifier in the context of the local
+ dictionary.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This property element contains or refers to the definitions which are members
+ of a dictionary. The content model follows the standard GML property pattern, so a
+ gml:dictionaryEntry may either contain or refer to a single gml:Definition. Since
+ gml:Dictionary is substitutable for gml:Definition, the content of an entry may itself be a
+ lower level dictionary. Note that if the value is provided by reference, this definition
+ does not carry a handle (gml:id) in this context, so does not allow external references to
+ this specific definition in this context. When used in this way the referenced definition
+ will usually be in a dictionary in the same XML document.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:NilReasonType defines a content model that allows recording of an
+ explanation for a void value or other exception. gml:NilReasonType is a union of the
+ following enumerated values: - inapplicable there is no value - missing the correct value is
+ not readily available to the sender of this data. Furthermore, a correct value may not exist
+ - template the value will be available later - unknown the correct value is not known to,
+ and not computable by, the sender of this data. However, a correct value probably exists -
+ withheld the value is not divulged - other:text other brief explanation, where text is a
+ string of two or more characters with no included spaces and - anyURI which should refer to
+ a resource which describes the reason for the exception A particular community may choose to
+ assign more detailed semantics to the standard values provided. Alternatively, the URI
+ method enables a specific or more complete explanation for the absence of a value to be
+ provided elsewhere and indicated by-reference in an instance document. gml:NilReasonType is
+ used as a member of a union in a number of simple content types where it is necessary to
+ permit a value from the NilReasonType union as an alternative to the primary
+ type.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:SignType is a convenience type with values "+" (plus) and "-"
+ (minus).
+
+
+
+
+
+
+
+
+ Extension to the respective XML Schema built-in simple type to allow a choice
+ of either a value of the built-in simple type or a reason for a nil value.
+
+
+
+
+
+ Extension to the respective XML Schema built-in simple type to allow a choice
+ of either a value of the built-in simple type or a reason for a nil value.
+
+
+
+
+
+ Extension to the respective XML Schema built-in simple type to allow a choice
+ of either a value of the built-in simple type or a reason for a nil value.
+
+
+
+
+
+ Extension to the respective XML Schema built-in simple type to allow a choice
+ of either a value of the built-in simple type or a reason for a nil value.
+
+
+
+
+
+ Extension to the respective XML Schema built-in simple type to allow a choice
+ of either a value of the built-in simple type or a reason for a nil value.
+
+
+
+
+
+ gml:CodeType is a generalized type to be used for a term, keyword or name. It
+ adds a XML attribute codeSpace to a term, where the value of the codeSpace attribute (if
+ present) shall indicate a dictionary, thesaurus, classification scheme, authority, or
+ pattern for the term.
+
+
+
+
+
+
+
+
+
+ gml:CodeWithAuthorityType requires that the codeSpace attribute is provided in
+ an instance.
+
+
+
+
+
+
+
+
+
+ gml:MeasureType supports recording an amount encoded as a value of XML Schema
+ double, together with a units of measure indicated by an attribute uom, short for "units Of
+ measure". The value of the uom attribute identifies a reference system for the amount,
+ usually a ratio or interval scale.
+
+
+
+
+
+
+
+
+
+ The simple type gml:UomIdentifer defines the syntax and value space of the unit
+ of measure identifier.
+
+
+
+
+
+ This type specifies a character string of length at least one, and restricted
+ such that it must not contain any of the following characters: ":" (colon), " " (space),
+ (newline), (carriage return), (tab). This allows values corresponding to familiar
+ abbreviations, such as "kg", "m/s", etc. It is recommended that the symbol be an identifier
+ for a unit of measure as specified in the "Unified Code of Units of Measure" (UCUM)
+ (http://aurora.regenstrief.org/UCUM). This provides a set of symbols and a grammar for
+ constructing identifiers for units of measure that are unique, and may be easily entered
+ with a keyboard supporting the limited character set known as 7-bit ASCII. ISO 2955 formerly
+ provided a specification with this scope, but was withdrawn in 2001. UCUM largely follows
+ ISO 2955 with modifications to remove ambiguities and other problems.
+
+
+
+
+
+
+
+ This type specifies a URI, restricted such that it must start with one of the
+ following sequences: "#", "./", "../", or a string of characters followed by a ":". These
+ patterns ensure that the most common URI forms are supported, including absolute and
+ relative URIs and URIs that are simple fragment identifiers, but prohibits certain forms of
+ relative URI that could be mistaken for unit of measure symbol . NOTE It is possible to
+ re-write such a relative URI to conform to the restriction (e.g. "./m/s"). In an instance
+ document, on elements of type gml:MeasureType the mandatory uom attribute shall carry a
+ value corresponding to either - a conventional unit of measure symbol, - a link to a
+ definition of a unit of measure that does not have a conventional symbol, or when it is
+ desired to indicate a precise or variant definition.
+
+
+
+
+
+
+
+ This type is deprecated for tuples with ordinate values that are numbers.
+ CoordinatesType is a text string, intended to be used to record an array of tuples or
+ coordinates. While it is not possible to enforce the internal structure of the string
+ through schema validation, some optional attributes have been provided in previous versions
+ of GML to support a description of the internal structure. These attributes are deprecated.
+ The attributes were intended to be used as follows: Decimal symbol used for a decimal point
+ (default="." a stop or period) cs symbol used to separate components within a tuple or
+ coordinate string (default="," a comma) ts symbol used to separate tuples or coordinate
+ strings (default=" " a space) Since it is based on the XML Schema string type,
+ CoordinatesType may be used in the construction of tables of tuples or arrays of tuples,
+ including ones that contain mixed text and numeric values.
+
+
+
+
+
+
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ A type for a list of values of the respective simple type.
+
+
+
+
+
+ gml:CodeListType provides for lists of terms. The values in an instance element
+ shall all be valid according to the rules of the dictionary, classification scheme, or
+ authority identified by the value of its codeSpace attribute.
+
+
+
+
+
+
+
+
+
+ gml:CodeOrNilReasonListType provides for lists of terms. The values in an
+ instance element shall all be valid according to the rules of the dictionary, classification
+ scheme, or authority identified by the value of its codeSpace attribute. An instance element
+ may also include embedded values from NilReasonType. It is intended to be used in situations
+ where a term or classification is expected, but the value may be absent for some
+ reason.
+
+
+
+
+
+
+
+
+
+ gml:MeasureListType provides for a list of quantities.
+
+
+
+
+
+
+
+
+
+ gml:MeasureOrNilReasonListType provides for a list of quantities. An instance
+ element may also include embedded values from NilReasonType. It is intended to be used in
+ situations where a value is expected, but the value may be absent for some
+ reason.
+
+
+
+
+
+
+
+
+
+ This element has no type defined, and is therefore implicitly (according to the
+ rules of W3C XML Schema) an XML Schema anyType. It is used as the head of an XML Schema
+ substitution group which unifies complex content and certain simple content elements used
+ for datatypes in GML, including the gml:AbstractGML substitution group.
+
+
+
+
+ The abstract element gml:AbstractGML is "any GML object having identity". It
+ acts as the head of an XML Schema substitution group, which may include any element which is
+ a GML feature, or other object, with identity. This is used as a variable in content models
+ in GML core and application schemas. It is effectively an abstract superclass for all GML
+ objects.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ XLink components are the standard method to support hypertext referencing in
+ XML. An XML Schema attribute group, gml:AssociationAttributeGroup, is provided to support
+ the use of Xlinks as the method for indicating the value of a property by reference in a
+ uniform manner in GML.
+
+
+
+
+
+ deprecated
+
+
+
+
+
+ Applying this pattern shall restrict the multiplicity of objects in a property
+ element using this content model to exactly one. An instance of this type shall contain an
+ element representing an object, or serve as a pointer to a remote object. Applying the
+ pattern to define an application schema specific property type allows to restrict - the
+ inline object to specified object types, - the encoding to "by-reference only" (see
+ 7.2.3.7), - the encoding to "inline only" (see 7.2.3.8).
+
+
+
+
+
+
+
+
+
+
+
+ Encoding a GML property inline vs. by-reference shall not imply anything about
+ the "ownership" of the contained or referenced GML Object, i.e. the encoding style shall not
+ imply any "deep-copy" or "deep-delete" semantics. To express ownership over the contained or
+ referenced GML Object, the gml:OwnershipAttributeGroup attribute group may be added to
+ object-valued property elements. If the attribute group is not part of the content model of
+ such a property element, then the value may not be "owned". When the value of the owns
+ attribute is "true", the existence of inline or referenced object(s) depends upon the
+ existence of the parent object.
+
+
+
+
+
+ This element shows how an element declaration may include a Schematron
+ constraint to limit the property to act in either inline or by-reference mode, but not
+ both.
+
+
+
+
+ gml:abstractReference may be used as the head of a subtitution group of more
+ specific elements providing a value by-reference.
+
+
+
+
+ gml:ReferenceType is intended to be used in application schemas directly, if a
+ property element shall use a "by-reference only" encoding.
+
+
+
+
+
+
+
+ gml:abstractInlineProperty may be used as the head of a subtitution group of
+ more specific elements providing a value inline.
+
+
+
+
+
+
+
+
+
+
+ If the value of an object property is another object and that object contains
+ also a property for the association between the two objects, then this name of the reverse
+ property may be encoded in a gml:reversePropertyName element in an appinfo annotation of the
+ property element to document the constraint between the two properties. The value of the
+ element shall contain the qualified name of the property element.
+
+
+
+
+ The value of this property is a text description of the object. gml:description
+ uses gml:StringOrRefType as its content model, so it may contain a simple text string
+ content, or carry a reference to an external description. The use of gml:description to
+ reference an external description has been deprecated and replaced by the
+ gml:descriptionReference property.
+
+
+
+
+ The value of this property is a remote text description of the object. The
+ xlink:href attribute of the gml:descriptionReference property references the external
+ description.
+
+
+
+
+ The gml:name property provides a label or identifier for the object, commonly a
+ descriptive name. An object may have several names, typically assigned by different
+ authorities. gml:name uses the gml:CodeType content model. The authority for a name is
+ indicated by the value of its (optional) codeSpace attribute. The name may or may not be
+ unique, as determined by the rules of the organization responsible for the codeSpace. In
+ common usage there will be one name per authority, so a processing application may select
+ the name from its preferred codeSpace.
+
+
+
+
+ Often, a special identifier is assigned to an object by the maintaining
+ authority with the intention that it is used in references to the object For such cases, the
+ codeSpace shall be provided. That identifier is usually unique either globally or within an
+ application domain. gml:identifier is a pre-defined property for such
+ identifiers.
+
+
+
+
+ The attribute gml:id supports provision of a handle for the XML element
+ representing a GML Object. Its use is mandatory for all GML objects. It is of XML type ID,
+ so is constrained to be unique in the XML document within which it occurs.
+
+
+
+
+ To create a collection of GML Objects that are not all features, a property
+ type shall be derived by extension from gml:AbstractMemberType. This abstract property type
+ is intended to be used only in object types where software shall be able to identify that an
+ instance of such an object type is to be interpreted as a collection of objects. By default,
+ this abstract property type does not imply any ownership of the objects in the collection.
+ The owns attribute of gml:OwnershipAttributeGroup may be used on a property element instance
+ to assert ownership of an object in the collection. A collection shall not own an object
+ already owned by another object.
+
+
+
+
+
+
+ A GML Object Collection is any GML Object with a property element in its
+ content model whose content model is derived by extension from gml:AbstractMemberType. In
+ addition, the complex type describing the content model of the GML Object Collection may
+ also include a reference to the attribute group gml:AggregationAttributeGroup to provide
+ additional information about the semantics of the object collection. This information may be
+ used by applications to group GML objects, and optionally to order and index them. The
+ allowed values for the aggregationType attribute are defined by gml:AggregationType. See 8.4
+ of ISO/IEC 11404:1996 for the meaning of the values in the enumeration.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ To associate metadata described by any XML Schema with a GML object, a property
+ element shall be defined whose content model is derived by extension from
+ gml:AbstractMetadataPropertyType. The value of such a property shall be metadata. The
+ content model of such a property type, i.e. the metadata application schema shall be
+ specified by the GML Application Schema. By default, this abstract property type does not
+ imply any ownership of the metadata. The owns attribute of gml:OwnershipAttributeGroup may
+ be used on a metadata property element instance to assert ownership of the metadata. If
+ metadata following the conceptual model of ISO 19115 is to be encoded in a GML document, the
+ corresponding Implementation Specification specified in ISO/TS 19139 shall be used to encode
+ the metadata information.
+
+
+
+
+
+
+
+
+
+
+ gml:AbstractTimeObject acts as the head of a substitution group for all
+ temporal primitives and complexes.
+
+
+
+
+
+
+
+
+
+ gml:AbstractTimePrimitive acts as the head of a substitution group for
+ geometric and topological temporal primitives.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimePrimitivePropertyType provides a standard content model for
+ associations between an arbitrary member of the substitution group whose head is
+ gml:AbstractTimePrimitive and another object.
+
+
+
+
+
+
+
+
+
+ gml:validTime is a convenience property element.
+
+
+
+
+ gml:RelatedTimeType provides a content model for indicating the relative
+ position of an arbitrary member of the substitution group whose head is
+ gml:AbstractTimePrimitive. It extends the generic gml:TimePrimitivePropertyType with an XML
+ attribute relativePosition, whose value is selected from the set of 13 temporal
+ relationships identified by Allen (1983)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:AbstractTimeComplex is an aggregation of temporal primitives and acts as
+ the head of a substitution group for temporal complexes.
+
+
+
+
+
+
+
+
+
+ gml:TimeGeometricPrimitive acts as the head of a substitution group for
+ geometric temporal primitives. A temporal geometry shall be associated with a temporal
+ reference system through the frame attribute that provides a URI reference that identifies a
+ description of the reference system. Following ISO 19108, the Gregorian calendar with UTC is
+ the default reference system, but others may also be used. The GPS calendar is an
+ alternative reference systems in common use. The two geometric primitives in the temporal
+ dimension are the instant and the period. GML components are defined to support these as
+ follows.
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeInstant acts as a zero-dimensional geometric primitive that represents
+ an identifiable position in time.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeInstantPropertyType provides for associating a gml:TimeInstant with an
+ object.
+
+
+
+
+
+
+
+
+
+ gml:TimePeriod acts as a one-dimensional geometric primitive that represents an
+ identifiable extent in time. The location in of a gml:TimePeriod is described by the
+ temporal positions of the instants at which it begins and ends. The length of the period is
+ equal to the temporal distance between the two bounding temporal positions. Both beginning
+ and end may be described in terms of their direct position using gml:TimePositionType which
+ is an XML Schema simple content type, or by reference to an indentifiable time instant using
+ gml:TimeInstantPropertyType. Alternatively a limit of a gml:TimePeriod may use the
+ conventional GML property model to make a reference to a time instant described elsewhere,
+ or a limit may be indicated as a direct position.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimePeriodPropertyType provides for associating a gml:TimePeriod with an
+ object.
+
+
+
+
+
+
+
+
+
+ The method for identifying a temporal position is specific to each temporal
+ reference system. gml:TimePositionType supports the description of temporal position
+ according to the subtypes described in ISO 19108. Values based on calendars and clocks use
+ lexical formats that are based on ISO 8601, as described in XML Schema Part 2:2001. A
+ decimal value may be used with coordinate systems such as GPS time or UNIX time. A URI may
+ be used to provide a reference to some era in an ordinal reference system . In common with
+ many of the components modelled as data types in the ISO 19100 series of International
+ Standards, the corresponding GML component has simple content. However, the content model
+ gml:TimePositionType is defined in several steps. Three XML attributes appear on
+ gml:TimePositionType: A time value shall be associated with a temporal reference system
+ through the frame attribute that provides a URI reference that identifies a description of
+ the reference system. Following ISO 19108, the Gregorian calendar with UTC is the default
+ reference system, but others may also be used. Components for describing temporal reference
+ systems are described in 14.4, but it is not required that the reference system be described
+ in this, as the reference may refer to anything that may be indentified with a URI. For time
+ values using a calendar containing more than one era, the (optional) calendarEraName
+ attribute provides the name of the calendar era. Inexact temporal positions may be expressed
+ using the optional indeterminatePosition attribute. This takes a value from an
+ enumeration.
+
+
+
+
+
+
+
+
+
+
+
+ These values are interpreted as follows: - "unknown" indicates that no specific
+ value for temporal position is provided. - "now" indicates that the specified value shall be
+ replaced with the current temporal position whenever the value is accessed. - "before"
+ indicates that the actual temporal position is unknown, but it is known to be before the
+ specified value. - "after" indicates that the actual temporal position is unknown, but it is
+ known to be after the specified value. A value for indeterminatePosition may - be used
+ either alone, or - qualify a specific value for temporal position.
+
+
+
+
+
+
+
+
+
+
+ The simple type gml:TimePositionUnion is a union of XML Schema simple types
+ which instantiate the subtypes for temporal position described in ISO 19108. An ordinal era
+ may be referenced via URI. A decimal value may be used to indicate the distance from the
+ scale origin . time is used for a position that recurs daily (see ISO 19108:2002 5.4.4.2).
+ Finally, calendar and clock forms that support the representation of time in systems based
+ on years, months, days, hours, minutes and seconds, in a notation following ISO 8601, are
+ assembled by gml:CalDate
+
+
+
+
+
+
+
+
+ This element is used directly as a property of gml:TimeInstant (see 15.2.2.3),
+ and may also be used in application schemas.
+
+
+
+
+ The length of a time period.
+
+
+
+
+
+
+
+
+ gml:duration conforms to the ISO 8601 syntax for temporal length as implemented
+ by the XML Schema duration type.
+
+
+
+
+ gml:timeInterval conforms to ISO 11404 which is based on floating point values
+ for temporal length. ISO 11404 syntax specifies the use of a positiveInteger together with
+ appropriate values for radix and factor. The resolution of the time interval is to one radix
+ ^(-factor) of the specified time unit. The value of the unit is either selected from the
+ units for time intervals from ISO 31-1:1992, or is another suitable unit. The encoding is
+ defined for GML in gml:TimeUnitType. The second component of this union type provides a
+ method for indicating time units other than the six standard units given in the
+ enumeration.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeTopologyPrimitive acts as the head of a substitution group for
+ topological temporal primitives. Temporal topology primitives shall imply the ordering
+ information between features or feature properties. The temporal connection of features can
+ be examined if they have temporal topology primitives as values of their properties.
+ Usually, an instantaneous feature associates with a time node, and a static feature
+ associates with a time edge. A feature with both modes associates with the temporal topology
+ primitive: a supertype of time nodes and time edges. A topological primitive is always
+ connected to one or more other topological primitives, and is, therefore, always a member of
+ a topological complex. In a GML instance, this will often be indicated by the primitives
+ being described by elements that are descendents of an element describing a complex.
+ However, in order to support the case where a temporal topological primitive is described in
+ another context, the optional complex property is provided, which carries a reference to the
+ parent temporal topological complex.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeTopologyPrimitivePropertyType provides for associating a
+ gml:AbstractTimeTopologyPrimitive with an object.
+
+
+
+
+
+
+
+
+
+ A temporal topology complex shall be the connected acyclic directed graph
+ composed of temporal topological primitives, i.e. time nodes and time edges. Because a time
+ edge may not exist without two time nodes on its boundaries, static features have time edges
+ from a temporal topology complex as the values of their temporal properties, regardless of
+ explicit declarations. A temporal topology complex expresses a linear or a non-linear graph.
+ A temporal linear graph, composed of a sequence of time edges, provides a lineage described
+ only by "substitution" of feature instances or feature element values. A time node as the
+ start or the end of the graph connects with at least one time edge. A time node other than
+ the start and the end shall connect to at least two time edges: one of starting from the
+ node, and another ending at the node. A temporal topological complex is a set of connected
+ temporal topological primitives. The member primtives are indicated, either by reference or
+ by value, using the primitive property.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeTopologyComplexPropertyType provides for associating a
+ gml:TimeTopologyComplex with an object.
+
+
+
+
+
+
+
+
+
+ A time node is a zero-dimensional topological primitive that represents an
+ identifiable node in time (it is equivalent to a point in space). A node may act as the
+ termination or initiation of any number of time edges. A time node may be realised as a
+ geometry, its position, whose value is a time instant.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeNodePropertyType provides for associating a gml:TimeNode with an
+ object
+
+
+
+
+
+
+
+
+
+ A time edge is a one-dimensional topological primitive. It is an open interval
+ that starts and ends at a node. The edge may be realised as a geometry whose value is a time
+ period.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeEdgePropertyType provides for associating a gml:TimeEdge with an
+ object.
+
+
+
+
+
+
+
+
+
+ A reference system is characterized in terms of its domain of validity: the
+ spatial and temporal extent over which it is applicable. The basic GML element for temporal
+ reference systems is gml:TimeReferenceSystem. Its content model extends gml:DefinitionType
+ with one additional property, gml:domainOfValidity.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A temporal coordinate system shall be based on a continuous interval scale
+ defined in terms of a single time interval. The differences to ISO 19108 TM_CoordinateSystem
+ are: - the origin is specified either using the property gml:originPosition whose value is a
+ direct time position, or using the property gml:origin whose model is
+ gml:TimeInstantPropertyType; this permits more flexibility in representation and also
+ supports referring to a value fixed elsewhere; - the interval uses
+ gml:TimeIntervalLengthType.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A calendar is a discrete temporal reference system that provides a basis for
+ defining temporal position to a resolution of one day. gml:TimeCalendar adds one property to
+ those inherited from gml:TimeReferenceSystem. A gml:referenceFrame provides a link to a
+ gml:TimeCalendarEra that it uses. A gml:TimeCalendar may reference more than one calendar
+ era. The referenceFrame element follows the standard GML property model, allowing the
+ association to be instantiated either using an inline description using the
+ gml:TimeCalendarEra element, or a link to a gml:TimeCalendarEra which is explicit
+ elsewhere.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeCalendarEra inherits basic properties from gml:DefinitionType and has
+ the following additional properties: - gml:referenceEvent is the name or description of a
+ mythical or historic event which fixes the position of the base scale of the calendar era.
+ This is given as text or using a link to description held elsewhere. - gml:referenceDate
+ specifies the date of the referenceEvent expressed as a date in the given calendar. In most
+ calendars, this date is the origin (i.e., the first day) of the scale, but this is not
+ always true. - gml:julianReference specifies the Julian date that corresponds to the
+ reference date. The Julian day number is an integer value; the Julian date is a decimal
+ value that allows greater resolution. Transforming calendar dates to and from Julian dates
+ provides a relatively simple basis for transforming dates from one calendar to another. -
+ gml:epochOfUse is the period for which the calendar era was used as a basis for
+ dating.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeCalendarPropertyType provides for associating a gml:TimeCalendar with
+ an object.
+
+
+
+
+
+
+
+
+
+ gml:TimeCalendarEraPropertyType provides for associating a gml:TimeCalendarEra
+ with an object.
+
+
+
+
+
+
+
+
+
+ A clock provides a basis for defining temporal position within a day. A clock
+ shall be used with a calendar in order to provide a complete description of a temporal
+ position within a specific day. gml:TimeClock adds the following properties to those
+ inherited from gml:TimeReferenceSystemType: - gml:referenceEvent is the name or description
+ of an event, such as solar noon or sunrise, which fixes the position of the base scale of
+ the clock. - gml:referenceTime specifies the time of day associated with the reference event
+ expressed as a time of day in the given clock. The reference time is usually the origin of
+ the clock scale. - gml:utcReference specifies the 24 hour local or UTC time that corresponds
+ to the reference time. - gml:dateBasis contains or references the calendars that use this
+ clock.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeClockPropertyType provides for associating a gml:TimeClock with an
+ object.
+
+
+
+
+
+
+
+
+
+ In some applications of geographic information — such as geology and
+ archaeology — relative position in time is known more precisely than absolute time or
+ duration. The order of events in time can be well established, but the magnitude of the
+ intervals between them cannot be accurately determined; in such cases, the use of an ordinal
+ temporal reference system is appropriate. An ordinal temporal reference system is composed
+ of a sequence of named coterminous eras, which may in turn be composed of sequences of
+ member eras at a finer scale, giving the whole a hierarchical structure of eras of verying
+ resolution. An ordinal temporal reference system whose component eras are not further
+ subdivided is effectively a temporal topological complex constrained to be a linear graph.
+ An ordinal temporal reference system some or all of whose component eras are subdivided is
+ effectively a temporal topological complex with the constraint that parallel branches may
+ only be constructed in pairs where one is a single temporal ordinal era and the other is a
+ sequence of temporal ordinal eras that are called "members" of the "group". This constraint
+ means that within a single temporal ordinal reference system, the relative position of all
+ temporal ordinal eras is unambiguous. The positions of the beginning and end of a given era
+ may calibrate the relative time scale. gml:TimeOrdinalReferenceSystem adds one or more
+ gml:component properties to the generic temporal reference system model.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Its content model follows the pattern of gml:TimeEdge, inheriting standard
+ properties from gml:DefinitionType, and adding gml:start, gml:end and gml:extent properties,
+ a set of gml:member properties which indicate ordered gml:TimeOrdinalEra elements, and a
+ gml:group property which points to the parent era. The recursive inclusion of
+ gml:TimeOrdinalEra elements allow the construction of an arbitrary depth hierarchical
+ ordinal reference schema, such that an ordinal era at a given level of the hierarchy
+ includes a sequence of shorter, coterminous ordinal eras.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ gml:TimeOrdinalEraPropertyType provides for associating a gml:TimeOrdinalEra
+ with an object.
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
+
+ deprecated
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/opengis/xlink/1.0/xlink-1.0.xsd b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/opengis/xlink/1.0/xlink-1.0.xsd
new file mode 100644
index 0000000..8d557f8
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/opengis/xlink/1.0/xlink-1.0.xsd
@@ -0,0 +1,98 @@
+
+
+
+ xlinks.xsd v3.0b2
+ 2001-07
+ GML 3.0 candidate xlinks schema. Copyright (c) 2001 OGC, All Rights
+ Reserved.
+
+
+
+
+
+
+
+ The 'show' attribute is used to communicate the desired presentation of the
+ ending resource on traversal from the starting resource; it's value should be treated as
+ follows: new - load ending resource in a new window, frame, pane, or other presentation
+ context replace - load the resource in the same window, frame, pane, or other presentation
+ context embed - load ending resource in place of the presentation of the starting resource
+ other - behavior is unconstrained; examine other markup in the link for hints none -
+ behavior is unconstrained
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The 'actuate' attribute is used to communicate the desired timing of traversal
+ from the starting resource to the ending resource; it's value should be treated as follows:
+ onLoad - traverse to the ending resource immediately on loading the starting resource
+ onRequest - traverse from the starting resource to the ending resource only on a
+ post-loading event triggered for this purpose other - behavior is unconstrained; examine
+ other markup in link for hints none - behavior is unconstrained
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/w3c/2008/06/xlink.xsd b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/w3c/2008/06/xlink.xsd
new file mode 100644
index 0000000..b07860a
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/w3c/2008/06/xlink.xsd
@@ -0,0 +1,273 @@
+
+
+
+
+ This schema document provides attribute declarations and
+attribute group, complex type and simple type definitions which can be used in
+the construction of user schemas to define the structure of particular linking
+constructs, e.g.
+
+
+
+
+
+
+ ...
+
+ ...
+
+
+ ...
+]]>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intended for use as the type of user-declared elements to make them
+ simple links.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intended for use as the type of user-declared elements to make them
+ extended links.
+ Note that the elements referenced in the content model are all abstract.
+ The intention is that by simply declaring elements with these as their
+ substitutionGroup, all the right things will happen.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ xml:lang is not required, but provides much of the
+ motivation for title elements in addition to attributes, and so
+ is provided here for convenience.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ label is not required, but locators have no particular
+ XLink function if they are not labeled.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ from and to have default behavior when values are missing
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/w3c/2009/01/xml.xsd b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/w3c/2009/01/xml.xsd
new file mode 100644
index 0000000..79427b7
--- /dev/null
+++ b/src/main/resources/org/opengis/cite/ogcapiprocesses10/xsd/w3c/2009/01/xml.xsd
@@ -0,0 +1,36 @@
+
+
+
+ This schema document describes the XML namespace, in a form suitable for
+ import by other schema documents. See http://www.w3.org/XML/1998/namespace.html and
+ http://www.w3.org/TR/REC-xml for information about this namespace.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/resources/test-run-props.xml b/src/main/resources/test-run-props.xml
new file mode 100644
index 0000000..a5fcf35
--- /dev/null
+++ b/src/main/resources/test-run-props.xml
@@ -0,0 +1,7 @@
+
+
+
+ Sample test run arguments
+ http://www.w3schools.com/xml/note.xml
+ class-A,class-B
+
diff --git a/src/main/scripts/ctl/ogcapi-processes10-suite.ctl b/src/main/scripts/ctl/ogcapi-processes10-suite.ctl
new file mode 100644
index 0000000..4f58451
--- /dev/null
+++ b/src/main/scripts/ctl/ogcapi-processes10-suite.ctl
@@ -0,0 +1,142 @@
+
+
+
+
+ A Document node containing test run arguments (as XML properties).
+ The directory in which the test results will be written.
+ The test results as a Source object (root node).
+ Runs the ogcapi-processes10 ${version} test suite.
+
+
+
+
+
+
+
+ OGC API - Processes Standard 1.0 Conformance Test Suite
+ Describe scope of testing.
+ tns:Main
+
+
+
+ The test subject satisfies all applicable constraints.
+
+
+
+
OGC API - Processes Standard 1.0 Conformance Test Suite
+
+
The implementation under test (IUT) is checked against the following specifications: