Package net.sf.saxon

## Interface Platform

- All Known Implementing Classes:
    `JavaPlatform`, `JavaPlatformEE`, `JavaPlatformPE`

      public interface Platform

  This interface provides access to methods whose implementation depends on the chosen platform (typically Java or .NET)

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | `canReturnCollationKeys​(StringCollator collation)` | Given a collation, determine whether it is capable of returning collation keys.
    `RegularExpression` | `compileRegularExpression​(Configuration config, java.lang.CharSequence regex, java.lang.String flags, java.lang.String hostLanguage, java.util.List<java.lang.String> warnings)` | Compile a regular expression
    `AtomicMatchKey` | `getCollationKey​(SimpleCollation namedCollation, java.lang.String value)` | Given a collation, get a collation key.
    `ExternalObjectType` | `getExternalObjectType​(Configuration config, java.lang.String uri, java.lang.String localName)` | Get a SchemaType representing a wrapped external (Java or .NET) object
    `java.lang.String` | `getInstallationDirectory​(java.lang.String edition, Configuration config)` | Return the name of the directory in which the software is installed (if available)
    `javax.xml.transform.Source` | `getParserSource​(PipelineConfiguration pipe, javax.xml.transform.stream.StreamSource input, int validation, boolean dtdValidation)` | Convert a StreamSource to a different kind of Source, depending on the native parser of the selected platform
    `java.lang.String` | `getPlatformSuffix()` | Get a suffix letter to add to the Saxon version number to identify the platform
    `java.lang.String` | `getPlatformVersion()` | Get the platform version
    `boolean` | `hasICUCollator()` | Indicate whether the ICU library is available and supports Collations
    `boolean` | `hasICUNumberer()` | Indicate whether the ICU library is available and supports Numberers
    `void` | `initialize​(Configuration config)` | Perform platform-specific initialization of the configuration
    `boolean` | `isDotNet()` | Return true if this is the .NET platform
    `boolean` | `isJava()` | Return true if this is the Java platform
    `boolean` | `JAXPStaticContextCheck​(RetainedStaticContext retainedStaticContext, StaticContext sc)` | Checks if the supplied static context is an instance of the JAXP static context.
    `org.xml.sax.XMLReader` | `loadParser()` | Get a parser by instantiating the SAXParserFactory
    `org.xml.sax.XMLReader` | `loadParserForXmlFragments()` | Get an XML parser suitable for use for reading XML fragments.
    `StringCollator` | `makeCollation​(Configuration config, java.util.Properties props, java.lang.String uri)` | Obtain a collation with a given set of properties.
    `java.lang.ClassLoader` | `makeGeneratedClassLoader​(Configuration config, java.lang.Class thisClass)` | Return the class loader required to load the bytecode generated classes
    `ModuleURIResolver` | `makeStandardModuleURIResolver​(Configuration config)` | Make an instance of the default module URI resolver for this platform
    `StringCollator` | `makeUcaCollator​(java.lang.String uri, Configuration config)` | If available, make a UCA collation.
    `void` | `registerAllBuiltInObjectModels​(Configuration config)` | Register all the external object models that are provided as standard with the relevant edition of Saxon for this Configuration
    `void` | `setDefaultSAXParserFactory​(Configuration config)` | Set the default XML parser to be loaded by the SAXParserFactory on this platform.

- - ### Method Detail

    - #### initialize

          void initialize​(Configuration config)

      Perform platform-specific initialization of the configuration
      Parameters:
        `config` - the Saxon Configuration

    - #### isJava

          boolean isJava()

      Return true if this is the Java platform
      Returns:
        true if this is the Java platform

    - #### isDotNet

          boolean isDotNet()

      Return true if this is the .NET platform
      Returns:
        true if this is the .NET platform

    - #### getPlatformVersion

          java.lang.String getPlatformVersion()

      Get the platform version
      Returns:
        the version of the platform, for example "Java version 1.5.09"

    - #### getPlatformSuffix

          java.lang.String getPlatformSuffix()

      Get a suffix letter to add to the Saxon version number to identify the platform
      Returns:
        "J" for Java, "N" for .NET

    - #### loadParser

          org.xml.sax.XMLReader loadParser()

      Get a parser by instantiating the SAXParserFactory
      Returns:
        the parser (XMLReader)

    - #### loadParserForXmlFragments

          org.xml.sax.XMLReader loadParserForXmlFragments()

      Get an XML parser suitable for use for reading XML fragments. This may differ from the parser used for reading complete XML documents, because some parsers may lack the capability to read fragments. See bug 4253.
      Returns:
        the parser (XMLReader)

    - #### getParserSource

          javax.xml.transform.Source getParserSource​(PipelineConfiguration pipe,
                                                     javax.xml.transform.stream.StreamSource input,
                                                     int validation,
                                                     boolean dtdValidation)

      Convert a StreamSource to a different kind of Source, depending on the native parser of the selected platform
      Parameters:
        `pipe` - the pipeline Configuration
        `input` - the supplied StreamSource
        `validation` - required validation mode, for example Validation.STRICT
        `dtdValidation` - true if DTD-based input validation is required
      Returns:
        the PullSource or SAXSource, initialized with a suitable parser, or the original input Source, if now special handling is required or possible

    - #### makeCollation

          StringCollator makeCollation​(Configuration config,
                                       java.util.Properties props,
                                       java.lang.String uri)
                                throws XPathException

      Obtain a collation with a given set of properties. The set of properties is extensible and variable across platforms. Common properties with example values include lang=en-GB, strength=primary, case-order=upper-first, ignore-modifiers=yes, alphanumeric=yes. Properties that are not supported are generally ignored; however some errors, such as failing to load a requested class, are fatal.
      Parameters:
        `config` - the configuration object
        `props` - the desired properties of the collation
        `uri` - the collation URI
      Returns:
        a collation with these properties
      Throws:
        `XPathException` - if a fatal error occurs

    - #### canReturnCollationKeys

          boolean canReturnCollationKeys​(StringCollator collation)

      Given a collation, determine whether it is capable of returning collation keys. The essential property of collation keys is that if two values are equal under the collation, then the collation keys are equal under the equals() method.
      Parameters:
        `collation` - the collation being examined, provided as a Comparator
      Returns:
        true if this collation can supply collation keys

    - #### getCollationKey

          AtomicMatchKey getCollationKey​(SimpleCollation namedCollation,
                                         java.lang.String value)

      Given a collation, get a collation key. The essential property of collation keys is that if two values are equal under the collation, then the collation keys are equal under the equals() method.
      Parameters:
        `namedCollation` - the collation in use
        `value` - the string whose collation key is required
      Returns:
        a representation of the collation key, such that two collation keys are equal() if and only if the string values they represent are equal under the specified collation.
      Throws:
        `java.lang.ClassCastException` - if the collation is not one that is capable of supplying collation keys (this should have been checked in advance)

    - #### hasICUCollator

          boolean hasICUCollator()

      Indicate whether the ICU library is available and supports Collations
      Returns:
        true if the ICU library class for collations appears to be loaded

    - #### hasICUNumberer

          boolean hasICUNumberer()

      Indicate whether the ICU library is available and supports Numberers
      Returns:
        true if the ICU library class for rule-based numbering appears to be loaded

    - #### makeUcaCollator

          StringCollator makeUcaCollator​(java.lang.String uri,
                                         Configuration config)
                                  throws XPathException

      If available, make a UCA collation. Depending on the Saxon edition and licensing, this will use the ICU-J Library if available, or the built-in Java collation support otherwise.
      Parameters:
        `uri` - the collation URI (which will always be a UCA collation URI as defined in XSLT 3.0)
        `config` - the Saxon configuration
      Returns:
        the collation, or null if not available
      Throws:
        `XPathException` - if the URI is malformed in some way

    - #### compileRegularExpression

          RegularExpression compileRegularExpression​(Configuration config,
                                                     java.lang.CharSequence regex,
                                                     java.lang.String flags,
                                                     java.lang.String hostLanguage,
                                                     java.util.List<java.lang.String> warnings)
                                              throws XPathException

      Compile a regular expression
      Parameters:
        `config` - the Saxon configuration
        `regex` - the regular expression as a string
        `flags` - the value of the flags attribute
        `hostLanguage` - one of "XSD10", "XSD11", XP20" or "XP30". Also allow combinations, e.g. "XP20/XSD11".
        `warnings` - if non-null, any warnings from the regular expression compiler will be added to this list. If null, the warnings are ignored.
      Returns:
        the compiled regular expression
      Throws:
        `XPathException` - if the regular expression or the flags are invalid

    - #### getExternalObjectType

          ExternalObjectType getExternalObjectType​(Configuration config,
                                                   java.lang.String uri,
                                                   java.lang.String localName)

      Get a SchemaType representing a wrapped external (Java or .NET) object
      Parameters:
        `config` - the Saxon Configuration
        `uri` - the namespace URI of the schema type
        `localName` - the local name of the schema type
      Returns:
        the SchemaType object representing this type

    - #### getInstallationDirectory

          java.lang.String getInstallationDirectory​(java.lang.String edition,
                                                    Configuration config)

      Return the name of the directory in which the software is installed (if available)
      Parameters:
        `edition` - The edition of the software that is loaded ("HE", "PE", or "EE")
        `config` - the Saxon configuration
      Returns:
        the name of the directory in which Saxon is installed, if available, or null otherwise

    - #### registerAllBuiltInObjectModels

          void registerAllBuiltInObjectModels​(Configuration config)

      Register all the external object models that are provided as standard with the relevant edition of Saxon for this Configuration
      Parameters:
        `config` - the Saxon configuration
      Since:
        9.3

    - #### setDefaultSAXParserFactory

          void setDefaultSAXParserFactory​(Configuration config)

      Set the default XML parser to be loaded by the SAXParserFactory on this platform. Needed because the Apache catalog resolver uses the SAXParserFactory to instantiate a parser, and if not customized this causes a failure on the .NET platform.
      Parameters:
        `config` - the Saxon configuration
      Since:
        9.4

    - #### JAXPStaticContextCheck

          boolean JAXPStaticContextCheck​(RetainedStaticContext retainedStaticContext,
                                         StaticContext sc)

      Checks if the supplied static context is an instance of the JAXP static context. On Java we create namespace information from the JAXP XPath static context. On the .NET platform we do nothing.
      Parameters:
        `retainedStaticContext` - If the static context is a JAXPStaticContext, then its namespaces are used to update the retainedStaticContext
        `sc` - the possible JAXPStaticContext
      Returns:
        boolean
      Since:
        9.7.0.5

    - #### makeStandardModuleURIResolver

          ModuleURIResolver makeStandardModuleURIResolver​(Configuration config)

      Make an instance of the default module URI resolver for this platform
      Parameters:
        `config` - the Saxon configuration
      Returns:
        an instance of ModuleURIResolver
      Since:
        9.7.0.2

    - #### makeGeneratedClassLoader

          java.lang.ClassLoader makeGeneratedClassLoader​(Configuration config,
                                                         java.lang.Class thisClass)

      Return the class loader required to load the bytecode generated classes
      Parameters:
        `config` - The saxon configuration
        `thisClass` - The class object generated
      Returns:
        the class loader object
      Since:
        9.6.0.3