Package org.geotools.xsd

Class Configuration

Object
Configuration
Direct Known Subclasses:
ApplicationSchemaConfiguration, AppSchemaConfiguration, CSWConfiguration, DCConfiguration, DCTConfiguration, FESConfiguration, GMLConfiguration, GMLConfiguration, GMLConfiguration, GMLConfiguration, GPKGConfiguration, InterpolationConfiguration, KMLConfiguration, KMLConfiguration, OGCConfiguration, OGCConfiguration, OGCConfiguration, OWSConfiguration, OWSConfiguration, OWSConfiguration, RangeSubsetConfiguration, ScalingConfiguration, SEConfiguration, SLDConfiguration, SLDConfiguration, SMIL20Configuration, SMIL20LANGConfiguration, WCSConfiguration, WCSConfiguration, WCSConfiguration, WCSEOConfiguration, WFSConfiguration, WFSConfiguration, WMSConfiguration, WMTSConfiguration, WPSConfiguration, WPSConfiguration, XLINKConfiguration, XMLConfiguration, XSConfiguration
public abstract class Configuration extends Object
Responsible for configuring a parser runtime environment.

Implementations have the following responsibilities:

  • Configuration of bindings.
  • Configuration of context used by bindings.
  • Supplying specialized handlers for looking up schemas.
  • Supplying specialized handlers for parsing schemas.
  • Declaring dependencies on other configurations

Dependencies

Configurations have dependencies on one another, that results from the fact that one schema imports another. Configuration dependencies are transitive. Each configuration should declare all dependencies in the constructor using the addDependency(Configuration) method. 

         class MyConfiguration extends Configuration {
     public MyConfiguration() {
       super();

       addDependency( new FooConfiguration() );
       addDependency( new BarConfiguration() );
     }
     ...
  }

Binding Configuration

To enable a particular binding to be found during a parse, the configuration must first populate a container with said binding. This can be done by returning the appropriate instance of org.geotools.xml.BindingConfiguration in #getBindingConfiguration(): 

          
  BindingConfiguration getBindingConfiguration() {
      return new MyBindingConfiguration();
  }
Instances of type org.geotools.xml.BindingConfiguration are used to populate a container with all the bindings from a particular schema.

Context Configuration

Many bindings have dependencies on other types of objects. The pattern used to satisfy these dependencies is known as Constructor Injection. Which means that any dependencies a binding has is passed to it in its constructor. For instance, the following binding has a dependency on java.util.List. 

         
 class MyBinding implements SimpleBinding {

                List list;

                 public MyBinding(List list) {
                         this.list = list;
                 }
 }
Before a binding can be created, the container in which it is housed in must be able to satisfy all of its dependencies. It is the responsibility of the configuration to satisfy this criteria. This is known as configuring the binding context. The following is a suitable configuration for the above binding. 
         
 class MyConfiguration extends Configuration {
        ....
                void configureContext(MutablePicoContainer container) {
                        container.registerComponentImplementation(ArrayList.class);
                }
 }

Schema Resolution

XML instance documents often contain schema uri references that are invalid with respect to the parser, or non-existent. A configuration can supply specialized look up classes to prevent the parser from following an invalid uri and prevent any errors that may occur as a result.

An instance of XSDSchemaLocationResolver can be used to override a schemaLocation referencing another schema. This can be useful when the entity parsing an instance document stores schemas in a location unknown to the entity providing the instance document.

An instance of XSDSchemaLocator can be used to provide an pre-parsed schema and prevent the parser from parsing a schemaLocation manually. This can be useful when an instance document does not supply a schemaLocation for the targetNamespace of the document. 

         
 class MyConfiguration implements Configuration {

                XSDSchemaLocationResolver getSchemaLocationResolver() {
                  return new MySchemaLocationResolver();
                }

                XSDSchemaLocator getSchemaLocator() {
                  return new MySchemaLocator();
                }
 }

The XSDSchemaLocator and XSDSchemaLocationResolver implementations are used in a couple of scenarios. The first is when the schemaLocation attribute of the root element of the instance document is being parsed. The schemaLocation attribute has the form: 

 
         schemaLocation="namespace location namespace location ..."
In which (namespace,location) tuples are listed. For each each namespace encountered when parsing the schemaLocation attribute, an appropriate resolver / locator is looked up. If an override is not available, the framework attempts to resolve the location part of the tuple into a schema.

The second scenario occurs when the parsing of a schema encounters an import or an include element. These elements have the form: 

  
      <import namespace="" schemaLocation=""/>
and: 
  
      <include schemaLocation="">
respectively. Similar to above, the schemaLocation (and namespace in the case of an import) are used to find an override. If not found they are resolved directly.
Author:
Justin Deoliveira,Refractions Research Inc.,jdeolive@refractions.net
See Also:
  • org.geotools.xml.BindingConfiguration

  • Constructor Details

    • Configuration

      public Configuration(XSD xsd)
      Creates a new configuration.

      Any dependent schemas should be added in subclass constructor. The xml schema dependency does not have to be added.

  • Method Details

    • getXSD

      public XSD getXSD()
      The XSD instance representing the schema for which the schema works against.

    • getDependencies

      public final List<Configuration> getDependencies()
      Returns:
      a list of direct dependencies of the configuration.

    • getProperties

      public final Set<QName> getProperties()
      Returns a list of parser properties to set.

      To set a parser property: 

       Configuration configuration = ...
 configuration.getProperties().add( Parser.Properties.... );

      Beware this class is not thread safe so take the needed precautions when using the list returned by this method.

      Returns:
      A list of hte set parser properties.

    • hasProperty

      public final boolean hasProperty(QName property)
      Searches the configuration and all dependent configuration for the specified property.

    • allDependencies

      public final List<Configuration> allDependencies()
      Returns all dependencies in the configuration dependency tree.

      The return list contains no duplicates.

      Returns:
      All dependencies in the configuration dependency tree.

    • getDependency

      public <C extends Configuration> C getDependency(Class<C> clazz)
      Returns the first dependency of this configuration of the specified type.
      Since:
      8.0

    • addDependency

      protected void addDependency(Configuration dependency)
      Adds a dependent configuration.

      This method should only be called from the constructor.

    • getNamespaceURI

      public final String getNamespaceURI()
      Returns:
      The namespace of the configuration schema.

    • getContext

      public final MutablePicoContainer getContext()
      Returns an internal context which is copied into the runtime context while parsing.

      This context is provided to allow for placing values in the parsing context without having to subclass.

      Returns:
      The context.

    • setupBindings

      public final Map<QName,Object> setupBindings()
      Creates the map of QName to Binding which is used during parsing to attach bindings to an element,attribute, or type.
      Returns:
      A map of Qname,[Class|Object]

    • setupParser

      public final void setupParser(Parser parser)
      Prepares a parser instance for use with this Configuration instance and all of its dependencies.
      Since:
      2.7

    • setupEncoder

      public final void setupEncoder(Encoder encoder)
      Prepares a encoder instance for use with this Configuration instance and all of its dependencies.
      Since:
      2.7

    • registerBindings

      protected void registerBindings(MutablePicoContainer container)
      Registers the bindings for the configuration.

      This method is intended to provide the default bindings for a configuration and is intended to be subclassed by client code. Client code should use configureBindings(MutablePicoContainer) . Subclasses should mark this method as final after implementing.

      Parameters:
      container - Container containing all bindings, keyed by QName.

    • registerBindings

      protected void registerBindings(Map<QName,Object> bindings)
      Registers the bindings for the configuration.

      This method is intended to provide the "default" bindings for a configuration and is not intended to be subclassed by client code. Client code should use configureBindings(MutablePicoContainer) to override/remove/add new bindings on the fly.

      The key of the bindings map is of type QName. The value can be class, or an instance. In the case of a class, the binding will be instantiated by the parser at runtime. In the instance case the binding will be used as is.

    • configureBindings

      protected void configureBindings(MutablePicoContainer container)
      Template method allowing subclass to override any bindings.
      Parameters:
      container - Container containing all bindings, keyed by QName.

    • configureBindings

      protected void configureBindings(Map<QName,Object> bindings)
      Template method allowing subclass to override any bindings.
      Parameters:
      bindings - Map containing all bindings, keyed by QName.

    • setupContext

      public final MutablePicoContainer setupContext(MutablePicoContainer container)
      Configures the root context to be used when parsing elements.
      Parameters:
      container - The container representing the context.

    • configureContext

      protected void configureContext(MutablePicoContainer container)
      Configures the root context to be used when parsing elements.

      The context satisfies any dependencies needed by a binding. This is often a factory used to create something.

      This method should be overridden. The default implementation does nothing.

      Parameters:
      container - The container representing the context.

    • configureParser

      protected void configureParser(Parser parser)
      Configures the parser to be used with this configuration.

      This method provides a callback for Configuration instances to configure the parser with whatever options they require.

    • configureEncoder

      protected void configureEncoder(Encoder encoder)
      Configures the encoder to be used with this configuration.

      This method provides a callback for Configuration instances to configure the encoder with whatever options they require.

    • equals

      public final boolean equals(Object obj)
      Equals override, equality is based solely on getNamespaceURI().
      Overrides:
      equals in class Object

    • hashCode

      public final int hashCode()
      Overrides:
      hashCode in class Object