Java saxon

Java saxon DEFAULT

Java XML and JSON: Document processing for Java SE, Part 1: SAXON and Jackson

XML and JSON are important to me, and I'm grateful to Apress for letting me write an entire book about them. In this article I will briefly introduce the second edition of my new book, Java XML and JSON. I'll also present two useful demos that I would have liked to include in the book if I'd had space for them.

First, I'll show you how to override Xalan, which is the standard XSLT implementation for Java 11, with an XSLT 2.0+ and XPath 2.0+-compatible alternative, in this case SAXON. Using SAXON for XSLT/XPath makes it much easier to access features such as grouping, which I'll also demonstrate. Next, I'll show you two ways to convert XML to JSON with Jackson: the first technique is data binding, the second is tree traversal.

Why XML and JSON?

Before XML arrived, I wrote software to import data stored in an undocumented binary format. I used a debugger to identify data field types, file offsets, and lengths. When XML came along, and then JSON, the technology greatly simplified my life.

The first edition of Java XML and JSON (June 2016) introduces XML and JSON, explores Java SE's own XML-oriented APIs, and explores external JSON-oriented APIs for Java SE. The second edition, recently published by Apress, offers new content, and (hopefully) answers more questions about XML, JSON, Java SE's XML APIs, and various JSON APIs, including JSON-P. It's also updated for Java SE 11.

After writing the book I wrote two additional sections introducing useful features of SAXON and Jackson, respectively. I'll present those sections in this article. First, I'll take a minute to introduce the book and its contents.

Java XML and JSON, second edition

Ideally, you should read the second edition of Java XML and JSON before studying the additional content in this article. Even if you haven't read the book yet, you should know what it covers, because that information puts the additional sections in context.

The second edition of Java XML and JSON is organized into three parts, consisting of 12 chapters and an appendix:

  • Part 1: Exploring XML
    • Chapter 1: Introducing XML
    • Chapter 2: Parsing XML Documents with SAX
    • Chapter 3: Parsing and Creating XML Documents with DOM
    • Chapter 4: Parsing and Creating XML Documents with StAX
    • Chapter 5: Selecting Nodes with XPath
    • Chapter 6: Transforming XML Documents with XSLT
  • Part 2: Exploring JSON
    • Chapter 7: Introducing JSON
    • Chapter 8: Parsing and Creating JSON Objects with mJson
    • Chapter 9: Parsing and Creating JSON Objects with Gson
    • Chapter 10: Extracting JSON Values with JsonPath
    • Chapter 11: Processing JSON with Jackson
    • Chapter 12: Processing JSON with JSON-P
  • Part 3: Appendices
    • Appendix A: Answers to Exercises

Part 1 focuses on XML. Chapter 1 defines key terminology, presents XML language features (XML declaration, elements and attributes, character references and CDATA sections, namespaces, and comments and processing instructions), and covers XML document validation (via Document Type Definitions and schemas). The remaining five chapters explore Java SE's SAX, DOM, StAX, XPath, and XSLT APIs.

Part 2 focuses on JSON. Chapter 7 defines key terminology, tours JSON syntax, demonstrates JSON in a JavaScript context (because Java SE has yet to officially support JSON), and shows how to validate JSON objects (via the JSON Schema Validator online tool). The remaining five chapters explore the third-party mJSon, Gson, JsonPath, and Jackson APIs; and Oracle's Java EE-oriented JSON-P API, which is also unofficially available for use in a Java SE context.

Each chapter ends with a set of exercises, including programming exercises, which are designed to reinforce the reader's understanding of the material. Answers are revealed in the book's appendix.

The new edition differs from its predecessor in some significant ways:

  • Chapter 2 shows the proper way to obtain an XML reader. The previous edition's approach is deprecated.
  • Chapter 3 also introduces the DOM's Load and Save, Range, and Traversal APIs.
  • Chapter 6 shows how to work with SAXON to move beyond XSLT/XPath 1.0.
  • Chapter 11 is a new (lengthy) chapter that explores Jackson.
  • Chapter 12 is a new (lengthy) chapter that explores JSON-P.

This edition also corrects minor errors in the previous edition's content, updates various figures, and adds numerous new exercises.

While I didn't have room for it in the second edition, a future edition of Java XML and JSON may cover YAML.

Addendum to Chapter 6: Transforming XML documents with XSLT

Move beyond XSLT/XPath 1.0 with SAXON

Java 11's XSLT implementation is based on the Apache Xalan Project, which supports XSLT 1.0 and XPath 1.0 but is limited to these early versions. To access the later XSLT 2.0+ and XPath 2.0+ features, you need to override the Xalan implementation with an alternative such as SAXON.

Java XML and JSON, Chapter 6 shows how to override Xalan with SAXON, then verify that SAXON is being used. In the demo, I recommend inserting the following line at the beginning of an application's method, in order to use SAXON:

You don't actually need this method call because SAXON's implementation is provided in a JAR file as a service that's loaded automatically when the JAR file is accessible via the classpath. However, if there were multiple implementation JAR files on the classpath, and if the Java runtime chose a non-SAXON service as the transformer implementation, there could be a problem. Including the aforementioned method call would override that choice with SAXON.

XSLT/XPath features: A demo

Chapter 6 presents two applications, and a third application is available in the book's code archive. Listing 1, below, presents a fourth demo application that highlights XSLT/XPath features.

Listing 1. XSLTDemo.java

The code in Listing 1 is similar to Chapter 6's Listing 6-2, but there are some differences. First, Listing 1's method must be called with two command-line arguments: the first argument names the XML file; the second argument names the XSL file.

The second difference is that I don't set any output properties on the transformer. Specifically, I don't specify the output method or whether indentation is used. These tasks can be accomplished in the XSL file.

Compile Listing 1 as follows:

XSLT 2.0 example: Grouping nodes

XSLT 1.0 doesn't offer built-in support for grouping nodes. For example, you might want to transform the following XML document, which lists books with their authors:

into the following XML, which lists authors with their books:

While this transformation is possible in XSLT 1.0, it's awkward. XSLT 2.0's element, by contrast, lets you take a set of nodes, group it by some criterion, and process each created group.

Let's explore this capability, starting with an XML document to process. Listing 2 presents the contents of a file that groups author names by book title.

Listing 2. books.xml (grouping by book title)

Listing 3 presents the contents of a file that provides the XSL transformation to turn this document into one that groups book titles according to author names.

Listing 3. books.xsl (grouping by author name)

The element indicates that indented HTML output is required. The element matches the single root element.

The element selects a sequence of nodes and organizes them into groups. The attribute is an XPath expression that identifies the elements to group. Here, it's told to select all elements that belong to elements. The attribute groups together all elements having the same value for a grouping key, which happens to be the attribute of the element. In essence, you end up with the following groups:

These groups are not in alphabetical order of author names, and so elements will be output such that is first and is last. The element ensures that elements are output in sorted order.

The construct outputs an tag whose attribute is assigned only the first author name in the group.

Continuing, iterates over the author names in the current iteration's group. The construct will sort the output elements, specified via the subsequent construct, according to the book titles.

How to choose a low-code development platform

Sours: https://www.infoworld.com/article/3346229/java-xml-and-json-document-processing-for-java-se-part-1.html

Hi,

I've been using Xalan xslt processor before so I'm used to use the java function this way: <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:java="xalan://java.util.Math" version="1.0">

Or any java function I wrote: xmlns:myfn="xalan://com.mycompany.myproduct.Utils

But when I tried to use saxon, from the research I've done, it seems that all I need is this: xmlns:myfnb="java:com.mycompany.myproduct.Utils"

and I should be able to use any methods in Utils class.

But the fact is that, when I tried this with Saxon-HE, I got the following error message:

Error on line 5 of foo.xsl: XTDE1425: Cannot find a matching 0-argument function named {java.util.Math}random(). For diagnostics on calls to Java methods, use the -TJ command line option or set the Configuration property FeatureKeys.TRACE_EXTERNAL_FUNCTIONS in built-in template rule ; SystemID: file:/C:/foo.xsl; Line#: 5; Column#: -1 net.sf.saxon.trans.XPathException: Cannot find a matching 0-argument function named {java.util.Math}random(). For diagnostics on calls to Java methods, use the -TJ command line option or set the Configuration property FeatureKeys.TRACE_EXTERNAL_FUNCTIONS at net.sf.saxon.expr.ErrorExpression.evaluateItem(ErrorExpression.java:66) at net.sf.saxon.expr.ErrorExpression.iterate(ErrorExpression.java:80) ...

My simple foo.xsl is like this:

Sours: https://saxonica.plan.io/boards/3/topics/5389
  1. Midnight cerakote
  2. Original minecraft skins
  3. Msi laptop red light on power button
  4. Ffxiv healer role skills
  5. Nand drama review

SAXON: The XSLT and XQuery Processor

This is the SourceForge home page for the Open Source Saxon XSLT & XQuery processor developed by Saxonica Limited. It also provides information about commercial versions of the Saxon product available from Saxonica.

See also the SourceForge project page for Saxon.

Documentation for the current release of Saxon is available online at http://www.saxonica.com/documentation.

Current releases

The latest version of Saxon is version 10, first released on 16 March 2020, available for Java and .NET.

The previous version Saxon 9.9 is the most stable version, first released on 27 September 2018, available for Java and .NET.

On the Java platform, Saxon 9.9 and 10 require Java 8 or above (earlier versions will run on Java 6 or above).

There are several editions of Saxon currently maintained:

  • Saxon-HE (Home Edition) is an open source product available under the Mozilla Public License version 2.0. It provides implementations of XSLT (3.0), XQuery (3.1), and XPath (2.0 and 3.1) at the basic level of conformance defined by W3C, plus from Saxon 10 the optional features higher-order functions and dynamic evaluation. It is available for Java and .NET.

  • Saxon-PE (Professional Edition) is a commercial product available at modest prices from Saxonica Limited. It adds a number of features to Saxon-HE, including support for Saxon extensions and extensibility mechanisms, support for further optional features defined in XSLT 3.0 and XQuery 3.1 including integration with the ICU-J library to provide localization for different languages, and support for external object models such as JDOM2, XOM, DOM4J, and AXIOM. It is available for Java and .NET.

  • Saxon-EE (Enterprise Edition) is the fully-featured commercial product. Saxon-EE 10 offers a complete implementation of the XSLT 3.0 Recommendation published on 8 June 2017. As well as a fully conformant XSD 1.0 and XSD 1.1 schema processor, and support for schema-aware XSLT and XQuery processing, it offers many other features including streaming in XSLT and XQuery, support for XQuery updates, an advanced query optimizer, compilation of XQuery and XSLT code to Java bytecode, multi-threaded execution, and much more. For full details, see the Saxonica website. It is available for Java and .NET.

  • Saxon-JS (JavaScript Edition) provides XSLT 3.0 running in the browser and on Node.js. Stylesheets are compiled into Stylesheet Export Files (SEFs) using Saxon-EE, or Saxon-JS on Node.js, and can then be executed in the browser. It runs in all modern browsers with JavaScript enabled. Details can be found on the Saxonica website Saxon-JS page.

  • Saxon/C is currently at version 1.2.1 for Linux, Mac OS, and Windows. This release is based on Saxon 9.9 source code. Saxon/C 1.2 offers the main Saxon products Saxon-HE, Saxon-PE and Saxon-EE for the C/C++, PHP and Python programming languages. Saxon/C is cross-compiled into a native executable library (.dll on Windows, .so on Linux) with APIs available to run XSLT 3.0, XQuery 3.1, XPath 3.1 and Schema Validation 1.0/1.1 from C/C++, PHP and Python applications. It can also be invoked from other languages such as Perl and Ruby. Details can be found on the Saxonica website Saxon/C page.

Saxon 9.9 on Java requires Java 8 or later. Earlier versions require Java 6 or later.

Saxon 9.8 on .NET requires .NET framework 3.5 or later. It also works on Mono, but we do not run complete tests on this platform. Saxon does not run on .NET Core (this is because the IKVM compiler which we rely on does not target this platform).

Product comparisons

A comparison of the features available in different editions of the Saxon product is available.

A detailed history of changes in successive releases is available.

Latest releases

Saxon-EE 10

The commercial Enterprise Edition from Saxonica, supporting XSLT 3.0, XPath 2.0 and 3.1, XQuery 3.1, XML Schema 1.0 and 1.1, and XQuery Update 1.0.

All current releases are listed on the Saxonica download page.

Source code for Saxon-EE is not available (except to Saxonica development partners).

Saxon-PE 10

The commercial Professional Edition from Saxonica, supporting XSLT 3.0, XPath 2.0 and 3.1, and XQuery 3.1. It omits support for some optional features of these specifications, notably schema awareness and (in the case of XSLT 3.0) streaming.

All current releases are listed on the Saxonica download page.

Source code for Saxon-PE is not available (except to Saxonica development partners).

Saxon-HE 10

The open-source implementation of XSLT 3.0, XPath 2.0 and 3.1, and XQuery 3.1. This provides the "basic" conformance level of these languages; it also supports some optional features of the specifications such as serialization, higher-order functions, dynamic evaluation and support for XQuery modules.

Not included in the Home Edition are: schema processing and schema aware XSLT and XQuery; support for XPath 1.0 (and XSLT 1.0) backwards compatibility mode, numerous Saxon extensions; calling out to Java methods; XQuery Update support; various optimizations including join optimization, streamed processing, multi-threaded execution, and byte code generation.

There are four files available: a ZIP file containing executable code for the Java platform; a .EXE installer for the .NET platform; a resources file containing documentation and sample applications applicable to both platforms; and a ZIP archive of the source code for both platforms. (Documentation is also available online)

Recent Saxon-HE releases can also be downloaded from Maven: see Maven Repository.

The latest 10 maintenance release for Java and .NET is Saxon 10.6, released on 16 September 2021.

The latest 9.9 maintenance release for Java and .NET is Saxon 9.9.1.8, released on 22 October 2020. Saxon 9.9 is currently considered the most stable and reliable release.

Since Saxon 9.4, the Subversion repository for source code is no longer maintained in SourceForge, but on the Saxonica site at https://dev.saxonica.com/repos/archive/opensource. The repository does not contain the development branch of the code, only versions that have been released; it is the best way of obtaining bug fixes quickly if you are prepared to build the product from source (which is not for the faint-hearted).

Note that bug fixes are typically made available in Subversion as soon as they are available, and are then consolidated periodically into a maintenance release. Source code under development is not held in Subversion, and is not available until a tested release is issued. Sometimes prereleases of new facility releases are made available for testing; these are announced on the saxon-help mailing list but will not generally be advertised here.

Older releases of Saxon-HE remain available from SourceForge: see the SourceForge download page for details. If you require a release that is no longer listed, please ask: we can't offer to support it, but in general we don't mind you using it at your own risk.

Saxon-JS 2

Saxon-JS is the JavaScript edition of Saxon, offering XSLT 3.0 running in the browser and on Node.js. It supersedes the earlier Saxon-CE product. For information about the product, see the Saxonica website Saxon-JS page.

Bugs, Forums and Discussion Lists

The bug tracker for all versions of Saxon is a Redmine database hosted at saxonica.plan.io. You are free to enter new bugs here directly, or if bugs are raised by other routes (such as the mailing list) we will register them there if they need to be tracked.

The Redmine database also offers discussion forums and these are the best way to raise technical issues or questions that need an answer from the Saxonica development team.

The SourceForge project hosts a mailing list, saxon-help, which provides a good way of reaching other Saxon users. Since SourceForge is dedicated to open source, we don't encourage use of this list for issues specific to the commercial versions of the product.

If you need help using the underlying languages (XSLT, XQuery, XSD etc) and the problem is not specific to Saxon, it's better to use a general forum rather than a Saxon community resource. The StackOverflow site is the best place to get a good answer to straight coding questions, while the xsl-list (also known as the Mulberry list) is the place for deeper discussions about the nature of XSLT as a language.

To search the history of previous questions and answers on these lists, the database maintained at MarkMail is the most comprehensive and most readily searchable.

Please try to avoid contacting Saxonica developers by personal email; while we love to help, it's much easier to manage the correspondence through an archived forum.

Older Products

Saxon-B

Saxon-HE does not offer all the capabilities that were present in Saxon-B. Most notably, support for Saxon extension functions and other extensions was dropped, as was the capability for writing extension functions that rely on dynamic loading of Java or .NET code (a new facility for "integrated extension functions" is however available). Users whose code relies on these features of Saxon-B should either purchase the Professional Edition product or stick with Saxon-B: the latest release of Saxon-B is 9.1.0.8, and although there are no plans to develop it further or maintain it, it will remain available indefinitely.

Saxon-B version 9.1.0.8 is a complete and conformant implementation of the XSLT 2.0, XQuery 1.0, and XPath 2.0 Recommendations published on 23 January 2007 by W3C.

Saxon-B 9.1.0.8 is available on both the Java and .NET platforms.

For the bug fixes in each successive maintenance release, see the Release Notes and Change Notes for the release on the SourceForge downloads page.

It can be downloaded from:

Saxon 6.5.5

The Saxon XSLT 1.0 processor remains available. The latest version is 6.5.5. However, even if your stylesheets only require XSLT 1.0, it is probably better to run them under Saxon 9.x

This product is mature and stable, and further developments are very unlikely.

The download includes documentation, source code, Java executables, and sample code.

Known limitations of this release are listed here. This page will be updated with information about any new bugs that come to light.

Ant Task for Saxon

There is a custom Ant task for invoking Saxon XSLT transformations. This was previously issued as part of the Saxon product but has now been separated into a separate package under the Saxon SourceForge project. It is no longer actively developed and is not recommended (there are a number of bugs, and it is difficult to improve the quality because of an absence of test material). The download is here.

Ælfred

The Ælfred XML Parser that was bundled with Saxon versions up to version 7.1 is available as a separate download. It is of historic interest only.

DTDGenerator

Also available on this site is the DTDGenerator program. This was formerly produced as a Saxon demonstration application, but has since been adapted to work as a pure SAX application, with no dependencies on the Saxon software.

Documentation for earlier releases remains present on the SourceForge web site: 6.4.2, 6.4.3, 6.5, 6.5.1, 6.5.2, 6.5.3, 6.5.4, 6.5.5, 7.0, 7.1, 7.2, 7.3, 7.3.1, 7.4, 7.5, 7.5.1, 7.6, 7.7, 7.8, 7.9, 7.9.1

For releases from 8.0 onwards, the documentation is not available directly on the web site, but can be obtained by downloading the software.

SourceForge.net Logo


Michael H. Kay
16 September 2021

Sours: http://saxon.sourceforge.net/
2010 Saxon Studio Sound System Meets Java Nuclear Power Sound System @ Alperton HA0

How to run saxon xslt transformation in java

You're best off working with the standard Java APIs for XML and XSLT processing: java.xml.transform

The first class you need to access is javax.xml.transform.TransformerFactory, which you use to create a Transformer object, which you then use to run your XSLT transform. Alternatively, you can use the TransformerFactory to create a Templates object (which will cause Saxon to pre-process/compile/etc your XSLT stylesheet), and then use the Templates object repeatedly to create Transformer objects for your XSLT transforms.

In order to make sure that the javax.xml.transform.TransformerFactory class maps to the Saxon implementation, you can either fiddle around with the boot classpath using command-line options, or use code to do the same:

Once this is done, any calls to TransformerFactory.newInstance() will magically create Saxon TransformerFactory implementations. You're much better off using this method as you'll get the benefits of the standard Java APIs, and you have the freedom to move to other XSLT processors later. You might want to look into using XSLTC, which is part of Apache Xalan, as it is faster for certain types of XSLT stylesheets.

Sours: https://stackoverflow.com/questions/40181386/how-to-run-saxon-xslt-transformation-in-java

Saxon java

What is Saxon?

The Saxon package is a collection of tools for processing XML documents. The main components are:

  • An XSLT processor, which can be used from the command line, or invoked from an application, using a supplied API. Saxon implements the XSLT 3.0 Recommendation. The product can also be used to run XSLT 2.0 stylesheets, or XSLT 1.0 stylesheets in backwards compatibility mode.

  • An XPath processor accessible to applications via a supplied API. This supports XPath 2.0 and XPath 3.1. It can also be used in backwards-compatibility mode to evaluate XPath 1.0 expressions.

  • An XQuery processor that can be used from the command line, or invoked from an application by use of a supplied API. This supports XQuery 3.1, which also allows XQuery 1.0 or 3.0 queries to be executed. With Saxon-EE, you can also use the XQuery extensions defined in the XQuery Update 1.0 Recommendation, but later working drafts of XQuery Update are not supported (W3C has abandoned work on these versions).

  • An XML Schema Processor. This supports both XSD 1.0 and XSD 1.1. This can be used on its own to validate a schema for correctness, or to validate a source document against the definitions in a schema. It is also used to support the schema-aware functionality of the XSLT and XQuery processors. Like the other tools, it can be run from the command line, or invoked from an application.

  • On the Java platform, when using XSLT, XPath, XQuery, or XML schema validation, Saxon offers a choice of APIs. If you need portability across different vendors' tools, you can use the JAXP API for XSLT, XPath, and XML Schema processing, and the XQJ interface for XQuery. On the other hand, if you want a more integrated and complete API offering access to all Saxon's facilities, the s9api interface is recommended. You can also dive down deeper into the Saxon internals if you need to: there has been no particular attempt to make interfaces private, and all public interfaces are documented in the JavaDoc. Clearly, the deeper you go, the greater the risk of interfaces changing in future releases.

  • On the .NET platform, Saxon offers an API that enables close integration with other services available from .NET, notably the XML-related classes in the namespace. It isn't possible to use Saxon as a transparent plug-in replacement for the processor, because the API for the Microsoft engine using concrete classes rather than abstract interfaces. However, it is possible to use it as a functional replacement with minor changes to your application code.

Full details of Saxon's conformance to the specifications are provided in the Conformance section.

As well as features standardized by W3C, Saxon provides an extensive library of extensions, all implemented in conformance with the XSLT and XQuery Recommendations to ensure that portable stylesheets and queries can be written. These include the EXSLT extension libraries common, sets, math, and dates-and-times, and the EXPath modules binary, file, and archive. Many of these extensions were pioneered in Saxon and have since become available in other products.

These extension libraries in most cases require Saxon-PE or higher, and in some cases require Saxon-EE.

Some Saxon extensions are described in the documentation as experimental. This means that they may be withdrawn or redesigned in future releases, in response to feedback on their usability, performance, or reliability.
Sours: https://www.saxonica.com/html/documentation/about/whatis.html
Getting Started with XSLT and Saxon

Saxon XSLT

Saxon is an XSLT and XQuery processor created by Michael Kay and now developed and maintained by his company, Saxonica. There are open-source and also closed-source commercial versions. Versions exist for Java, JavaScript[1] and .NET.

The current version, as of May 2020, is 10.1.[2]

Versions[edit]

The original development line of Saxon ended with the version 6 series. This is a series of XSLT 1.0 processors. The current version, 6.5.5, is not undergoing further development aside from maintenance. The 6 series is only available for the Java programming language.

The current development line, Saxon 10, implements the XSLT 3.0 and XQuery 3.1 specifications. Saxon 10 is capable of processing XSLT 1.0 files as well. (XSLT 2.0 is highly backwards compatible with XSLT 1.0. [3])

From 2004 until 2009, Saxon was available into two separate forms: Saxon-B and Saxon-SA. Both of these were built on similar codebases. Saxon-B was open-source software released under the Mozilla Public License, while Saxon-SA was a closed-source commercial product.

The difference between Saxon-B and Saxon-SA was that B was "basic" while SA was "schema-aware". These terms are references to terms in the XSLT 2.0 and XQuery 1.0 specification. A processor that is "schema-aware" is able to use a W3C XML Schema to define the data types of the various elements in the source XML document(s). These data types can then be used in XPath 2.0 and XSLT 2.0 commands. A "basic" XSLT 2.0 processor is unable to use data typing information.

With the release of version 9.2 in August 2009, the packaging changed to create three versions: home edition (HE), professional edition (PE), and enterprise edition (EE). The home edition is open source and free, the other versions are available under commercial licenses. The renaming from SA to EE was done to emphasize that the commercial product by now included many additional features beyond schema awareness, including a more advanced optimizer and the capability for streamed processing of XSLT and XQuery, enabling very large source documents to be processed without correspondingly large amounts of memory.

Saxon offers strict conformance to the XSLT 2.0, XPath 2.0 and 3.0, and XQuery 1.0 and 3.0 W3C Recommendations, and also implements XML Schema 1.0 and 1.1. As of 2021 the current version (10.6) conforms with the W3C Recommendations for XSLT 3.0, XPath 3.1, and XQuery 3.1.

The Saxon source code is written in Java. During 2005-6 M., David Peterson and others demonstrated that Saxon could be cross-compiled to run on .NET using the IKVM.NET cross-compiler, launching Saxon.NET as a separate product independent of the original developer. With the release of Saxon 8.7, Saxonica adopted this technology and from that release onwards, all versions have been released simultaneously for Java and .NET. The .NET version of the product omits features that are specific to the Java platform (such as integration with JDOM, Dom4j, and XOM) and instead provides features that integrate with the XML processing capabilities of the .NET platform.

In 2012, following a series of prototypes, Saxonica released Saxon Client Edition (Saxon-CE), a version of the product adapted to run within the browser environment. This is achieved by adapting the Java source code so that it can be cross-compiled to Javascript using the GWT cross-compiler produced by Google. Saxon-CE provides the first implementation of XSLT 2.0 running on the browser, and also extends the language so that rather than merely generating HTML, it can directly handle user interaction. With the release of Saxon-CE 1.1 in February 2013, the product became open source. In February 2016 Michael Kay announced that Saxonica was working on a replacement for Saxon-CE written in pure Javascript, and dubbed Saxon-JS.[4]

Michael Kay, the author of Saxon, was the editor of the XSLT 2.0 specification and is also editor of the XSLT 3.0 draft.

Features[edit]

This table shows which features are available in the current versions of Saxon. The Java and .NET versions are built from a single codebase, so they share the same features. The suffixes *HE*, *PE*, *EE*, and *CE* refer to the Home, Professional, Enterprise, and Client Editions respectively: Saxon-HE and -CE are open source, while the -PE and -EE versions are available under a commercial license.

A more detailed and up-to-date feature matrix can be found on the Saxonica web site.

FeatureSaxon
6.5.5
(Java-only)

Saxon
HE 9.5
(Home Edition,
MPL-2.0)
Saxon
PE 9.5
(Professional Edition,
commercial)
Saxon
EE 9.5
(Enterprise Edition,
commercial)
Saxon
CE 1.1
(Client Edition,
JS-only, MPL-2.0)
XSLT 1.0 supportYesVia backward-compatible behaviorVia backward-compatible behaviorVia backward-compatible behaviorVia backward-compatible behavior
XSLT 2.0 support--YesYesYesYes
XSLT 3.0 support----YesYes--
XPath 1.0 supportYesVia XPath 1.0 compatibility modeVia XPath 1.0 compatibility modeVia XPath 1.0 compatibility modeOnly in XSLT
XPath 2.0 support--YesYesYesOnly in XSLT
XPath 3.0 support----YesYes--
XQuery 1.0 support--YesYesYes--
XQuery 3.0 support----YesYes--
XQueryX support----------
XQuery Updates 1.0 support----YesYes--
XQuery/XPath Full Text support----------
XML Schema 1.0 support------Yes--
XML Schema 1.1 support------Yes--
Serialization feature supportYesYesYesYes--
Static Typing feature support----------
xml:id 1.0 support--YesYesYesYes
XML stylesheet Processing Instruction supportYesYesYesYesvia XSLT 1.0 bootstrap stylesheet
Advanced extension functions----YesYes--
Advanced optimizer------Yes--
Streaming------Yes--
Bytecode Generation------Yes--

See also[edit]

References[edit]

External links[edit]

Sours: https://en.wikipedia.org/wiki/Saxon_XSLT

You will also like:

.



155 156 157 158 159