Each of the subdirectories in the Xalan-C++ samples directory contains the source files for a sample application.
With most of the samples, you can use the following procedure:
Note: Each sample application looks for input files in the current
directory, the directory from which you run the application. The
input files are in the samples subdirectory along with the sample
source files. The location of the sample executables may vary
depending upon the CMake generator used for building. They should
typically be located within the builddir/samples/<sample>. In all
cases, be sure the sample executable is on the PATH, and run it
from the samples subdirectory that contains the input files.
Note: The most of the samples are implemented without providing a pluggable memory manager. SimpleTransform sample illustrates, in addition to a simple transformation, the usage of the processor with memory manager.
Note: This sample must be built with the Apache Web server.
What it does: runs as an Apache module on an Apache Web server; performs transformations and returns the output to a Web browser. You configure Apache to respond to a given URL request for an output file (html or txt file in the configuration below) by applying an XSL stylesheet file to an XML document file (both with the specified name in a given location) and returning the transformation output to the client.
This sample also illustrates use of the
XalanTransformer
class and the C API defined in
xalanc/XalanTransformer/XalanCAPI.h.
It returns transformation output in blocks to a callback function,
which enables the browser to start displaying the result before the
transformation has been completed.
Note: You may need to configure CMake to locate the required Apache header files.
To use ApacheModuleXSLT, do the following:
LoadModule and (UNIX only) AddModule entries to the Apache
configuration file, httpd.conf.
Windows: LoadModule xslt_module Xalan-C_1_12_0;-<my_Windows_distribution>\bin\ApacheModuleXSLT.dll
UNIX: AddModule mod_xslt.c and
LoadModule xslt_module /usr/lib/apache/mod_xslt.<ref>xx</ref>
where <ref>xx</ref> is the appropriate library suffix for the
UNIX platform (“.so” or “.a”).<Location> entry to httpd.conf that indicates where
.xml and .xsl file pairs are to be found, and what target file
extensions to recognize. We suggest the following:
<Location /xslt>
AddHandler mod_xslt .html
AddHandler mod_xslt .txt
</Location>
This
For example, a request for *foo.html* instructs the module to apply
*foo.xsl* to *foo.xml* and return the result.
Note: It is up to the stylesheet to apply the appropriate
`xsl:output` method to the output. Whether the user specifies
`html` or `txt` is, of itself, immaterial.
<Location> subdirectory
(xslt in the example) under the document root directory specified
in httpd.conf by the DocumentRoot and <Directory> settings.
Alternatively, you can modify these settings to point to
samples/ApacheModuleXSLT, which includes an xslt subdirectory
with .xml and .xsl file pairs (foo.xml and foo.xsl,
apachemod.xml and apachemod.xsl).http://serverName/xslt/xxx.html
where serverName is the Apache server (such as www.myServer.com)
and xxx is the name of an XML/XSL pair of files (such as foo.xml
and foo.xsl) in the xslt subdirectory under the DocumentRoot
directory.http://www.myServer.com/xslt/apachemod.html
instructs ApacheModuleXSLT to apply the apachemod.xsl stylesheet
to the apachemod.xml XML document (both files in the xslt
directory under the Apache DocumentRoot directory) and return the
transformation result to the browser.What it does: Use a compiled stylesheet to perform a series of transformations.
You can run it from the CompileStylesheet subdirectory with
CompileStylesheet
See also: Performing a series of transformations.
What it does: Use a DocumentBuilder to programmatically construct an
XML document, apply the foo.xsl stylesheet to this document, and
write the ouput to foo.out.
You can run it from the DocumentBuilder subdirectory with
DocumentBuilder.
What it does: implement, install, and illustrate the usage of three extension functions. The functions return a square root, a cube, and a string with the current date and time. The sample stylesheet (foo.xsl) gets the area of a cube and units of measurement from an XML document (foo.xml), computes the length of each side of a cube and the volume of the cube, and enters the date and time of the transformation. The output appears in foo.out.
Run this sample from the ExternalFunction subdirectory with
ExternalFunction.
See also: Extension Functions.
What it does: performs a transformation with input in the form of a
pre-built XercesDOM or XalanSourceTree.
Run this sample from the ParsedSourceWrappers subdirectory with
ParsedSourceWrappers
See transformXercesDOM() and transformXalanSourceTree() as called
by transform() in ParsedSourceWrappers.cpp.
What it does: Serialize the node set returned by the application of an XPath expression to an XML document.
Run this sample from the SerializeNodeSet subdirectory with
SerializeNodeSet XMLFile ContextNode XPathExpression
where XMLFile is an XML source file, ContextNode is the location path to the context node, and XPathExpression is an XPath expression to apply to that context node. The SerializeNodeSet directory contains the same foo.xml sample source file as the preceding examples.
What it does: The SimpleTransform class uses the foo.xsl stylesheet
to transform foo.xml, and writes the output to foo.out. The source
for this sample has been modified to demonstrate the usage of the new
pluggable memory management feature.
You can run it from the SimpleTransform subdirectory with
SimpleTransform.
See also: Basic procedures for performing XSL transformations.
What it does: Use the XPathEvaluator interface to evaluate an XPath
expression from the specified context node of an XML file and display
the nodeset returned by the expression.
Note: You can use this sample as an aid when you want to find out what a given XPath expression returns from a given context node in an XML file.
Run this sample from the SimpleXPathAPI subdirectory with:
SimpleXPathAPI XMLFile ContextNode XPathExpression
where XMLFile is an XML source file, ContextNode is the location path to the context node, and XPathExpression is an XPath expression to apply to that context node.
Keep in mind that the string value returned by an XPath expression is the string value of the first node in the nodeset returned by the expresssion.
The XPathWrapper subdirectory contains an XML file named xml.foo (part of it appears below).
<?xml version="1.0"?>
<doc>
<name first="David" last="Marston">Mr. Marson</name>
<name first="David" last="Bertoni">Mr. Bertoni</name>
…
<name first="Paul" last="Dick">Mr. Dick</name>
</doc>
You can try command lines like
SimpleXPathAPI foo.xml /foo:doc foo:name/@last
and
SimpleXPathAPI foo.xml / '//foo:name[position()="4"]/@first'
Note: If a SimpleXPathAPI argument includes characters (such as *)
that the shell interprets incorrectly, enclose the argument in double
quotes.
See also: Working with XPath expressions.
What it does: Use the
XPathEvaluator
C interface to evaluate an XPath expression and display the string
value returned by the expression.
Note: Keep in mind that the string value returned by an XPath expression is the string value of the first node in the nodeset returned by the expresssion.
Run this sample from the SimpleXPathCAPI subdirectory with:
SimpleXPathCAPI XMLFile XPathExpression
where XMLFile is an XML source file, and XPathExpression is an XPath expression to apply to the XML source file. The SimpleXPathCAPI subdirectory contains an XML file named foo.xml similar to the foo.xml in the preceding example.
You can try command lines like:
SimpleXPathCAPI foo.xml /doc/name[3]
What it does: The StreamTransform class processes character input
streams containing a stylesheet and an XML document, and writes the
transformation output to a character output stream. This sample
illustrates the process for working with stylesheets and documents
that you assemble in memory.
You can run it from the SimpleTransform subdirectory with StreamTransform.
What it does: Multiple threads use a single compiled stylesheet
(StylesheetRoot) and DOM source tree (XalanNode) to perform
transformations concurrently. The application tracks the progress of
the threads in messages to the console, and each thread writes its own
output file. Imagine a server application responding to multiple
clients who happen to request the same transformation.
You can run it from the ThreadSafe subdirectory with ThreadSafe.
See also: Performing a series of transformations.
What it does: Trace events during a transformation; the transformation uses birds.xsl to transform birds.xml and writes the output to birds.out.
You can run it from the TraceListen subdirectory with:
TraceListen traceFlags
where traceFlags is one or more of the following:
These flags are also available in the command-line utility (TestXSLT).
The core of this example is the following fragment:
// Set up a diagnostic writer to be used by the TraceListener…
XalanStdOutputStream theStdErr(cerr);
XalanOutputStreamPrintWriter diagnosticsWriter(theStdErr);
// Make sure that error reporting, which includes any TraceListener
// output does not throw exceptions when transcoding, since that could
// result in an exception being thrown while another exception is active.
// In particular, characters that the TraceListener writes might not be
// representable in the local code page.
theStdErr.setThrowTranscodeException(false);
// Set up the TraceListener…
// traceTemplates, traceTemplateChildren, traceGenerationEvent,
// and TraceSelectionEvent are booleans set by the command line.
TraceListenerDefault theTraceListener(
diagnosticsWriter,
traceTemplates,
traceTemplateChildren,
traceGenerationEvent,
traceSelectionEvent);
// Add the TraceListener to the XSLT processor…
theProcessor.setTraceSelects(traceSelectionEvent);
theProcessor.addTraceListener(&theTraceListener);
// Perform the transformation
…
What it does: Performs a simple transformation but puts the result in a
Xerces DOMDocument
Run this sample from the TransformToXercesDOM subdirectory with:
TransformToXercesDOM XMLFile XSLFile
where XMLFile is a source XML file, and XSLFile is the XSLT input file. The program will use XSLFile to transform the input file XMLFile using Xerces DOM as the output destination.
See the FormatterToXercesDOM usage in the sample code.
What it does: Performs a transformation using top-level stylesheet parameters. There are three supported types of parameters. One is a text string. A second is a number of type double. A nodeset or parsed document can also be used.
You can run it from the UseStylesheetParam subdirectory with:
UseStylesheetParam xmlfile stylesheet outfile [options]
where the options are:
The files used by the sample program and the top-level parameter nodesets for this illustration are to be in working directory in which the sample program runs.
Using the sample program:
UseStylesheetParam foo.xml foo.xslt foo.out \
-s stringA "'This is a test string value'" \
-n numberA 123.012345 \
-d parmA "parmA.xml" \
-d parmB "parmB.xml"
The parmA.xml and parmB.xml files are parsed and converted to
nodesets. The stylesheet foo.xslt merges the contents of foo.xml
and the parameters into the foo.out file.
The source sample is implemented in C++. Another example is implemented in ‘C’ using the XalanCAPI library, TestCAPIparm.c. The usage interface for both is the same.
See also: Setting stylesheet parameters.
What it does: XalanTransform uses the
XalanTransformer
class and the associated C++ API to apply an XSL stylesheet file to an
XML document file and write the transformation output to either an
output file or to a stream.
XalanTransform takes command-line arguments for the XML document to
be transformed, the XSL stylesheet to apply, and an optional output
file argument. If you omit the third argument, XalanTransform writes
the transformation output to a stream that is sent to standard out (the
console).
You can run XalanTransform from the XalanTransform subdirectory
with:
XalanTransform foo.xml foo.xsl foo.out
Omit the third argument to write the transformation result to the console.
See also: Using the XalanTransformer class.
What it does: Return transformation output in blocks to a callback function, which writes the output to a file. This sample illustrates the use of a callback function to incrementally process a transformation result, that is to begin working with the transformation result before the transformation has been completed. See Processing output incrementally.
You can run it from the XalanTransformerCallback subdirectory with:
XalanTransformerCallback foo.xml foo.xsl [foo.out]
Note: If you omit the third argument, the transformation result is written to the console.