Project

Profile

Help

How to connect?
Download (121 KB) Statistics
| Branch: | Tag: | Revision:

he / latest9.9 / hen / csource / api / Saxon.Api / Feature.cs @ a2e6e9df

1

    
2
using System;
3

    
4
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
5

    
6
namespace Saxon.Api 
7
{
8

    
9

    
10
/// <summary>
11
/// Feature defines a set of constants, representing the details of Saxon configuration
12
/// options which can be supplied to the Saxon method <c>Processor.SetProperty()</c>,
13
/// and to other interfaces.
14
/// </summary>
15

    
16
public class Feature<T> {
17
    
18
    private net.sf.saxon.lib.Feature jfeature;
19

    
20
    private Feature(String name) {
21
        jfeature = net.sf.saxon.lib.Feature.byName(name);
22
    }
23
    
24
    private Feature(net.sf.saxon.lib.Feature jf) {
25
        this.jfeature = jf;
26
    }
27
    
28
    /// <summary>
29
    /// Get the <c>Feature</c> object by string value name
30
    /// </summary>
31
    /// <param name="name">The feature name</param>
32
    /// <returns>The <c>Feature</c> object</returns>
33

    
34
    public static Feature<T> byName(String name) {
35
        return new Feature<T>(name);
36
    }
37
    
38
    /// <summary>
39
	/// The underlying <c>net.sf.saxon.lib.Feature</c> object in the Java implementation
40
    /// </summary>
41
    /// <remarks>
42
    /// <para>This property provides access to the internal Java <c>Feature</c> object in the 
43
    /// Saxon engine that is wrapped in the .NET API.</para> 
44
	/// <para>Information about the returned <see cref="net.sf.saxon.lib.Feature"/> object 
45
	/// is included in the Saxon JavaDoc docmentation.
46
    /// </para>
47
    /// </remarks>
48
        
49
	public net.sf.saxon.lib.Feature JFeature
50
    {
51
        get { return jfeature; }
52
    }
53

    
54

    
55

    
56
    /// <summary><para>ALLOW_EXTERNAL_FUNCTIONS determines whether calls to reflexive external functions are
57
    ///                allowed.</para>
58
    /// </summary>
59
    /// <remarks>
60
    ///            <para>More specifically, if set to <b>false</b> it disallows all of the
61
    ///                following:</para>
62
    ///            <list>
63
    ///                <item>Calls to reflexive Java extension functions</item>
64
    ///                <item>Use of the XSLT <code>system-property()</code> function to access Java system
65
    ///                    properties</item>
66
    ///                <item>Use of a URI in the <code>href</code> attribute of an <code>xsl:result-document</code> instruction</item>
67
    ///                <item>Calls to XSLT extension instructions</item>
68
    ///            </list>
69
    ///            <para>The default value is <b>true</b>. The setting <b>false</b> is recommended in an
70
    ///                environment where untrusted stylesheets may be executed.</para>
71
    ///            <para>This option does not disable use of the <code>doc()</code> function or similar
72
    ///                functions to access the filestore of the machine where the transformation or query
73
    ///                is running. That should be done using a user-supplied <code>URIResolver</code>.</para>
74
    ///            <para>Note that integrated extension functions are trusted; calls to such functions are
75
    ///                allowed even if this configuration option is false. In cases where an integrated
76
    ///                extension function is used to load and execute untrusted code, it should check this
77
    ///                configuration option before doing so.</para>
78
    ///            <para>If the value of the property is false, then it will also be set to false on any new
79
    ///            Configuration created using the <code>fn:transform()</code> function.</para>
80
    ///        
81
    /// </remarks>
82

    
83
    public static Feature<bool> ALLOW_EXTERNAL_FUNCTIONS = new Feature<bool>(
84
            net.sf.saxon.lib.Feature.ALLOW_EXTERNAL_FUNCTIONS);
85

    
86
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
87

    
88

    
89
    /// <summary><para>ALLOW_MULTITHREADING determines whether multi-threading is allowed.</para>
90
    /// </summary>
91
    /// <remarks>
92
    ///            <para>If true (the default), the presence of the attribute <code>saxon:threads="N"</code>
93
    ///                on an <code>xsl:for-each</code> instruction, when running under Saxon-EE, causes
94
    ///                multi-threaded execution. If set to false, the value of the
95
    ///                    <code>saxon:threads</code> argument is ignored.</para>
96
    ///            <para>Setting the value to false also disables asynchronous processing of
97
    ///                    <code>xsl:result-document</code> instructions.</para>
98
    ///            <para>The default value is true if Saxon-EE is in use, false otherwise.</para>
99
    ///        
100
    /// </remarks>
101

    
102
    public static Feature<bool> ALLOW_MULTITHREADING = new Feature<bool>(
103
            net.sf.saxon.lib.Feature.ALLOW_MULTITHREADING);
104

    
105
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
106

    
107

    
108
    /// <summary><para>ALLOW_OLD_JAVA_URI_FORMAT determines whether extension function calls to
109
    ///                dynamically-loaded Java extension functions may use the URI format supported in
110
    ///                older Saxon releases.</para>
111
    /// </summary>
112
    /// <remarks>
113
    ///            <para>If the value is false (the default), the only URI format accepted is (for example)
114
    ///                "java:java.util.Date" - that is, a URI consisting of the string "java:" followed by
115
    ///                the Java qualified class name of the class containing the implementation of the
116
    ///                extension function.</para>
117
    ///            <para>If the value is true, then in addition to this format, the following are accepted:
118
    ///                (a) the Java class name on its own ("java.util.Date"), and (b) any URI in which the
119
    ///                Java class name follows the last "/" character (for example
120
    ///                "http://my.com/extensions/java.util.Date"). This last format was originally provided
121
    ///                for compatibility with xt and xalan, but it causes problems because it leads to
122
    ///                unnecessary attempts to load spurious classes when the user did not intend the URI
123
    ///                to represent a dynamically-loaded Java class.</para>
124
    ///        
125
    /// </remarks>
126

    
127
    public static Feature<bool> ALLOW_OLD_JAVA_URI_FORMAT = new Feature<bool>(
128
            net.sf.saxon.lib.Feature.ALLOW_OLD_JAVA_URI_FORMAT);
129

    
130
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
131

    
132

    
133
    /// <summary><para>This flag must be set to enable use of extensions to XPath (and potentially XQuery and XSLT)
134
    ///                syntax that go beyond what is allowed by the extensibility mechanisms in the spec.
135
    ///                In some cases these extensions are experimental and may not be carried forward to future
136
    ///            Saxon releases.</para>
137
    /// </summary>
138
    /// <remarks>
139
    ///            <para>Syntax extensions in Saxon 9.8 include the use of type aliases (<code>~aliasName</code> where
140
    ///                an item type is expected, and <code>declare type NAME = item-type</code> in the XQuery Prolog); 
141
    ///                and simple inline functions (for example <code>fn{. + 1}</code>).</para>
142
    ///        
143
    /// </remarks>
144

    
145
    public static Feature<bool> ALLOW_SYNTAX_EXTENSIONS = new Feature<bool>(
146
            net.sf.saxon.lib.Feature.ALLOW_SYNTAX_EXTENSIONS);
147

    
148
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
149

    
150

    
151
    /// <summary><para>ASSERTIONS_CAN_SEE_COMMENTS determines whether comment and processing instructions in
152
    ///                a document being validated are visible to assertions in an XSD 1.1 schema.</para>
153
    /// </summary>
154
    /// <remarks>
155
    ///            <para>If the value is false (the default), comments and processing instructions are
156
    ///                stripped from the view of the document that is made visible to the XPath expression
157
    ///                that implements the assertion. If this creates adjacent text nodes, they are
158
    ///                collapsed into a single text node.</para>
159
    ///            <para>If the value is true, then comments and processing instructions are visible to the
160
    ///                XPath assertion.</para>
161
    ///        
162
    /// </remarks>
163

    
164
    public static Feature<bool> ASSERTIONS_CAN_SEE_COMMENTS = new Feature<bool>(
165
            net.sf.saxon.lib.Feature.ASSERTIONS_CAN_SEE_COMMENTS);
166

    
167
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
168

    
169

    
170
    /// <summary><para>The supplied <code>CollationURIResolver</code> is used to process any collation URIs
171
    ///                found in the query or stylesheet, returning an object of class
172
    ///                    <see cref="net.sf.saxon.lib.StringCollator" /> that implements the requested
173
    ///                collation.</para>
174
    /// </summary>
175

    
176
    public static Feature<net.sf.saxon.lib.CollationURIResolver> COLLATION_URI_RESOLVER = new Feature<net.sf.saxon.lib.CollationURIResolver>(
177
            net.sf.saxon.lib.Feature.COLLATION_URI_RESOLVER);
178

    
179
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
180

    
181

    
182
    /// <summary><para>The supplied class is instantiated and the resulting instance is used as the value of
183
    ///                the <see cref="COLLATION_URI_RESOLVER" /> property.</para>
184
    /// </summary>
185

    
186
    public static Feature<String> COLLATION_URI_RESOLVER_CLASS = new Feature<String>(
187
            net.sf.saxon.lib.Feature.COLLATION_URI_RESOLVER_CLASS);
188

    
189
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
190

    
191

    
192
    /// <summary><para>The supplied <code>CollectionFinder</code> is used to retrieve a <see cref="net.sf.saxon.lib.ResourceCollection" /> object given by any URI defined in
193
    ///                calls to the <code>collection()</code> or the <code>uri-collection()</code> function.</para>
194
    /// </summary>
195
    /// <remarks>
196
    ///            <para>If the argument is not specified then a default <code>ResourceCollection</code> should be handled.
197
    ///                <code>CollectionFinder</code> returns a <see cref="net.sf.saxon.lib.ResourceCollection" /> which is used to map the URI of collection into a
198
    ///                sequence of <see cref="net.sf.saxon.lib.Resource" /> objects
199
    ///                (which are then resolved in the same way as URIs passed to the <code>doc()</code>
200
    ///                function), or it may return an item (typically a node but can handle JSON documents).</para>
201
    ///        
202
    /// </remarks>
203

    
204
    public static Feature<net.sf.saxon.lib.CollectionFinder> COLLECTION_FINDER = new Feature<net.sf.saxon.lib.CollectionFinder>(
205
            net.sf.saxon.lib.Feature.COLLECTION_FINDER);
206

    
207
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
208

    
209

    
210
    /// <summary><para>The supplied class is instantiated and the resulting instance is used as the value of
211
    ///                the <see cref="COLLECTION_FINDER" /> property.</para>
212
    /// </summary>
213

    
214
    public static Feature<String> COLLECTION_FINDER_CLASS = new Feature<String>(
215
            net.sf.saxon.lib.Feature.COLLECTION_FINDER_CLASS);
216

    
217
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
218

    
219

    
220
    /// <summary><para>The supplied <code>CollectionURIResolver</code> is used to process any URIs used in
221
    ///                calls to the <code>collection()</code> function. The
222
    ///                    <code>CollectionURIResolver</code> may either return a sequence of URIs (which
223
    ///                are then resolved in the same way as URIs passed to the <code>doc()</code>
224
    ///                function), or it may return a sequence of (typically document) nodes.</para>
225
    /// </summary>
226

    
227
    public static Feature<net.sf.saxon.lib.CollectionURIResolver> COLLECTION_URI_RESOLVER = new Feature<net.sf.saxon.lib.CollectionURIResolver>(
228
            net.sf.saxon.lib.Feature.COLLECTION_URI_RESOLVER);
229

    
230
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
231

    
232

    
233
    /// <summary><para>The supplied class is instantiated and the resulting instance is used as the value of
234
    ///                the <see cref="COLLECTION_URI_RESOLVER" /> property.</para>
235
    /// </summary>
236

    
237
    public static Feature<String> COLLECTION_URI_RESOLVER_CLASS = new Feature<String>(
238
            net.sf.saxon.lib.Feature.COLLECTION_URI_RESOLVER_CLASS);
239

    
240
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
241

    
242

    
243
    /// <summary><para>If run-time tracing of stylesheet or query execution is required, then the code must
244
    ///                be compiled with tracing enabled.</para>
245
    /// </summary>
246
    /// <remarks>
247
    ///            <para>Default is false. This option causes code to be
248
    ///                compiled that makes calls to a <see cref="net.sf.saxon.lib.TraceListener" />, but this
249
    ///                has no effect unless a <code>TraceListener</code> is registered at execution
250
    ///                time.</para>
251
    ///        
252
    /// </remarks>
253

    
254
    public static Feature<bool> COMPILE_WITH_TRACING = new Feature<bool>(
255
            net.sf.saxon.lib.Feature.COMPILE_WITH_TRACING);
256

    
257
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
258

    
259

    
260
    /// <summary><para>This attribute cannot be set on the <see cref="net.sf.saxon.Configuration" /> itself,
261
    ///                but it can be set on various JAXP factory objects such as a
262
    ///                <code>TransformerFactory</code> or <code>DocumentBuilderFactory</code>, to
263
    ///                ensure that several such factories use the same <code>Configuration</code>.</para>
264
    /// </summary>
265
    /// <remarks>
266
    ///            <para>Note that other configuration options are held in the <code>Configuration</code> object,
267
    ///                so setting this attribute will cancel all others that have been set. Also, if two
268
    ///                factories share the same <code>Configuration</code>, then setting an attribute on
269
    ///                one affects all the others.</para>
270
    ///        
271
    /// </remarks>
272

    
273
    public static Feature<net.sf.saxon.Configuration> CONFIGURATION = new Feature<net.sf.saxon.Configuration>(
274
            net.sf.saxon.lib.Feature.CONFIGURATION);
275

    
276
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
277

    
278

    
279
    /// <summary><para>Defines a configuration file to be applied to the configuration.</para>
280
    /// </summary>
281
    /// <remarks>
282
    ///            <para>This attribute cannot be set on the <see cref="net.sf.saxon.Configuration" /> itself, but it can be
283
    ///                set on various JAXP factory objects such as a <code>TransformerFactory</code> or
284
    ///                    <code>DocumentBuilderFactory</code>. It is particularly useful when running
285
    ///                transformations via the Ant xslt task, where it can be set as follows to define all
286
    ///                configuration settings: </para>
287
    ///            <para><code>&lt;factory name="net.sf.saxon.TransformerFactoryImpl"&gt; &lt;attribute
288
    ///                    name="http://saxon.sf.net/feature/configuration-file"
289
    ///                    value="c:/saxon/config.xml"/&gt; &lt;/factory&gt;</code>
290
    ///            </para>
291
    ///        
292
    /// </remarks>
293

    
294
    public static Feature<String> CONFIGURATION_FILE = new Feature<String>(
295
            net.sf.saxon.lib.Feature.CONFIGURATION_FILE);
296

    
297
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
298

    
299

    
300
    /// <summary><para>This option is set to indicate that bytecode generation should be run in debugging
301
    ///                mode; it injects diagnostic tracing calls into the generated bytecode. This should
302
    ///                be used only if requested by Saxonica support to diagnose a problem related to
303
    ///                bytecode generation.</para>
304
    /// </summary>
305

    
306
    public static Feature<bool> DEBUG_BYTE_CODE = new Feature<bool>(
307
            net.sf.saxon.lib.Feature.DEBUG_BYTE_CODE);
308

    
309
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
310

    
311

    
312
    /// <summary><para>This option is relevant only if <code>DISPLAY_BYTE_CODE</code> is set to true. It
313
    ///                defines a directory to which files containing bytecode in human-readable form will
314
    ///                be written. There will be one such file for each generated class, with a filename
315
    ///                designed to give some kind of clue as to its relationship to the source code.</para>
316
    /// </summary>
317
    /// <remarks>
318
    ///            <para>The default value is the directory <code>saxonByteCode</code> within the current
319
    ///                working directory.</para>
320
    ///            <para>The named directory is created if it does not already exist.</para>
321
    ///            <para>Because the generation of class names involves random numbers, files will tend to
322
    ///                accumulate in the supplied directory, even when the same source code is compiled
323
    ///                repeatedly.</para>
324
    ///        
325
    /// </remarks>
326

    
327
    public static Feature<String> DEBUG_BYTE_CODE_DIR = new Feature<String>(
328
            net.sf.saxon.lib.Feature.DEBUG_BYTE_CODE_DIR);
329

    
330
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
331

    
332

    
333
    /// <summary><para>This option determines the collation that is used for comparing strings when no
334
    ///                explicit collation is requested. It is not necessary for this collation to exist (or
335
    ///                to have been registered) when setting this option; it only needs to exist by the
336
    ///                time it is used.</para>
337
    /// </summary>
338
    /// <remarks>
339
    ///            <para>In XSLT it is possible to override this setting using the
340
    ///                    <code>[xsl:]default-collation</code> attribute on any stylesheet element. In
341
    ///                XQuery, it can be overridden using the <code>declare default collation</code>
342
    ///                declaration in the query prolog, or via a setter method in class
343
    ///                    <see cref="net.sf.saxon.query.StaticQueryContext" />.</para>
344
    ///            <para>If no value is specified, the Unicode codepoint collation is used.</para>
345
    ///        
346
    /// </remarks>
347

    
348
    public static Feature<String> DEFAULT_COLLATION = new Feature<String>(
349
            net.sf.saxon.lib.Feature.DEFAULT_COLLATION);
350

    
351
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
352

    
353

    
354
    /// <summary><para>This determines the collection that is used when the <code>fn:collection()</code>
355
    ///                function is called with no arguments; the effect is the same as if it were called
356
    ///                passing the URI that is the value of this configuration property.</para>
357
    /// </summary>
358

    
359
    public static Feature<String> DEFAULT_COLLECTION = new Feature<String>(
360
            net.sf.saxon.lib.Feature.DEFAULT_COLLECTION);
361

    
362
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
363

    
364

    
365
    /// <summary><para>This determines the country that is used by <code>format-date()</code> and similar
366
    ///                functions if no country code is supplied explicitly. If no value is given for this
367
    ///                property, the default is taken from the Java Locale, which in turn typically depends
368
    ///                on settings for the current user in the operating system.</para>
369
    /// </summary>
370

    
371
    public static Feature<String> DEFAULT_COUNTRY = new Feature<String>(
372
            net.sf.saxon.lib.Feature.DEFAULT_COUNTRY);
373

    
374
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
375

    
376

    
377
    /// <summary><para>This option determines the language that is used by <code>format-date()</code>,
378
    ///                    <code>xsl:number</code> and similar constructs if no language code is supplied
379
    ///                explicitly. If no value is given for this property, the default is taken from the
380
    ///                Java Locale, which in turn typically depends on settings for the current user in the
381
    ///                operating system.</para>
382
    /// </summary>
383

    
384
    public static Feature<String> DEFAULT_LANGUAGE = new Feature<String>(
385
            net.sf.saxon.lib.Feature.DEFAULT_LANGUAGE);
386

    
387
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
388

    
389

    
390
    /// <summary><para>Determines which regular expression engine should be used for evaluating regular expressions occuring in constructs
391
    ///            such as <code>fn:matches()</code>, <code>fn:replace</code>, and <code>xsl:analyze-string</code>, and also
392
    ///            in the pattern facet of a schema.</para>
393
    /// </summary>
394
    /// <remarks>
395
    ///            <para>On the Java platform the permitted values are "S" (default), and "J". The value "J" selects the regex engine
396
    ///            provided in the JDK in preference to the Saxon regular expression engine. This means that regular expressions must
397
    ///            follow the Java syntax and semantics rather than the XPath syntax and semantics.</para>
398
    ///            <para>On the .NET platform the permitted values are "S" (default), "J", and "N". The value "J" selects the regex engine
399
    ///                provided in the IKVMC run-time, which is derived from OpenJDK. The value "N" selects the regex engine provided
400
    ///            in the Microsoft .NET platform. In each case, the regular expression must follow the syntax and semantics of the selected
401
    ///            regex engine.</para>
402
    ///            <para>The choice of regular expression may be overridden in a particular invocation by appending the value ";s",
403
    ///            ";j", or ";n" to the flags argument of the relevant call. (This does not apply to XSD patterns, where no flags argument is available)</para>
404
    ///            <para>Use of this feature is not conformant with W3C specifications. Use of the setting "N", however, can be useful
405
    ///            when schemas have been written with the Microsoft schema processor in mind, since this uses the Microsoft regular
406
    ///            expression dialect rather than the W3C dialect.</para>
407
    ///        
408
    /// </remarks>
409

    
410
    public static Feature<String> DEFAULT_REGEX_ENGINE = new Feature<String>(
411
            net.sf.saxon.lib.Feature.DEFAULT_REGEX_ENGINE);
412

    
413
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
414

    
415

    
416
    /// <summary><para>This option disables the <code>xsl:evaluate</code> instruction.</para>
417
    /// </summary>
418
    /// <remarks>
419
    ///            <para>If set at stylesheet compile time, the feature is statically disabled. If set at 
420
    ///                run-time it is dynamically disabled. (These terms are defined in the XSLT 3.0 spec.) 
421
    ///                The feature is always disabled (statically) in Saxon-HE.</para>
422
    ///        
423
    /// </remarks>
424

    
425
    public static Feature<bool> DISABLE_XSL_EVALUATE = new Feature<bool>(
426
            net.sf.saxon.lib.Feature.DISABLE_XSL_EVALUATE);
427

    
428
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
429

    
430

    
431
    /// <summary><para>This option is set to indicate that bytecode generation should be run in display
432
    ///                mode. The effect is to output files (one per class) containing a human-readable
433
    ///                print of the generated bytecode. The files are placed in the directory identified by
434
    ///                the <code>DEBUG_BYTE_CODE_DIR</code> option.</para>
435
    /// </summary>
436

    
437
    public static Feature<bool> DISPLAY_BYTE_CODE = new Feature<bool>(
438
            net.sf.saxon.lib.Feature.DISPLAY_BYTE_CODE);
439

    
440
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
441

    
442

    
443
    /// <summary><para>If true, the XML parser is requested to perform validation of source documents
444
    ///                against their DTD. Default is false.</para>
445
    /// </summary>
446
    /// <remarks>
447
    ///            <para>This option establishes a default for use whenever source documents (not stylesheets
448
    ///                or schema documents) are parsed. The option can be overridden for individual
449
    ///                documents by setting the <see cref="net.sf.saxon.lib.ParseOptions" /> for that
450
    ///                individual document, for example from a <code>URIResolver</code>.</para>
451
    ///        
452
    /// </remarks>
453

    
454
    public static Feature<bool> DTD_VALIDATION = new Feature<bool>(
455
            net.sf.saxon.lib.Feature.DTD_VALIDATION);
456

    
457
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
458

    
459

    
460
    /// <summary><para>This option determines whether DTD validation failures should be treated as
461
    ///                recoverable. If the option is set, a validation failure is reported as a warning
462
    ///                rather than an error. The default is false.</para>
463
    /// </summary>
464
    /// <remarks>
465
    ///            <para>This option establishes a default for use whenever source documents (not stylesheets
466
    ///                or schema documents) are parsed. The option can be overridden for individual
467
    ///                documents by setting the <see cref="net.sf.saxon.lib.ParseOptions" /> for that
468
    ///                individual document, for example from a <code>URIResolver</code>.</para>
469
    ///        
470
    /// </remarks>
471

    
472
    public static Feature<bool> DTD_VALIDATION_RECOVERABLE = new Feature<bool>(
473
            net.sf.saxon.lib.Feature.DTD_VALIDATION_RECOVERABLE);
474

    
475
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
476

    
477

    
478
    /// <summary><para>Forces Saxon to do eager evaluation of expressions in contexts where normally it would do lazy evaluation,
479
    ///                for example when evaluating variables and function results. This can make for easier debugging.</para>
480
    /// </summary>
481
    /// <remarks>
482
    ///            <para>Note that this only applies to situations where Saxon would normally save a <code>Closure</code>
483
    ///            object as the result of an expression. It does not prevent Saxon from using pipelined evaluation of
484
    ///            intermediate expressions using iterators.</para>
485
    ///        
486
    /// </remarks>
487

    
488
    public static Feature<bool> EAGER_EVALUATION = new Feature<bool>(
489
            net.sf.saxon.lib.Feature.EAGER_EVALUATION);
490

    
491
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
492

    
493

    
494
    /// <summary><para>The supplied class is instantiated and the resulting <code>EntityResolver</code> is
495
    ///                used whenever Saxon itself creates an <code>XMLReader</code> for parsing source
496
    ///                documents. It is not used with a user-supplied <code>XMLReader</code>.</para>
497
    /// </summary>
498
    /// <remarks>
499
    ///            <para>The default value is <see cref="net.sf.saxon.lib.StandardEntityResolver" />. This is an entity
500
    ///                resolver that recognizes the names of many standard W3C DTDs and external entity
501
    ///                files, and resolves them against local copies issued with the Saxon software, to
502
    ///                avoid the need to fetch them from the web.</para>
503
    ///            <para>The property can be set to a zero-length string, in which case no
504
    ///                    <code>EntityResolver</code> will be used.</para>
505
    ///
506
    ///        
507
    /// </remarks>
508

    
509
    public static Feature<String> ENTITY_RESOLVER_CLASS = new Feature<String>(
510
            net.sf.saxon.lib.Feature.ENTITY_RESOLVER_CLASS);
511

    
512
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
513

    
514

    
515
    /// <summary><para>Setting the <code>ENVIRONMENT_VARIABLE_RESOLVER</code> causes the supplied object to
516
    ///                be registered as the environment variable resolver for the
517
    ///                    <code>Configuration</code>. The setting is global: it affects all queries and
518
    ///                transformations using this configuration.</para>
519
    /// </summary>
520
    /// <remarks>
521
    ///            <para>The environment variable resolver is used when the XPath functions
522
    ///                    <code>available-environment-variables()</code> or
523
    ///                    <code>environment-variable()</code> are called. Saxon essentially delegates the
524
    ///                evaluation of the function to the external resolver.</para>
525
    ///        
526
    /// </remarks>
527

    
528
    public static Feature<net.sf.saxon.lib.EnvironmentVariableResolver> ENVIRONMENT_VARIABLE_RESOLVER = new Feature<net.sf.saxon.lib.EnvironmentVariableResolver>(
529
            net.sf.saxon.lib.Feature.ENVIRONMENT_VARIABLE_RESOLVER);
530

    
531
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
532

    
533

    
534
    /// <summary><para>Setting <code>ENVIRONMENT_VARIABLE_RESOLVER_CLASS</code> causes an instance of the
535
    ///                supplied class to be created, and registered as the environment variable resolver
536
    ///                for the <code>Configuration</code>. The setting is global: it affects all queries
537
    ///                and transformations using this configuration.</para>
538
    /// </summary>
539
    /// <remarks>
540
    ///            <para>The environment variable resolver is used when the XPath functions
541
    ///                    <code>available-environment-variables()</code> or
542
    ///                    <code>environment-variable()</code> are called. Saxon essentially delegates the
543
    ///                evaluation of the function to the external resolver.</para>
544
    ///        
545
    /// </remarks>
546

    
547
    public static Feature<String> ENVIRONMENT_VARIABLE_RESOLVER_CLASS = new Feature<String>(
548
            net.sf.saxon.lib.Feature.ENVIRONMENT_VARIABLE_RESOLVER_CLASS);
549

    
550
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
551

    
552

    
553
    /// <summary><para><code>ERROR_LISTENER_CLASS</code> is the name of the class used to implement the JAXP
554
    ///                <code>ErrorListener</code>. This is used both at compile time and at run-time.</para>
555
    /// </summary>
556
    /// <remarks>
557
    ///            <para>Currently if this option is specified, the class is instantiated, and the same
558
    ///                instance is used for all processes running under this configuration. This may change
559
    ///                in future so that a new instance is created for each compilation or evaluation.</para>
560
    ///            <para>Finer control can be obtained by setting the <code>ErrorListener</code> for a
561
    ///                specific XSLT or XQuery compilation or evaluation.</para>
562
    ///        
563
    /// </remarks>
564

    
565
    public static Feature<String> ERROR_LISTENER_CLASS = new Feature<String>(
566
            net.sf.saxon.lib.Feature.ERROR_LISTENER_CLASS);
567

    
568
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
569

    
570

    
571
    /// <summary><para><code>EXPAND_ATTRIBUTE_DEFAULTS</code> determines whether fixed and default values
572
    ///                defined in a schema or DTD will be expanded (both on input and on output documents,
573
    ///                if validation is requested).</para>
574
    /// </summary>
575
    /// <remarks>
576
    ///            <para>By default (and for conformance with the specification)
577
    ///                validation against a DTD or schema will cause default values defined in the schema
578
    ///                or DTD to be inserted into the document. Setting this feature to false suppresses
579
    ///                this behavior. In the case of DTD-defined defaults this only works if the XML parser
580
    ///                reports whether each attribute was specified in the source or generated by expanding
581
    ///                a default value. Not all XML parsers report this information.</para>
582
    ///        
583
    /// </remarks>
584

    
585
    public static Feature<bool> EXPAND_ATTRIBUTE_DEFAULTS = new Feature<bool>(
586
            net.sf.saxon.lib.Feature.EXPAND_ATTRIBUTE_DEFAULTS);
587

    
588
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
589

    
590

    
591
    /// <summary><para><code>EXPATH_FILE_DELETE_TEMPORARY_FILES</code> determines whether temporary files
592
    ///                and directories created in the EXPath File module should be automatically deleted on
593
    ///                closure of the JVM.</para>
594
    /// </summary>
595
    /// <remarks>
596
    ///            <para>The default value is <b>false</b>, to align with the standard. The setting
597
    ///                    <b>false</b> is recommended when external 'sweep-up' features aren't
598
    ///                available.</para>
599
    ///        
600
    /// </remarks>
601

    
602
    public static Feature<bool> EXPATH_FILE_DELETE_TEMPORARY_FILES = new Feature<bool>(
603
            net.sf.saxon.lib.Feature.EXPATH_FILE_DELETE_TEMPORARY_FILES);
604

    
605
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
606

    
607

    
608
    /// <summary><para>By default, Saxon-EE attempts to generate Java bytecode for evaluation of parts of a
609
    ///                query or stylesheet that are amenable to such treatment. Setting this option to
610
    ///                false disables this.</para>
611
    /// </summary>
612

    
613
    public static Feature<bool> GENERATE_BYTE_CODE = new Feature<bool>(
614
            net.sf.saxon.lib.Feature.GENERATE_BYTE_CODE);
615

    
616
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
617

    
618

    
619
    /// <summary><para>If this option is set to true, then when a <code>SAXSource</code> is supplied as the
620
    ///                input to an XSLT transformation, Saxon will ignore the <code>XMLReader</code>
621
    ///                supplied in the <code>SAXSource</code> (in fact, it will modify the supplied
622
    ///                    <code>SAXSource</code> setting the <code>XMLReader</code> to null) and use an
623
    ///                    <code>XMLReader</code> created using the value of the
624
    ///                    <code>SOURCE_PARSER_CLASS</code> option in preference.</para>
625
    /// </summary>
626
    /// <remarks>
627
    ///            <para>The defining use case for this feature is when calling a Saxon transformation from
628
    ///                Ant. Ant always supplies the source document as a <code>SAXSource</code> using a
629
    ///                parser instantiated using the default JAXP mechanism. A different parser set using
630
    ///                the property <code>http://saxon.sf.net/feature/sourceParserClass</code> will
631
    ///                normally be ignored in this case; setting the <code>ignoreSAXSourceParser</code>
632
    ///                option overrides this. This is especially useful if the input format is not in fact
633
    ///                XML, but some other format converted to a SAX event stream by means of a custom
634
    ///                parser.</para>
635
    ///        
636
    /// </remarks>
637

    
638
    public static Feature<bool> IGNORE_SAX_SOURCE_PARSER = new Feature<bool>(
639
            net.sf.saxon.lib.Feature.IGNORE_SAX_SOURCE_PARSER);
640

    
641
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
642

    
643

    
644
    /// <summary><para><code>IMPLICIT_SCHEMA_IMPORTS</code> allows reference to schema components without an <code>xs:import</code> for the relevant namespace being
645
    ///                present in the containing schema document. </para>
646
    /// </summary>
647
    /// <remarks>
648
    ///            <para>This only works if the referenced components are already present among the schema components known to the configuration, perhaps
649
    ///            because they were part of a different schema, or because there are cyclic references within a schema.</para>
650
    ///            <para>This option is not conformant with the XSD specification, which requires explicit <code>xs:import</code> declarations
651
    ///            for all cross-namespace component references. However, some "industry-standard" schemas are known to violate this rule,
652
    ///            and setting this option allows such schemas to be loaded by Saxon.</para>
653
    ///        
654
    /// </remarks>
655

    
656
    public static Feature<bool> IMPLICIT_SCHEMA_IMPORTS = new Feature<bool>(
657
            net.sf.saxon.lib.Feature.IMPLICIT_SCHEMA_IMPORTS);
658

    
659
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
660

    
661

    
662
    /// <summary><para><code>LAZY_CONSTRUCTION_MODE</code> determines whether temporary trees are
663
    ///                constructed lazily. The default setting is false; there are a few situations (but
664
    ///                not many) where setting this to true can give a performance benefit (especially a
665
    ///                memory saving).</para>
666
    /// </summary>
667
    /// <remarks>
668
    ///            <para>The option is most likely to be effective when executing XQuery in "pull" mode, that
669
    ///                is, when the client calls the query processor to deliver the result as a stream of
670
    ///                nodes, rather than running the query and piping the results into a serializer.</para>
671
    ///        
672
    /// </remarks>
673

    
674
    public static Feature<bool> LAZY_CONSTRUCTION_MODE = new Feature<bool>(
675
            net.sf.saxon.lib.Feature.LAZY_CONSTRUCTION_MODE);
676

    
677
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
678

    
679

    
680
    /// <summary><para><code>LICENSE_FILE_LOCATION</code> holds the filename in which the Saxon license file
681
    ///                is held.</para>
682
    /// </summary>
683
    /// <remarks>
684
    ///            <para>This is the full file name, for example <code>c:/saxon/license/license.lic</code>. 
685
    ///                Setting this property causes Saxon to
686
    ///                immediately read the specified file and register the license data, assuming it can
687
    ///                be found at this location. The property is not recognized for reading, and it is not
688
    ///                recognized for writing except in Saxon-PE and Saxon-EE.</para>
689
    ///        
690
    /// </remarks>
691

    
692
    public static Feature<String> LICENSE_FILE_LOCATION = new Feature<String>(
693
            net.sf.saxon.lib.Feature.LICENSE_FILE_LOCATION);
694

    
695
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
696

    
697

    
698
    /// <summary><para>Default is false. If true, line and column number information is retained for all
699
    ///                source documents. This information is accessible using the
700
    ///                    <code>saxon:line-number()</code> and <code>saxon:column-number()</code>
701
    ///                extension functions.</para>
702
    /// </summary>
703
    /// <remarks>
704
    ///            <para>Note that the information is only as good as the XML parser supplies. SAX parsers
705
    ///                generally report the position of an element node using the line and column number of
706
    ///                the "&gt;" character that forms the last character of the start tag.</para>
707
    ///            <para>When this option is set, location information attached to a node (system ID, line
708
    ///            number, and column number) is retained when the node is copied. This has the side effect
709
    ///            that the base URI of a node is also copied, which in some cases runs contrary to the
710
    ///            XSLT or XQuery specification.</para>
711
    ///        
712
    /// </remarks>
713

    
714
    public static Feature<bool> LINE_NUMBERING = new Feature<bool>(
715
            net.sf.saxon.lib.Feature.LINE_NUMBERING);
716

    
717
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
718

    
719

    
720
    /// <summary><para>Setting the <code>MARK_DEFAULTED_ATTRIBUTES</code> option causes Saxon to retain details of attributes
721
    ///            that were notified by the XML parser as being defaulted (that is, the attribute was not present in the instance
722
    ///            document but was defined by a default value in a DTD or schema). This information is available to applications
723
    ///            via the <code>saxon:is-defaulted()</code> extension function.</para>
724
    /// </summary>
725
    /// <remarks>
726
    ///            <para>Note: information about defaulted attributes is retained automatically where the attribute is processed
727
    ///            using Saxon's schema processor; but in the case where the information comes from an external XML parser, it
728
    ///            is retained only if this option is set.</para>
729
    ///        
730
    /// </remarks>
731

    
732
    public static Feature<bool> MARK_DEFAULTED_ATTRIBUTES = new Feature<bool>(
733
            net.sf.saxon.lib.Feature.MARK_DEFAULTED_ATTRIBUTES);
734

    
735
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
736

    
737

    
738
    /// <summary><para>Places a limit on the number of classes for which Saxon will generate bytecode.</para>
739
    /// </summary>
740
    /// <remarks>
741
    ///            <para>If bytecode generation is enabled, Saxon will generate bytecode for frequently used constructs appearing
742
    ///                in stylesheets or queries. This can become problematic if a configuration uses a very large number
743
    ///                of different stylesheets and queries, because it creates memory pressure (in some environments classes
744
    ///                are never garbage collected). When this limit (which defaults to 10,000) is exceeded, no more bytecode
745
    ///            is generated, and queries/stylesheets are interpreted instead.</para>
746
    ///        
747
    /// </remarks>
748

    
749
    public static Feature<int> MAX_COMPILED_CLASSES = new Feature<int>(
750
            net.sf.saxon.lib.Feature.MAX_COMPILED_CLASSES);
751

    
752
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
753

    
754

    
755
    /// <summary><para>Use the specified <code>Receiver</code> to process the output from
756
    ///                    <code>xsl:message</code>. The class must implement the
757
    ///                    <code>net.sf.saxon.event.Receiver</code> interface. This interface is similar to
758
    ///                a SAX <code>ContentHandler</code>, in that it takes a stream of events to generate
759
    ///                output.</para>
760
    /// </summary>
761
    /// <remarks>
762
    ///            <para>By default the standard XML emitter is used, configured to write to the standard
763
    ///                error stream, and to include no XML declaration. </para>
764
    ///            <para>In general the content of a message is an XML fragment. Each message is output as a
765
    ///                new document. The sequence of calls to this <code>Receiver</code> is as follows:
766
    ///                there is a single <code>open()</code> call at the start of the transformation, and a
767
    ///                single <code>close()</code> call at the end; and each evaluation of an
768
    ///                    <code>xsl:message</code> instruction starts with a <code>startDocument()</code>
769
    ///                call and ends with <code>endDocument()</code>. </para>
770
    ///            <para>The <code>startDocument()</code> event has a <code>properties</code> argument
771
    ///                indicating whether <code>terminate="yes"</code> was specified, and the
772
    ///                    <code>locationId</code> on calls such as <code>startElement()</code> and
773
    ///                    <code>characters()</code> can be used to identify the location in the stylesheet
774
    ///                where the message data originated (this is achieved by passing the supplied
775
    ///                    <code>locationId</code> in a call to
776
    ///                    <code>getPipelineConfiguration().getLocator().getSystemId(locationId)</code>, or
777
    ///                to <code>getLineNumber()</code> on the same object). </para>
778
    ///            <para>Select the class <code>net.sf.saxon.event.MessageWarner</code> to have
779
    ///                    <code>xsl:message</code> output notified to the JAXP <code>ErrorListener</code>,
780
    ///                as described in the JAXP documentation.</para>
781
    ///        
782
    /// </remarks>
783

    
784
    public static Feature<String> MESSAGE_EMITTER_CLASS = new Feature<String>(
785
            net.sf.saxon.lib.Feature.MESSAGE_EMITTER_CLASS);
786

    
787
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
788

    
789

    
790
    /// <summary><para>Affects XQuery only. An instance of a user-written class implementing Saxon's
791
    ///                    <see cref="net.sf.saxon.lib.ModuleURIResolver" /> interface. This is used to
792
    ///                process any URIs used in <code>import module</code> directives in XQuery.</para>
793
    /// </summary>
794

    
795
    public static Feature<net.sf.saxon.lib.ModuleURIResolver> MODULE_URI_RESOLVER = new Feature<net.sf.saxon.lib.ModuleURIResolver>(
796
            net.sf.saxon.lib.Feature.MODULE_URI_RESOLVER);
797

    
798
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
799

    
800

    
801
    /// <summary><para>Affects XQuery only. The name of a user-written class implementing Saxon's
802
    ///                    <see cref="net.sf.saxon.lib.ModuleURIResolver" /> interface. This is used to
803
    ///                process any URIs used in <code>import module</code> directives in XQuery.</para>
804
    /// </summary>
805

    
806
    public static Feature<String> MODULE_URI_RESOLVER_CLASS = new Feature<String>(
807
            net.sf.saxon.lib.Feature.MODULE_URI_RESOLVER_CLASS);
808

    
809
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
810

    
811

    
812
    /// <summary><para>When set from the Transform or Query command line, a report on bytecode generation is
813
    ///                produced at the end of the transformation or query.</para>
814
    /// </summary>
815
    /// <remarks>
816
    ///            <para>When set from an application, the bytecode report is produced only on request, by
817
    ///                calling <code>Configuration.createByteCodeReport(fileName)</code>.</para>
818
    ///            <para>The bytecode report is an XML file containing one entry for each expression that has
819
    ///                been compiled into bytecode. Each entry contains the following details, where
820
    ///                applicable:</para>
821
    ///                <list>
822
    ///                <item><code>text</code> Abbreviated text of the expression</item>
823
    ///                <item><code>intCount</code> Number of times the expression was evaluated in the interpreter</item>
824
    ///                <item><code>intTime</code> Cumulative time spent evaluating the expression (including subexpressions) in the interpreter</item>
825
    ///                <item><code>bcCount</code> Number of times the expression was evaluated as byte-code</item>
826
    ///                <item><code>bcTime</code> Cumulative time spent evaluating the expression (including subexpressions) as byte-code</item>
827
    ///                <item><code>compileTime</code> Time spent generating bytecode for the expression</item>
828
    ///                <item><code>ratio</code> Average byte-code execution time as a proportion of average interpreted execution time</item>
829
    ///                <item><code>ebv</code> Number of evaluations of the expressions <code>effectiveBooleanValue()</code> method</item>
830
    ///                <item><code>eval</code> Number of evaluations of the expressions <code>evaluateItem()</code> method</item>
831
    ///                <item><code>iterate</code> Number of evaluations of the expressions <code>iterate()</code> method</item>
832
    ///                <item><code>process</code> Number of evaluations of the expressions <code>process()</code> method</item>
833
    ///                <item><code>module</code> URI of the module containing the expression</item>
834
    ///                <item><code>line</code> Line number of the expression within this module</item>
835
    ///            </list>
836
    ///        
837
    /// </remarks>
838

    
839
    public static Feature<bool> MONITOR_HOT_SPOT_BYTE_CODE = new Feature<bool>(
840
            net.sf.saxon.lib.Feature.MONITOR_HOT_SPOT_BYTE_CODE);
841

    
842
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
843

    
844

    
845
    /// <summary><para>Affects schema construction (whether for standalone validation, or in the context of
846
    ///                XSLT or XQuery).</para>
847
    /// </summary>
848
    /// <remarks>
849
    ///            <para>If set to true, the schema processor attempts to fetch a schema
850
    ///                document appearing in an <code>xs:import</code> directive, whether or not a schema
851
    ///                for that namespace has already been loaded, unless the absolute URI formed from the
852
    ///                    <code>schemaLocation</code> is the same as the absolute URI that was used to
853
    ///                load that namespace. If set to false, the schema processor ignores the
854
    ///                    <code>schemaLocation</code> on an <code>xs:import</code> declaration if schema
855
    ///                components for the requested namespace are already available. Note that setting the
856
    ///                value to true might cause spurious errors due to like-named schema components being
857
    ///                loaded more than once. On the other hand, setting the value to false might result in
858
    ///                validation failing because schema components are missing.</para>
859
    ///            <para>Note: Both settings are conformant with the W3C recommendation, which leaves the
860
    ///                details implementation-defined. It is possible (and advisable) to write schemas in
861
    ///                such a way that this setting makes no difference, by ensuring that all imports for a
862
    ///                particular namespace go via a "home" schema document for that namespace, where the
863
    ///                home schema document contains <code>xs:include</code> declarations for all the
864
    ///                schema documents defining components in that namespace.</para>
865
    ///        
866
    /// </remarks>
867

    
868
    public static Feature<bool> MULTIPLE_SCHEMA_IMPORTS = new Feature<bool>(
869
            net.sf.saxon.lib.Feature.MULTIPLE_SCHEMA_IMPORTS);
870

    
871
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
872

    
873

    
874
    /// <summary><para>Indicates that the supplied <code>NamePool</code> should be used as the target
875
    ///                (run-time) <code>NamePool</code> by all stylesheets compiled (using
876
    ///                <code>newTemplates()</code>) after this call on <code>setAttribute</code>.</para>
877
    /// </summary>
878
    /// <remarks>
879
    ///            <para>Normally a single system-allocated <code>NamePool</code> is used for all stylesheets
880
    ///                compiled while the Java VM remains loaded; this attribute allows user control over
881
    ///                the allocation of name pools. Note that source trees used as input to a
882
    ///                transformation must be built using the same <code>NamePool</code> that is used when
883
    ///                the stylesheet is compiled: this will happen automatically if the input to a
884
    ///                transformation is supplied as a <code>SAXSource</code> or <code>StreamSource</code>
885
    ///                but it is under user control if you build the source tree yourself.</para>
886
    ///            <para>This option can be used to make two <code>Configuration</code> objects share a
887
    ///                    <code>NamePool</code> even though they differ in other respects.</para>
888
    ///        
889
    /// </remarks>
890

    
891
    public static Feature<net.sf.saxon.om.NamePool> NAME_POOL = new Feature<net.sf.saxon.om.NamePool>(
892
            net.sf.saxon.lib.Feature.NAME_POOL);
893

    
894
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
895

    
896

    
897
    /// <summary><para><code>OCCURRENCE_LIMITS</code> determines the largest values of
898
    ///                <code>minOccurs</code> and <code>maxOccurs</code> that can be accommodated when
899
    ///                compiling an "expanded" finite state machine to represent an XSD content model
900
    ///                grammar.</para>
901
    /// </summary>
902
    /// <remarks>
903
    ///            <para>These limits do not apply in the common cases where the grammar can be
904
    ///                implemented using a counting finite-state-machine, but in those cases where this is
905
    ///                not possible, any <code>minOccurs</code> value greater than the first integer is
906
    ///                reduced to the value of the first integer, and any <code>maxOccurs</code> value
907
    ///                greater than the second integer is treated as "unbounded".</para>
908
    ///            <para>Setting these values too high may cause an <code>OutOfMemoryException</code> since
909
    ///                the size of the finite state machine constructed by Saxon increases linearly with
910
    ///                the values of <code>minOccurs</code> and <code>maxOccurs</code>.</para>
911
    ///        
912
    /// </remarks>
913

    
914
    public static Feature<Object> OCCURRENCE_LIMITS = new Feature<Object>(
915
            net.sf.saxon.lib.Feature.OCCURRENCE_LIMITS);
916

    
917
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
918

    
919

    
920
    /// <summary><para>Allows individual optimizations to be enabled or disabled selectively.</para>
921
    /// </summary>
922
    /// <remarks>
923
    ///            <para>There is a set of single-letter flags identifying particular optimizations:</para>
924
    ///            <list>
925
    ///                <item>c: generate bytecode</item>
926
    ///                <item>e: cache regular expressions</item>
927
    ///                <item>f: inline functions</item>
928
    ///                <item>g: extract global variables</item>
929
    ///                <item>j: just-in-time compilation of template rules</item>
930
    ///                <item>k: create keys</item>
931
    ///                <item>l: loop lifting</item>
932
    ///                <item>m: miscellaneous</item>
933
    ///                <item>r: template rule-sets</item>
934
    ///                <item>s: extract common subexpressions</item>
935
    ///                <item>v: inline variables</item>
936
    ///                <item>w: create switch statements</item>
937
    ///                <item>x: index predicates</item>
938
    ///            </list>
939
    ///            <para>A value such as <code>gs</code> runs with only the selected optimizations;
940
    ///                <code>-gs</code> runs with the selected optimizations disabled and all others enabled. The
941
    ///                value <code>0</code> suppresses all optimizations. The default is full optimization; this
942
    ///                feature allows optimization to be suppressed in cases where reducing compile time is
943
    ///                important, or where optimization gets in the way of debugging, or causes extension
944
    ///                functions with side-effects to behave unpredictably. (Note however, that even with
945
    ///                no optimization, lazy evaluation may still cause the evaluation order to be not as
946
    ///                expected.) </para>
947
    ///            <para><i>Note that disabling optimizations may prevent streamed execution. This is because
948
    ///            there are cases where streamed execution is only possible because the optimizer is able to detect
949
    ///            that sorting nodes into document order is unnecessary.</i></para>
950
    ///        
951
    /// </remarks>
952

    
953
    public static Feature<Object> OPTIMIZATION_LEVEL = new Feature<Object>(
954
            net.sf.saxon.lib.Feature.OPTIMIZATION_LEVEL);
955

    
956
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
957

    
958

    
959
    /// <summary><para>The supplied <code>OutputURIResolver</code> will be used to resolve URIs of secondary
960
    ///                result documents selected in the <code>href</code> attribute of the XSLT
961
    ///                    <code>xsl:result-document</code> instruction.</para>
962
    /// </summary>
963

    
964
    public static Feature<net.sf.saxon.lib.OutputURIResolver> OUTPUT_URI_RESOLVER = new Feature<net.sf.saxon.lib.OutputURIResolver>(
965
            net.sf.saxon.lib.Feature.OUTPUT_URI_RESOLVER);
966

    
967
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
968

    
969

    
970
    /// <summary><para>The supplied class will be instantiated, and the resulting
971
    ///                    <code>OutputURIResolver</code> will be used to resolve URIs of secondary result
972
    ///                documents selected in the <code>href</code> attribute of the XSLT
973
    ///                    <code>xsl:result-document</code> instruction.</para>
974
    /// </summary>
975

    
976
    public static Feature<String> OUTPUT_URI_RESOLVER_CLASS = new Feature<String>(
977
            net.sf.saxon.lib.Feature.OUTPUT_URI_RESOLVER_CLASS);
978

    
979
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
980

    
981

    
982
    /// <summary><para>If true, calls on the <code>doc()</code> and <code>document()</code> functions, if
983
    ///                their arguments are known at compile time, will be evaluated at compile time, and
984
    ///                the resulting document will be stored as part of the Saxon
985
    ///                <see cref="net.sf.saxon.Configuration" /> and shared by all queries and
986
    ///                transformations running within that <code>Configuration</code>.</para>
987
    /// </summary>
988
    /// <remarks>
989
    ///            <para>This is useful for reference documents that have stable content and are used by many different 
990
    ///                queries and transformations. The default is false, which means each query or transformation
991
    ///                will reload the document from disk.</para>
992
    ///            <para>In XSLT 3.0 a better way of having external documents pre-loaded at stylesheet
993
    ///                compile time is to use the new facility of static global variables.</para>
994
    ///        
995
    /// </remarks>
996

    
997
    public static Feature<bool> PRE_EVALUATE_DOC_FUNCTION = new Feature<bool>(
998
            net.sf.saxon.lib.Feature.PRE_EVALUATE_DOC_FUNCTION);
999

    
1000
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1001

    
1002

    
1003
    /// <summary><para>Relevant only on .NET, determines whether the Java Classpath parser is used in
1004
    ///                preference to the Microsoft .NET parser.</para>
1005
    /// </summary>
1006
    /// <remarks>
1007
    ///            <para>This option has no effect on the Java platform. The default is <b>true</b>. When
1008
    ///                running on the .NET platform, if the option is true it causes the Apache Xerces
1009
    ///                parser (cross-compiled using IKVMC) to be used in preference to the .NET XML parser.
1010
    ///                If false the .NET XML parser (<code>System.Xml.XmlTextReader</code>) is used. One
1011
    ///                reason for providing this option is that the .NET XML parser does not report ID
1012
    ///                attributes, which means that the <code>id()</code> function does not work.</para>
1013
    ///        
1014
    /// </remarks>
1015

    
1016
    public static Feature<bool> PREFER_JAXP_PARSER = new Feature<bool>(
1017
            net.sf.saxon.lib.Feature.PREFER_JAXP_PARSER);
1018

    
1019
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1020

    
1021

    
1022
    /// <summary><para>True if the standard URI resolver is to recognize query parameters included in
1023
    ///                the URI (for example, <code>?val=strict</code>). Such parameters can then be used in
1024
    ///                URIs passed to the <code>doc()</code> or <code>document()</code> functions. For
1025
    ///                details of the query parameters available, see <span class="link" data-href="/sourcedocs">Source Documents</span>. The default is false.</para>
1026
    /// </summary>
1027
    /// <remarks>
1028
    ///            <para>This option has no effect if a user-supplied <code>URIResolver</code> is in use,
1029
    ///                unless the user-supplied <code>URIResolver</code> chooses to inherit this
1030
    ///                functionality from the standard <code>URIResolver</code>.</para>
1031
    ///            <para>Allowed parameters include <code>validation=strict|lax|strip</code> to perform schema
1032
    ///                validation, <code>strip-space=yes|ignorable|no</code> to control whitespace
1033
    ///                stripping, and <code>xinclude=yes|no</code> to control whether XInclude processing
1034
    ///                takes place (assuming the XML parser supports it).</para>
1035
    ///        
1036
    /// </remarks>
1037

    
1038
    public static Feature<bool> RECOGNIZE_URI_QUERY_PARAMETERS = new Feature<bool>(
1039
            net.sf.saxon.lib.Feature.RECOGNIZE_URI_QUERY_PARAMETERS);
1040

    
1041
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1042

    
1043

    
1044
    /// <summary><para>An integer, one of <see cref="net.sf.saxon.Configuration#RECOVER_SILENTLY" />,
1045
    ///                <see cref="net.sf.saxon.Configuration#RECOVER_WITH_WARNINGS" />, or
1046
    ///                <see cref="net.sf.saxon.Configuration#DO_NOT_RECOVER" />. Indicates the policy for
1047
    ///                handling dynamic errors that the XSLT specification defines as recoverable.</para>
1048
    /// </summary>
1049
    /// <remarks>
1050
    ///            <para>0 means recover silently; 1 means recover after signalling a warning to the
1051
    ///                    <code>ErrorListener</code>; 2 means treat the error as fatal. An example of a
1052
    ///                recoverable error is when two template rules match the same node.</para>
1053
    ///            <para>Note that XSLT 3.0 has eliminated all "recoverable errors" from the
1054
    ///                specification.</para>
1055
    ///        
1056
    /// </remarks>
1057

    
1058
    public static Feature<int> RECOVERY_POLICY = new Feature<int>(
1059
            net.sf.saxon.lib.Feature.RECOVERY_POLICY);
1060

    
1061
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1062

    
1063

    
1064
    /// <summary><para>Indicates the policy for handling dynamic errors that the XSLT specification defines
1065
    ///                as recoverable.</para>
1066
    /// </summary>
1067
    /// <remarks>
1068
    ///            <para>"recoverSilently" means recover silently; "recoverWithWarnings"
1069
    ///                means recover after signalling a warning to the <code>ErrorListener</code>;
1070
    ///                "doNotRecover" means treat the error as fatal. An example of a recoverable error is
1071
    ///                when two template rules match the same node. </para>
1072
    ///            <para>Note that XSLT 3.0 has eliminated all "recoverable errors" from the
1073
    ///                specification.</para>
1074
    ///        
1075
    /// </remarks>
1076

    
1077
    public static Feature<String> RECOVERY_POLICY_NAME = new Feature<String>(
1078
            net.sf.saxon.lib.Feature.RECOVERY_POLICY_NAME);
1079

    
1080
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1081

    
1082

    
1083
    /// <summary><para>Indicates the maximum number of threads to be used for processing
1084
    ///                    <code>xsl:result-document</code> instructions in parallel. If the maximum number
1085
    ///                of threads are already in use, the <code>xsl:result-document</code> instruction will
1086
    ///                be executed synchronously within its parent thread.</para>
1087
    /// </summary>
1088
    /// <remarks>
1089
    ///            <para>The default value is initialized to
1090
    ///                    <code>Runtime.getRuntime().availableProcessors()</code> which is intended to
1091
    ///                represent the number of "processors" (under some definition) available from the
1092
    ///                hardware.</para>
1093
    ///            <para>The limit applies per <code>Configuration</code>. If multiple workloads are running
1094
    ///                on the same server under separate Saxon <code>Configuration</code> objects, then it
1095
    ///                may be desirable to lower the limit.</para>
1096
    ///            <para>Setting a value of zero or one suppresses multithreading entirely. This can also be
1097
    ///                achieved (for a specific <code>xsl:result-document</code> instruction) by setting
1098
    ///                the attribute <code>saxon:asynchronous="no"</code> in the stylesheet. Suppressing
1099
    ///                multithreading may be desirable in a stylesheet that calls extension functions with
1100
    ///                side-effects.</para>
1101
    ///        
1102
    /// </remarks>
1103

    
1104
    public static Feature<int> RESULT_DOCUMENT_THREADS = new Feature<int>(
1105
            net.sf.saxon.lib.Feature.RESULT_DOCUMENT_THREADS);
1106

    
1107
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1108

    
1109

    
1110
    /// <summary><para>If set to true, indicates that when input is obtained from a SAX parser, the
1111
    ///                DTD-based attribute type notified by the XML parser should be used to set the type
1112
    ///                annotation of the resulting node: for example a DTD type of NMTOKENS results in a
1113
    ///                type annotation of xs:NMTOKENS. </para>
1114
    /// </summary>
1115
    /// <remarks>
1116
    ///            <para>This option is retained for backwards compatibility (at some time in the past, it was
1117
    ///                the default), but is deprecated.</para>
1118
    ///        
1119
    /// </remarks>
1120

    
1121
    public static Feature<bool> RETAIN_DTD_ATTRIBUTE_TYPES = new Feature<bool>(
1122
            net.sf.saxon.lib.Feature.RETAIN_DTD_ATTRIBUTE_TYPES);
1123

    
1124
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1125

    
1126

    
1127
    /// <summary><para>The supplied <code>SchemaURIResolver</code> will be used to resolve URIs of schema
1128
    ///                documents referenced in <code>xsl:import-schema</code> declarations in XSLT,
1129
    ///                    <code>import schema</code> in XQuery, references from one schema document to
1130
    ///                another using <code>xs:include</code> or <code>xs:import</code>, and references from
1131
    ///                an instance document to a schema using <code>xsi:schemaLocation</code>.</para>
1132
    /// </summary>
1133

    
1134
    public static Feature<net.sf.saxon.lib.SchemaURIResolver> SCHEMA_URI_RESOLVER = new Feature<net.sf.saxon.lib.SchemaURIResolver>(
1135
            net.sf.saxon.lib.Feature.SCHEMA_URI_RESOLVER);
1136

    
1137
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1138

    
1139

    
1140
    /// <summary><para>The name of a class that implements the interface <code>SchemaURIResolver</code>;
1141
    ///                this class will be instantiated and the resulting instance will be used as the value
1142
    ///                of the <see cref="SCHEMA_URI_RESOLVER" /> property.</para>
1143
    /// </summary>
1144

    
1145
    public static Feature<String> SCHEMA_URI_RESOLVER_CLASS = new Feature<String>(
1146
            net.sf.saxon.lib.Feature.SCHEMA_URI_RESOLVER_CLASS);
1147

    
1148
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1149

    
1150

    
1151
    /// <summary><para>Indicates whether and how schema validation should be applied to source
1152
    ///                documents.</para>
1153
    /// </summary>
1154

    
1155
    public static Feature<int> SCHEMA_VALIDATION = new Feature<int>(
1156
            net.sf.saxon.lib.Feature.SCHEMA_VALIDATION);
1157

    
1158
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1159

    
1160

    
1161
    /// <summary><para>Indicates whether and how schema validation should be applied to source
1162
    ///                documents.</para>
1163
    /// </summary>
1164

    
1165
    public static Feature<String> SCHEMA_VALIDATION_MODE = new Feature<String>(
1166
            net.sf.saxon.lib.Feature.SCHEMA_VALIDATION_MODE);
1167

    
1168
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1169

    
1170

    
1171
    /// <summary><para>The class will be instantiated and the resulting <code>SerializerFactory</code> will
1172
    ///                be used to create the serialization pipeline for XSLT and XQuery results.</para>
1173
    /// </summary>
1174
    /// <remarks>
1175
    ///            <para>By subclassing the standard <code>SerializerFactory</code> it is possible to customize
1176
    ///                many aspects of the output produced by the Serializer, or to introduce new
1177
    ///                serialization methods and parameters.</para>
1178
    ///        
1179
    /// </remarks>
1180

    
1181
    public static Feature<String> SERIALIZER_FACTORY_CLASS = new Feature<String>(
1182
            net.sf.saxon.lib.Feature.SERIALIZER_FACTORY_CLASS);
1183

    
1184
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1185

    
1186

    
1187
    /// <summary><para>XML parser used for source documents.</para>
1188
    /// </summary>
1189
    /// <remarks>
1190
    ///            <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
1191
    ///                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
1192
    ///                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
1193
    ///                parse source documents (that is, the principal source document plus any secondary
1194
    ///                source documents read using the <code>doc()</code>, <code>document()</code>, or
1195
    ///                    <code>collection()</code> function).</para>
1196
    ///            <para>Note that the selected parser is used only when the input is supplied in the form of
1197
    ///                a <code>StreamSource</code>; it is ignored when a <code>SAXSource</code> with a
1198
    ///                pre-initialized <code>XMLReader</code> is supplied. A consequence is that this
1199
    ///                configuration option has no effect when running transformations from an Ant script,
1200
    ///                since the Ant <code>xslt</code> task always supplies the input in the form of a
1201
    ///                    <code>SAXSource</code>.</para>
1202
    ///        
1203
    /// </remarks>
1204

    
1205
    public static Feature<String> SOURCE_PARSER_CLASS = new Feature<String>(
1206
            net.sf.saxon.lib.Feature.SOURCE_PARSER_CLASS);
1207

    
1208
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1209

    
1210

    
1211
    /// <summary><para>On interfaces that allow an <code>org.xml.sax.Source</code> to be supplied, if a kind
1212
    ///                of <code>Source</code> is provided that Saxon does not recognize, it will be passed
1213
    ///                to the user-supplied <code>SourceResolver</code>, which has the opportunity to
1214
    ///                convert it to a kind of <code>Source</code> that Saxon does recognize. This allows
1215
    ///                new kinds of input to be supplied as input to Saxon's query, transformation, and
1216
    ///                validation engines.</para>
1217
    /// </summary>
1218

    
1219
    public static Feature<String> SOURCE_RESOLVER_CLASS = new Feature<String>(
1220
            net.sf.saxon.lib.Feature.SOURCE_RESOLVER_CLASS);
1221

    
1222
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1223

    
1224

    
1225
    /// <summary><para><code>STABLE_COLLECTION_URI</code>, if set, indicates that collections returned by
1226
    ///                the <code>fn:collection()</code> and <code>fn:uri-collection()</code> functions
1227
    ///                should be <i>stable</i>, that is, repeated calls on these functions with the same
1228
    ///                collection URI (within the scope of a single query or transformation) should return
1229
    ///                identical results.</para>
1230
    /// </summary>
1231
    /// <remarks>
1232
    ///            <para>Setting this option may be expensive because it requires that the entire collection
1233
    ///                be saved in memory; it is rarely necessary in practice, but is required for strict
1234
    ///                conformance with the W3C specifications.</para>
1235
    ///            <para>It is also possible to indicate that a collection is stable by means of the
1236
    ///                    <code>CollectionFinder</code> API.</para>
1237
    ///        
1238
    /// </remarks>
1239

    
1240
    public static Feature<bool> STABLE_COLLECTION_URI = new Feature<bool>(
1241
            net.sf.saxon.lib.Feature.STABLE_COLLECTION_URI);
1242

    
1243
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1244

    
1245

    
1246
    /// <summary><para><code>STABLE_UNPARSED_TEXT</code>, if set, indicates that the results returned by
1247
    ///                repeated calls of <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>,
1248
    ///                and <code>unparsed-text-available()</code> are consistent: calling these functions
1249
    ///                twice during the evaluation of a stylesheet or query will return the same
1250
    ///                results.</para>
1251
    /// </summary>
1252
    /// <remarks>
1253
    ///            <para>Setting this option may be expensive because it requires that the file contents be
1254
    ///                saved in memory; it is rarely necessary in practice, but is required for strict
1255
    ///                conformance with the W3C specifications.</para>
1256
    ///        
1257
    /// </remarks>
1258

    
1259
    public static Feature<bool> STABLE_UNPARSED_TEXT = new Feature<bool>(
1260
            net.sf.saxon.lib.Feature.STABLE_UNPARSED_TEXT);
1261

    
1262
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1263

    
1264

    
1265
    /// <summary><para><code>STANDARD_ERROR_OUTPUT_FILE</code> is the name of a file to which Saxon will
1266
    ///                redirect output that would otherwise go to the operating system standard error
1267
    ///                stream (System.err). This is the fallback destination for various tracing and
1268
    ///                diagnostic output. In some cases a more specific mechanism exists to select the
1269
    ///                destination for particular kinds of output.</para>
1270
    /// </summary>
1271
    /// <remarks>
1272
    ///            <para>Note that if the <code>Configuration</code> is used in more than one processing
1273
    ///                thread, the messages from different threads will be interleaved in the output file.
1274
    ///                A more selective approach is to use a different <code>ErrorListener</code> in
1275
    ///                different processing threads, and arrange for each <code>ErrorListener</code> to
1276
    ///                write to its own logging destination.</para>
1277
    ///        
1278
    /// </remarks>
1279

    
1280
    public static Feature<String> STANDARD_ERROR_OUTPUT_FILE = new Feature<String>(
1281
            net.sf.saxon.lib.Feature.STANDARD_ERROR_OUTPUT_FILE);
1282

    
1283
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1284

    
1285

    
1286
    /// <summary><para>The <code>STREAMABILITY</code> option can be used to disable streaming.</para>
1287
    /// </summary>
1288
    /// <remarks>
1289
    ///            <para>In earlier Saxon releases a third value "extended" was supported, to enable Saxon
1290
    ///                streaming extensions. Since nearly all these extensions found their way into the W3C
1291
    ///                specification, the distinction between "standard" and "extended" became meaningless,
1292
    ///                so the value "extended" has been dropped.</para>
1293
    ///            <para>The value "off" causes Saxon to behave as a non-streaming processor; that is, it does
1294
    ///                not analyze constructs that are declared streamable, and it processes them as if
1295
    ///                streaming were not requested. This is the only option available when using a Saxon
1296
    ///                version or license that does not enable streaming.</para>
1297
    ///            <para>The value "standard" is a misnomer. For strict adherence to W3C streamability rules,
1298
    ///                set the property <code>STRICT_STREAMABILITY</code>. The streamability rules applied
1299
    ///                by default are (in nearly all cases) identical to the W3C rules, but by default they
1300
    ///                are applied to the expression tree after type-checking and optimization, which makes
1301
    ///                some constructs streamable that would not be so otherwise.</para>
1302
    ///            <para>Whichever option is chosen, the <code>STREAMING_FALLBACK</code> option can be used to
1303
    ///                control what happens when code is deemed non-streamable; it provides a choice
1304
    ///                between throwing a static (compile-time) error, and falling back to a non-streaming
1305
    ///                implementation.</para>
1306
    ///        
1307
    /// </remarks>
1308

    
1309
    public static Feature<String> STREAMABILITY = new Feature<String>(
1310
            net.sf.saxon.lib.Feature.STREAMABILITY);
1311

    
1312
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1313

    
1314

    
1315
    /// <summary><para>Causes the XSLT processor to verify that constructs that are declared streamable are
1316
    ///                in fact "guaranteed streamable" according to the W3C rules.</para>
1317
    /// </summary>
1318
    /// <remarks>
1319
    ///            <para>Normally, Saxon performs a variety of simplifications and optimizations on the
1320
    ///                expression tree before performing streamability analysis. Sometimes these tree
1321
    ///                rewrites will turn a non-streamable expression into a streamable one. An obvious
1322
    ///                example is variable inlining: the expression <code>let $x := ./item/price return
1323
    ///                    sum($x)</code> is not streamable, but the rewritten form
1324
    ///                    <code>sum(./item/price)</code> is.</para>
1325
    ///            <para>The XSLT 3.0 specification requires conformant streaming processors to have a mode of
1326
    ///                operation in which the streamability rules are enforced as they appear in the spec,
1327
    ///                and this option enables this mode.</para>
1328
    ///            <para>This analysis is expensive, and should only be used during development when testing
1329
    ///                stylesheet code for portability. When this mode is enabled, Saxon applies the
1330
    ///                streamability rules at the earliest possible stage of processing; it then performs
1331
    ///                its normal type checking and optimization phases, before doing a second stage of
1332
    ///                streamability analysis to construct a streamed execution plan.</para>
1333
    ///        
1334
    /// </remarks>
1335

    
1336
    public static Feature<bool> STRICT_STREAMABILITY = new Feature<bool>(
1337
            net.sf.saxon.lib.Feature.STRICT_STREAMABILITY);
1338

    
1339
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1340

    
1341

    
1342
    /// <summary><para>If the <code>STREAMING_FALLBACK</code> option is set, then constructs for which
1343
    ///                streaming is requested (such as templates in a streaming mode, the
1344
    ///                    <code>xsl:source-document</code> instruction with attribute
1345
    ///                    <code>streamable="yes"</code>, and streamable accumulators) will be executed in
1346
    ///                non-streaming mode if the code is not actually streamable. A compile-time warning
1347
    ///                will always be given when the fallback option is taken.</para>
1348
    /// </summary>
1349

    
1350
    public static Feature<bool> STREAMING_FALLBACK = new Feature<bool>(
1351
            net.sf.saxon.lib.Feature.STREAMING_FALLBACK);
1352

    
1353
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1354

    
1355

    
1356
    /// <summary><para>Indicates whether all whitespace, no whitespace, or whitespace in elements defined in
1357
    ///                a DTD or schema as having element-only content should be stripped from source
1358
    ///                documents.</para>
1359
    /// </summary>
1360
    /// <remarks>
1361
    ///            <para>The default is "ignorable". This whitespace stripping is additional to
1362
    ///                any stripping done as a result of the <code>xsl:strip-space</code> declaration in an
1363
    ///                XSLT stylesheet.</para>
1364
    ///        
1365
    /// </remarks>
1366

    
1367
    public static Feature<String> STRIP_WHITESPACE = new Feature<String>(
1368
            net.sf.saxon.lib.Feature.STRIP_WHITESPACE);
1369

    
1370
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1371

    
1372

    
1373
    /// <summary><para>XML parser used for stylesheets and schema documents.</para>
1374
    /// </summary>
1375
    /// <remarks>
1376
    ///            <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
1377
    ///                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
1378
    ///                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
1379
    ///                parse stylesheet documents (that is, the principal stylesheet module plus any
1380
    ///                secondary source documents read using <code>xsl:include</code> or
1381
    ///                    <code>xsl:import</code>) and also schema documents.</para>
1382
    ///        
1383
    /// </remarks>
1384

    
1385
    public static Feature<String> STYLE_PARSER_CLASS = new Feature<String>(
1386
            net.sf.saxon.lib.Feature.STYLE_PARSER_CLASS);
1387

    
1388
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1389

    
1390

    
1391
    /// <summary><para>This is set to true to suppress the warning otherwise issued by command-line
1392
    ///                interfaces indicating that an evaluation license is in use and is due to expire in a
1393
    ///                set number of days.</para>
1394
    /// </summary>
1395

    
1396
    public static Feature<bool> SUPPRESS_EVALUATION_EXPIRY_WARNING = new Feature<bool>(
1397
            net.sf.saxon.lib.Feature.SUPPRESS_EVALUATION_EXPIRY_WARNING);
1398

    
1399
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1400

    
1401

    
1402
    /// <summary><para>Suppresses all warnings issued by the XPath and XQuery parsers.</para>
1403
    /// </summary>
1404
    /// <remarks>
1405
    ///            <para>Examples of warnings that are suppressed are the warning produced when keywords such
1406
    ///                as <code>true</code> and <code>return</code> are interpreted as element names.</para>
1407
    ///        
1408
    /// </remarks>
1409

    
1410
    public static Feature<bool> SUPPRESS_XPATH_WARNINGS = new Feature<bool>(
1411
            net.sf.saxon.lib.Feature.SUPPRESS_XPATH_WARNINGS);
1412

    
1413
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1414

    
1415

    
1416
    /// <summary><para>This is set to true to suppress the warning when there is no commonality between the
1417
    ///                namespaces used in stylesheet match patterns and the namespaces used in the source
1418
    ///                document.</para>
1419
    /// </summary>
1420

    
1421
    public static Feature<bool> SUPPRESS_XSLT_NAMESPACE_CHECK = new Feature<bool>(
1422
            net.sf.saxon.lib.Feature.SUPPRESS_XSLT_NAMESPACE_CHECK);
1423

    
1424
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1425

    
1426

    
1427
    /// <summary><para>Indicates how often an XSD simple type definition must be used before Saxon generates
1428
    ///                bytecode to implement validation of input data against that type.</para>
1429
    /// </summary>
1430
    /// <remarks>
1431
    ///            <para>By default, Saxon-EE generates Java bytecode to speed up the validation of input
1432
    ///                strings against user-defined simple types after the type has been used 100 times
1433
    ///                (during the life of a Saxon Configuration). This threshold may be changed using this
1434
    ///                configuration option. It may be useful to raise the threshold if the number of
1435
    ///                user-defined types is large, and the bytecode is creating memory pressure.</para>
1436
    ///        
1437
    /// </remarks>
1438

    
1439
    public static Feature<int> THRESHOLD_FOR_COMPILING_TYPES = new Feature<int>(
1440
            net.sf.saxon.lib.Feature.THRESHOLD_FOR_COMPILING_TYPES);
1441

    
1442
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1443

    
1444

    
1445
    /// <summary><para>This is set to true to cause basic timing and tracing information to be output to the
1446
    ///                standard error output stream.</para>
1447
    /// </summary>
1448
    /// <remarks>
1449
    ///            <para>The name of the feature is poorly chosen, since much
1450
    ///                of the information that is output has nothing to do with timing, for example the
1451
    ///                names of output files for <code>xsl:result-document</code> are traced, as are the
1452
    ///                names of schema documents loaded.</para>
1453
    ///        
1454
    /// </remarks>
1455

    
1456
    public static Feature<bool> TIMING = new Feature<bool>(
1457
            net.sf.saxon.lib.Feature.TIMING);
1458

    
1459
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1460

    
1461

    
1462
    /// <summary><para>If this option is set, Saxon will output (to the standard error output) progress
1463
    ///                information about its attempts to locate and disambiguate references to reflexive
1464
    ///                Java extension functions. This is useful for diagnostics if the XQuery or XSLT
1465
    ///                compiler is failing to locate user-written extension functions.</para>
1466
    /// </summary>
1467

    
1468
    public static Feature<bool> TRACE_EXTERNAL_FUNCTIONS = new Feature<bool>(
1469
            net.sf.saxon.lib.Feature.TRACE_EXTERNAL_FUNCTIONS);
1470

    
1471
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1472

    
1473

    
1474
    /// <summary><para>The <code>TraceListener</code> will be notified of significant events occurring
1475
    ///                during a query or transformation, for tracing or debugging purposes.</para>
1476
    /// </summary>
1477
    /// <remarks>
1478
    ///            <para>Setting a <code>TraceListener</code> automatically sets the
1479
    ///                    <see cref="COMPILE_WITH_TRACING" /> option.</para>
1480
    ///            <para>Avoid this option if more than one transformation or query is running concurrently:
1481
    ///                use the feature <see cref="TRACE_LISTENER_CLASS" />
1482
    ///                instead. Alternatively, it is possible to set a <code>TraceListener</code> for an
1483
    ///                individual query or transformation.</para>
1484
    ///        
1485
    /// </remarks>
1486

    
1487
    public static Feature<net.sf.saxon.lib.TraceListener> TRACE_LISTENER = new Feature<net.sf.saxon.lib.TraceListener>(
1488
            net.sf.saxon.lib.Feature.TRACE_LISTENER);
1489

    
1490
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1491

    
1492

    
1493
    /// <summary><para>The class will be instantiated once for each query or transformation, and the
1494
    ///                resulting <code>TraceListener</code> will be notified of significant events
1495
    ///                occurring during that query or transformation, for tracing or debugging
1496
    ///                purposes.</para>
1497
    /// </summary>
1498
    /// <remarks>
1499
    ///            <para>Setting a <code>TraceListener</code> automatically sets the
1500
    ///                    <see cref="COMPILE_WITH_TRACING" /> option.</para>
1501
    ///        
1502
    /// </remarks>
1503

    
1504
    public static Feature<String> TRACE_LISTENER_CLASS = new Feature<String>(
1505
            net.sf.saxon.lib.Feature.TRACE_LISTENER_CLASS);
1506

    
1507
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1508

    
1509

    
1510
    /// <summary><para>When trace listening is switched on (for example by using -T on the command line),
1511
    ///                this file will be supplied to the trace listener to use as the output destination.
1512
    ///                If the option is not supplied, trace listener output is sent to the standard error
1513
    ///                stream.</para>
1514
    /// </summary>
1515

    
1516
    public static Feature<String> TRACE_LISTENER_OUTPUT_FILE = new Feature<String>(
1517
            net.sf.saxon.lib.Feature.TRACE_LISTENER_OUTPUT_FILE);
1518

    
1519
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1520

    
1521

    
1522
    /// <summary><para>If this option is set, Saxon will output (to the standard error output) detailed
1523
    ///                information about the rewrites to the expression tree made by the optimizer. This
1524
    ///                information is mainly useful for internal system debugging, but it is also possible
1525
    ///                to digest it to analyze the ways in which the expression has been optimized for the
1526
    ///                purpose of performance analysis and tuning.</para>
1527
    /// </summary>
1528

    
1529
    public static Feature<bool> TRACE_OPTIMIZER_DECISIONS = new Feature<bool>(
1530
            net.sf.saxon.lib.Feature.TRACE_OPTIMIZER_DECISIONS);
1531

    
1532
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1533

    
1534

    
1535
    /// <summary><para>Selects an implementation of the Saxon tree model. The default is
1536
    ///                    <code>TINY_TREE</code>.</para>
1537
    /// </summary>
1538
    /// <remarks>
1539
    ///            <para>For running XQuery Update, use the linked tree, because it is the only implementation
1540
    ///                that is updateable.</para>
1541
    ///        
1542
    /// </remarks>
1543

    
1544
    public static Feature<int> TREE_MODEL = new Feature<int>(
1545
            net.sf.saxon.lib.Feature.TREE_MODEL);
1546

    
1547
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1548

    
1549

    
1550
    /// <summary><para>Selects an implementation of the Saxon tree model. The default is
1551
    ///                    <code>tinyTree</code>.</para>
1552
    /// </summary>
1553
    /// <remarks>
1554
    ///            <para>For running XQuery Update, use the linked tree, because it is the only implementation
1555
    ///                that is updateable.</para>
1556
    ///        
1557
    /// </remarks>
1558

    
1559
    public static Feature<String> TREE_MODEL_NAME = new Feature<String>(
1560
            net.sf.saxon.lib.Feature.TREE_MODEL_NAME);
1561

    
1562
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1563

    
1564

    
1565
    /// <summary><para>The supplied <code>UnparsedTextURIResolver</code> will be used to resolve
1566
    ///                (dereference) all URIs specifed in calls to the <code>unparsed-text()</code>,
1567
    ///                    <code>unparsed-text-lines()</code>, and <code>unparsed-text-available()</code>
1568
    ///                functions.</para>
1569
    /// </summary>
1570

    
1571
    public static Feature<net.sf.saxon.lib.UnparsedTextURIResolver> UNPARSED_TEXT_URI_RESOLVER = new Feature<net.sf.saxon.lib.UnparsedTextURIResolver>(
1572
            net.sf.saxon.lib.Feature.UNPARSED_TEXT_URI_RESOLVER);
1573

    
1574
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1575

    
1576

    
1577
    /// <summary><para>An instance of the specified <code>UnparsedTextURIResolver</code> class will be
1578
    ///                created, and used to resolve (dereference) all URIs specifed in calls to the
1579
    ///                    <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>, and
1580
    ///                    <code>unparsed-text-available()</code> functions.</para>
1581
    /// </summary>
1582

    
1583
    public static Feature<String> UNPARSED_TEXT_URI_RESOLVER_CLASS = new Feature<String>(
1584
            net.sf.saxon.lib.Feature.UNPARSED_TEXT_URI_RESOLVER_CLASS);
1585

    
1586
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1587

    
1588

    
1589
    /// <summary><para>An instance of the specified <code>URIResolver</code> class will be created, and used
1590
    ///                to resolve (dereference) all URIs specifed in calls to the <code>doc()</code> and
1591
    ///                    <code>document()</code> functions, as well as URIs used in
1592
    ///                    <code>xsl:include</code> and <code>xsl:import</code> and location hints for
1593
    ///                XQuery modules and XSD schema documents.</para>
1594
    /// </summary>
1595

    
1596
    public static Feature<String> URI_RESOLVER_CLASS = new Feature<String>(
1597
            net.sf.saxon.lib.Feature.URI_RESOLVER_CLASS);
1598

    
1599
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1600

    
1601

    
1602
    /// <summary><para>This option determines whether a <code>TransformerHandler</code> created with this
1603
    ///                    <code>TransformerFactory</code> or <code>Configuration</code> recognizes the
1604
    ///                JAXP-defined processing instructions <code>Result.PI_DISABLE_OUTPUT_ESCAPING</code>
1605
    ///                and <code>Result.PI_ENABLE_OUTPUT_ESCAPING</code> in the input stream as
1606
    ///                instructions to disable or to re-enable output escaping. The default value is
1607
    ///                    <b>false</b>.</para>
1608
    /// </summary>
1609

    
1610
    public static Feature<bool> USE_PI_DISABLE_OUTPUT_ESCAPING = new Feature<bool>(
1611
            net.sf.saxon.lib.Feature.USE_PI_DISABLE_OUTPUT_ESCAPING);
1612

    
1613
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1614

    
1615

    
1616
    /// <summary><para>This option is relevant only when the TinyTree is used; it determines whether (for a
1617
    ///                validated document) a cache will be maintained containing the typed values of nodes.</para>
1618
    /// </summary>
1619
    /// <remarks>
1620
    ///            <para>Typed values are held in the cache only for elements and attributes whose type is
1621
    ///                other than string, untypedAtomic, or anyURI. The default value is true. Setting this
1622
    ///                value to false can reduce memory requirements at the cost of requiring recomputation
1623
    ///                of typed values on each access.</para>
1624
    ///        
1625
    /// </remarks>
1626

    
1627
    public static Feature<bool> USE_TYPED_VALUE_CACHE = new Feature<bool>(
1628
            net.sf.saxon.lib.Feature.USE_TYPED_VALUE_CACHE);
1629

    
1630
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1631

    
1632

    
1633
    /// <summary><para>This option determines whether or not to use the <code>xsi:schemaLocation</code>
1634
    ///                    and<code> xsi:noNamespaceSchemaLocation</code> attributes in an instance
1635
    ///                document to locate a schema for validation.</para>
1636
    /// </summary>
1637
    /// <remarks>
1638
    ///            <para>Note, these attribute are only consulted if validation is requested; the presence of
1639
    ///                one of these attributes never by itself triggers validation.</para>
1640
    ///        
1641
    /// </remarks>
1642

    
1643
    public static Feature<bool> USE_XSI_SCHEMA_LOCATION = new Feature<bool>(
1644
            net.sf.saxon.lib.Feature.USE_XSI_SCHEMA_LOCATION);
1645

    
1646
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1647

    
1648

    
1649
    /// <summary><para>This option determines whether non-fatal validation errors in XQuery or XSLT result
1650
    ///                documents should result in comments being inserted into the result tree. The
1651
    ///                command-line flag <code>-outval:recover</code> sets both this option and the
1652
    ///                    <see cref="VALIDATION_WARNINGS" /> option.</para>
1653
    /// </summary>
1654

    
1655
    public static Feature<bool> VALIDATION_COMMENTS = new Feature<bool>(
1656
            net.sf.saxon.lib.Feature.VALIDATION_COMMENTS);
1657

    
1658
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1659

    
1660

    
1661
    /// <summary><para>This option indicates (if true) that errors occuring while validating a final result
1662
    ///                tree are not to be treated as fatal.</para>
1663
    /// </summary>
1664
    /// <remarks>
1665
    ///            <para>Regardless of the setting of this option, all validation errors are reported to the
1666
    ///                    <code>error()</code> method of the <code>ErrorListener</code>, and validation is
1667
    ///                terminated if the <code>error()</code> method throws an exception, or if the error
1668
    ///                limit set in the <code>ParseOptions</code> object is reached.</para>
1669
    ///            <para>This option primarily controls what happens at the end of a validation episode. If
1670
    ///                the validation episode detected one or more validation errors, then when this option
1671
    ///                is off, an exception is thrown, which will normally result in any query or
1672
    ///                stylesheet failing with a dynamic error, and no output file being written. If the
1673
    ///                option is on, no exception is thrown, and the output is written as if validation had
1674
    ///                been successful. Note in this case that any type annotations present in a result
1675
    ///                document are unreliable.</para>
1676
    ///            <para>If this option is set when running XSLT or XQuery, it is ignored as far as input
1677
    ///                files are concerned: validation errors in input files are still fatal. However, if
1678
    ///                the option is set and a validation error occurs in a final output file, the output
1679
    ///                file is still written and the process terminates as if successful.</para>
1680
    ///            <para>The detailed interpretation of this option changed in Saxon 9.5.</para>
1681
    ///        
1682
    /// </remarks>
1683

    
1684
    public static Feature<bool> VALIDATION_WARNINGS = new Feature<bool>(
1685
            net.sf.saxon.lib.Feature.VALIDATION_WARNINGS);
1686

    
1687
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1688

    
1689

    
1690
    /// <summary><para>Indicates whether a warning message should be notified (to the
1691
    ///                <code>ErrorListener</code>) if running Saxon against an XSLT stylesheet that
1692
    ///                specifies <code>version="1.0"</code>.</para>
1693
    /// </summary>
1694
    /// <remarks>
1695
    ///            <para>From Saxon 9.8, the warning is no longer output (since XSLT 3.0 does not require
1696
    ///                it), so this option is ignored.</para>
1697
    ///            
1698
    ///        
1699
    /// </remarks>
1700

    
1701
    public static Feature<bool> VERSION_WARNING = new Feature<bool>(
1702
            net.sf.saxon.lib.Feature.VERSION_WARNING);
1703

    
1704
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1705

    
1706

    
1707
    /// <summary><para>Indicates whether source documents should have any XInclude directives expanded.</para>
1708
    /// </summary>
1709
    /// <remarks>
1710
    ///            <para>The default is false. The option applies to all input XML documents, including
1711
    ///                stylesheets and schema documents. It can be overridden for individual documents
1712
    ///                using the <see cref="net.sf.saxon.lib.ParseOptions" /> class.</para>
1713
    ///            <para>This option relies on support in the underlying XML parser. If the XML parser does
1714
    ///                not support XInclude processing, the option is ignored.</para>
1715
    ///        
1716
    /// </remarks>
1717

    
1718
    public static Feature<bool> XINCLUDE = new Feature<bool>(
1719
            net.sf.saxon.lib.Feature.XINCLUDE);
1720

    
1721
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1722

    
1723

    
1724
    /// <summary><para>This determines the XML version used by the <code>Configuration</code>.</para>
1725
    /// </summary>
1726
    /// <remarks>
1727
    ///            <para>Note that source documents specifying <code>xml version="1.0"</code> or
1728
    ///                    <code>"1.1"</code> are accepted regardless of this setting. The effect of this
1729
    ///                switch is to change the validation rules for types such as <code>xs:Name</code> and
1730
    ///                    <code>xs:NCName</code>, to change the characters allowed in names within XPath
1731
    ///                expressions (etc.), to change the meaning of <code>\i</code> and <code>\c</code> in
1732
    ///                regular expressions, and to determine whether the serializer allows XML 1.1
1733
    ///                documents to be constructed. </para>
1734
    ///            <para>The default is currently 1.0, but may change.</para>
1735
    ///        
1736
    /// </remarks>
1737

    
1738
    public static Feature<String> XML_VERSION = new Feature<String>(
1739
            net.sf.saxon.lib.Feature.XML_VERSION);
1740

    
1741
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1742

    
1743

    
1744
    /// <summary><para>Sets the value of a parser feature flag. The feature name is any fully-qualified
1745
    ///                URI.</para>
1746
    /// </summary>
1747
    /// <remarks>
1748
    ///            <para>For example if the parser supports a feature
1749
    ///                    <code>http://xml.org/sax/features/external-parameter-entities</code> then this
1750
    ///                can be set by setting the value of the Configuration property:
1751
    ///                    <code>http://saxon.sf.net/feature/parserFeature?uri=http%3A//xml.org/sax/features/external-parameter-entities</code>
1752
    ///                to true.</para>
1753
    ///        
1754
    /// </remarks>
1755

    
1756
    public static Feature<bool> XML_PARSER_FEATURE = new Feature<bool>(
1757
            net.sf.saxon.lib.Feature.XML_PARSER_FEATURE);
1758

    
1759
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1760

    
1761

    
1762
    /// <summary><para>Sets the value of a parser property flag. The property name is any fully-qualified
1763
    ///                URI.</para>
1764
    /// </summary>
1765
    /// <remarks>
1766
    ///            <para>For example if the parser supports a property
1767
    ///                    <code>http://apache.org/xml/properties/schema/external-schemaLocation</code>
1768
    ///                then this can be set using the value of the Configuration property:
1769
    ///                    <code>http://saxon.sf.net/feature/parserProperty?uri=http%3A//apache.org/xml/properties/schema/external-schemaLocation</code>
1770
    ///                to the required value.</para>
1771
    ///        
1772
    /// </remarks>
1773

    
1774
    public static Feature<bool> XML_PARSER_PROPERTY = new Feature<bool>(
1775
            net.sf.saxon.lib.Feature.XML_PARSER_PROPERTY);
1776

    
1777
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1778

    
1779

    
1780
    /// <summary><para>Determines whether XQuery Update syntax is accepted.</para>
1781
    /// </summary>
1782
    /// <remarks>
1783
    ///            <para>If true, update syntax is accepted, if false, it is not accepted. Setting the value to 
1784
    ///                true does not mean that the query has to use update syntax, only that it may do so.</para>
1785
    ///            <para>From Saxon 9.6, XQuery Update syntax and XQuery 3.0 syntax can be mixed, although
1786
    ///                this combination is not defined by any W3C specification at the time of writing.</para>
1787
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1788
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1789
    ///            <para>On the command line, this option is combined with the option "discard" which
1790
    ///                indicates that updates are allowed, but the updates are not written back to
1791
    ///                filestore. This does not correspond to any option in the Java API, where writing an
1792
    ///                updated document back to filestore only happens if explicitly requested.</para>
1793
    ///        
1794
    /// </remarks>
1795

    
1796
    public static Feature<bool> XQUERY_ALLOW_UPDATE = new Feature<bool>(
1797
            net.sf.saxon.lib.Feature.XQUERY_ALLOW_UPDATE);
1798

    
1799
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1800

    
1801

    
1802
    /// <summary><para>This option defines the default value of the construction mode in the XQuery static
1803
    ///                context (overridable in the query prolog).</para>
1804
    /// </summary>
1805
    /// <remarks>
1806
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1807
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1808
    ///        
1809
    /// </remarks>
1810

    
1811
    public static Feature<String> XQUERY_CONSTRUCTION_MODE = new Feature<String>(
1812
            net.sf.saxon.lib.Feature.XQUERY_CONSTRUCTION_MODE);
1813

    
1814
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1815

    
1816

    
1817
    /// <summary><para>This property defines the default namespace for elements and types that are not
1818
    ///                qualified by a namespace prefix.</para>
1819
    /// </summary>
1820
    /// <remarks>
1821
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1822
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1823
    ///        
1824
    /// </remarks>
1825

    
1826
    public static Feature<Object> XQUERY_DEFAULT_ELEMENT_NAMESPACE = new Feature<Object>(
1827
            net.sf.saxon.lib.Feature.XQUERY_DEFAULT_ELEMENT_NAMESPACE);
1828

    
1829
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1830

    
1831

    
1832
    /// <summary><para>This property defines the default namespace for function names that are not qualified
1833
    ///                by a namespace prefix.</para>
1834
    /// </summary>
1835
    /// <remarks>
1836
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1837
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1838
    ///        
1839
    /// </remarks>
1840

    
1841
    public static Feature<Object> XQUERY_DEFAULT_FUNCTION_NAMESPACE = new Feature<Object>(
1842
            net.sf.saxon.lib.Feature.XQUERY_DEFAULT_FUNCTION_NAMESPACE);
1843

    
1844
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1845

    
1846

    
1847
    /// <summary><para>This property defines how the empty sequence is handled in XQuery sorting (the "order
1848
    ///                by" clause). If true, <code>()</code> comes at the start of the sorted sequence; if
1849
    ///                false, it comes last.</para>
1850
    /// </summary>
1851
    /// <remarks>
1852
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1853
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1854
    ///        
1855
    /// </remarks>
1856

    
1857
    public static Feature<bool> XQUERY_EMPTY_LEAST = new Feature<bool>(
1858
            net.sf.saxon.lib.Feature.XQUERY_EMPTY_LEAST);
1859

    
1860
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1861

    
1862

    
1863
    /// <summary><para>This property defines the default value of the <code>inherit-namespaces</code>
1864
    ///                property in the XQuery static context.</para>
1865
    /// </summary>
1866
    /// <remarks>
1867
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1868
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1869
    ///        
1870
    /// </remarks>
1871

    
1872
    public static Feature<bool> XQUERY_INHERIT_NAMESPACES = new Feature<bool>(
1873
            net.sf.saxon.lib.Feature.XQUERY_INHERIT_NAMESPACES);
1874

    
1875
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1876

    
1877

    
1878
    /// <summary><para>If the value is false, then when an <code>import module</code> declaration is
1879
    ///                encountered for a module URI that is already among the known loaded modules (or
1880
    ///                modules in the process of being compiled), the <code>import module</code> is treated
1881
    ///                as a reference to the existing module. If the value is true, the system first checks
1882
    ///                whether the supplied "location hints" match the known location of the existing
1883
    ///                module, and the existing module is used only if there is a match.</para>
1884
    /// </summary>
1885

    
1886
    public static Feature<bool> XQUERY_MULTIPLE_MODULE_IMPORTS = new Feature<bool>(
1887
            net.sf.saxon.lib.Feature.XQUERY_MULTIPLE_MODULE_IMPORTS);
1888

    
1889
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1890

    
1891

    
1892
    /// <summary><para>This property defines whether "boundary space" (insignificant space in direct element
1893
    ///                constructors) should be retained or not.</para>
1894
    /// </summary>
1895
    /// <remarks>
1896
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1897
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1898
    ///        
1899
    /// </remarks>
1900

    
1901
    public static Feature<bool> XQUERY_PRESERVE_BOUNDARY_SPACE = new Feature<bool>(
1902
            net.sf.saxon.lib.Feature.XQUERY_PRESERVE_BOUNDARY_SPACE);
1903

    
1904
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1905

    
1906

    
1907
    /// <summary><para>This property defines whether unused namespace declarations are retained by XQuery
1908
    ///                element copy operations.</para>
1909
    /// </summary>
1910
    /// <remarks>
1911
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1912
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1913
    ///        
1914
    /// </remarks>
1915

    
1916
    public static Feature<bool> XQUERY_PRESERVE_NAMESPACES = new Feature<bool>(
1917
            net.sf.saxon.lib.Feature.XQUERY_PRESERVE_NAMESPACES);
1918

    
1919
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1920

    
1921

    
1922
    /// <summary><para>This property defines the default expected context item type for a query.</para>
1923
    /// </summary>
1924
    /// <remarks>
1925
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1926
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1927
    ///        
1928
    /// </remarks>
1929

    
1930
    public static Feature<String> XQUERY_REQUIRED_CONTEXT_ITEM_TYPE = new Feature<String>(
1931
            net.sf.saxon.lib.Feature.XQUERY_REQUIRED_CONTEXT_ITEM_TYPE);
1932

    
1933
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1934

    
1935

    
1936
    /// <summary><para>A query will automatically be schema-aware if it contains an <code>import
1937
    ///                    schema</code> declaration. This property allows a query to be marked as
1938
    ///                schema-aware even if it contains no <code>import schema</code> declaration. It is
1939
    ///                necessary for a query to be compiled as schema-aware if it is to handle typed
1940
    ///                (validated) input documents in which nodes have type annotations based on their
1941
    ///                schema-defined type.</para>
1942
    /// </summary>
1943
    /// <remarks>
1944
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1945
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1946
    ///        
1947
    /// </remarks>
1948

    
1949
    public static Feature<bool> XQUERY_SCHEMA_AWARE = new Feature<bool>(
1950
            net.sf.saxon.lib.Feature.XQUERY_SCHEMA_AWARE);
1951

    
1952
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1953

    
1954

    
1955
    /// <summary><para>The specified class is instantiated to create an <code>ErrorListener</code>, and all
1956
    ///                reports of static errors in a query will go to this <code>ErrorListener</code>.</para>
1957
    /// </summary>
1958
    /// <remarks>
1959
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1960
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1961
    ///            <para>In the absence of this property, the global <code>ErrorListener</code> specified as
1962
    ///                the value of the <see cref="ERROR_LISTENER_CLASS" />
1963
    ///                property is used.</para>
1964
    ///        
1965
    /// </remarks>
1966

    
1967
    public static Feature<String> XQUERY_STATIC_ERROR_LISTENER_CLASS = new Feature<String>(
1968
            net.sf.saxon.lib.Feature.XQUERY_STATIC_ERROR_LISTENER_CLASS);
1969

    
1970
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1971

    
1972

    
1973
    /// <summary><para>This property determines the version of XQuery used by the
1974
    ///                <code>Configuration</code>.</para>
1975
    /// </summary>
1976
    /// <remarks>
1977
    ///            <para>From Saxon 9.8, an XQuery 3.1 processor is always used by default. So setting this
1978
    ///                property has no effect.</para>
1979
    ///            
1980
    ///        
1981
    /// </remarks>
1982

    
1983
    public static Feature<String> XQUERY_VERSION = new Feature<String>(
1984
            net.sf.saxon.lib.Feature.XQUERY_VERSION);
1985

    
1986
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1987

    
1988

    
1989
    /// <summary><para>This property determines the version of XML Schema used by the
1990
    ///                <code>Configuration</code>.</para>
1991
    /// </summary>
1992
    /// <remarks>
1993
    ///            <para>From Saxon 9.8, the default is XSD 1.1. If XSD 1.0 is
1994
    ///                selected, XSD 1.1 features will be rejected, with the exception of the version
1995
    ///                control attributes that allow sections of the schema to be marked as requiring XSD
1996
    ///                1.0 or XSD 1.1.</para>
1997
    ///        
1998
    /// </remarks>
1999

    
2000
    public static Feature<String> XSD_VERSION = new Feature<String>(
2001
            net.sf.saxon.lib.Feature.XSD_VERSION);
2002

    
2003
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2004

    
2005

    
2006
    /// <summary><para>This property indicates whether assertions (XSLT 3.0 xsl:assert instructions) are
2007
    ///                enabled or disabled. They are disabled by default. Setting this property on causes
2008
    ///                assertions to be enabled at compile time for all XSLT packages compiled using the
2009
    ///                default configuration options.</para>
2010
    /// </summary>
2011
    /// <remarks>
2012
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2013
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2014
    ///                acts as a default.</para>
2015
    ///            <para>If assertions have been enabled at compile time for a particular package, they can
2016
    ///                still be disabled at run-time (for all packages) by setting an option on the
2017
    ///                    <code>Xslt30Transformer</code>. But if assertions were disabled at compile time,
2018
    ///                enabling them at run-time has no effect.</para>
2019
    ///        
2020
    /// </remarks>
2021

    
2022
    public static Feature<bool> XSLT_ENABLE_ASSERTIONS = new Feature<bool>(
2023
            net.sf.saxon.lib.Feature.XSLT_ENABLE_ASSERTIONS);
2024

    
2025
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2026

    
2027

    
2028
    /// <summary><para>This property indicates the name of a mode within a stylesheet in which execution
2029
    ///                (using template rules) should begin.</para>
2030
    /// </summary>
2031
    /// <remarks>
2032
    ///            <para>This option can be set for a particular XSLT transformation. When the option is set
2033
    ///                at the <code>Configuration</code> (or on a <code>TransformerFactory</code>), it acts
2034
    ///                as a default.</para>
2035
    ///        
2036
    /// </remarks>
2037

    
2038
    public static Feature<String> XSLT_INITIAL_MODE = new Feature<String>(
2039
            net.sf.saxon.lib.Feature.XSLT_INITIAL_MODE);
2040

    
2041
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2042

    
2043

    
2044
    /// <summary><para>This property indicates the name of a named template within a stylesheet where
2045
    ///                execution should begin.</para>
2046
    /// </summary>
2047
    /// <remarks>
2048
    ///            <para>This option can be set for a particular XSLT transformation. When the option is set
2049
    ///                at the <code>Configuration</code> level (or on a <code>TransformerFactory</code>),
2050
    ///                it acts as a default.</para>
2051
    ///        
2052
    /// </remarks>
2053

    
2054
    public static Feature<String> XSLT_INITIAL_TEMPLATE = new Feature<String>(
2055
            net.sf.saxon.lib.Feature.XSLT_INITIAL_TEMPLATE);
2056

    
2057
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2058

    
2059

    
2060
    /// <summary><para>This property indicates whether stylesheets should be compiled with the ability to
2061
    ///                handle schema-typed input documents. By default a stylesheet is compiled to handle
2062
    ///                such input if it contains an <code>xsl:import-schema</code> instruction, and not
2063
    ///                otherwise. It is necessary for a stylesheet to be compiled as schema-aware if it is
2064
    ///                to handle typed (validated) input documents in which nodes have type annotations
2065
    ///                based on their schema-defined type.</para>
2066
    /// </summary>
2067
    /// <remarks>
2068
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2069
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2070
    ///                acts as a default.</para>
2071
    ///        
2072
    /// </remarks>
2073

    
2074
    public static Feature<bool> XSLT_SCHEMA_AWARE = new Feature<bool>(
2075
            net.sf.saxon.lib.Feature.XSLT_SCHEMA_AWARE);
2076

    
2077
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2078

    
2079

    
2080
    /// <summary><para>The specified class is instantiated to create an <code>ErrorListener</code>, and all
2081
    ///                reports of static errors in a stylesheet will go to this
2082
    ///                <code>ErrorListener</code>.</para>
2083
    /// </summary>
2084
    /// <remarks>
2085
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2086
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2087
    ///                acts as a default.</para>
2088
    ///            <para>In the absence of this property, the global <code>ErrorListener</code> specified as
2089
    ///                the value of the <see cref="ERROR_LISTENER_CLASS" />
2090
    ///                property is used.</para>
2091
    ///        
2092
    /// </remarks>
2093

    
2094
    public static Feature<String> XSLT_STATIC_ERROR_LISTENER_CLASS = new Feature<String>(
2095
            net.sf.saxon.lib.Feature.XSLT_STATIC_ERROR_LISTENER_CLASS);
2096

    
2097
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2098

    
2099

    
2100
    /// <summary><para>This property defines a <code>URIResolver</code> used when dereferencing the URIs
2101
    ///                that appear in the <code>href</code> attributes of the <code>xsl:include</code> and
2102
    ///                    <code>xsl:import</code> declarations. Note that this defaults to the setting of
2103
    ///                the global <code>URI_RESOLVER</code> property.</para>
2104
    /// </summary>
2105
    /// <remarks>
2106
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2107
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2108
    ///                acts as a default.</para>
2109
    ///            <para>In the absence of this property, the global <code>URIResolver</code> specified as the
2110
    ///                value of the <see cref="URI_RESOLVER_CLASS" /> property
2111
    ///                is used.</para>
2112
    ///        
2113
    /// </remarks>
2114

    
2115
    public static Feature<String> XSLT_STATIC_URI_RESOLVER_CLASS = new Feature<String>(
2116
            net.sf.saxon.lib.Feature.XSLT_STATIC_URI_RESOLVER_CLASS);
2117

    
2118
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2119

    
2120

    
2121
    /// <summary><para>This property determines the version of XSLT to be supported by default.</para>
2122
    /// </summary>
2123
    /// <remarks>
2124
    ///            <para>From Saxon 9.8, an XSLT 3.0 processor is always used by default. So setting this
2125
    ///                property has no effect.</para>
2126
    ///            
2127
    ///        
2128
    /// </remarks>
2129

    
2130
    public static Feature<String> XSLT_VERSION = new Feature<String>(
2131
            net.sf.saxon.lib.Feature.XSLT_VERSION);
2132

    
2133
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2134

    
2135

    
2136
    /// <summary><para>This property sets a limit on the amount of backtracking performed during regular expression evaluation.</para>
2137
    /// </summary>
2138
    /// <remarks>
2139
    ///            <para>The default is 10000000 (ten million) which typically represents an evaluation time of about ten seconds.
2140
    ///            After this time, evaluation of the regular expression will fail rather than making further attempts to find a
2141
    ///            match. If this limit is reached, it often suggests that there might be a better way of writing the regular expression.
2142
    ///            The value can be set to -1 (minus one) to mean "unlimited".</para>
2143
    ///            <para>Excessive backtracking is usually caused by nested loops in the regular expression, combined with processing
2144
    ///            of long input strings. Try to ensure that when nested loops are used, there is an unambiguous condition that causes
2145
    ///            the inner loop to terminate. For example <code>(/[^/]*)+</code> is fine (it matches a sequence of path segments separated
2146
    ///                by <code>/</code> characters), because the presence of <code>/</code> forces the inner loop to terminate. By contrast,
2147
    ///                <code>(/.*)+</code> matches the same input, but in many different ways, which could lead to excessive backtracking
2148
    ///            to no useful purpose.</para>
2149
    ///        
2150
    /// </remarks>
2151

    
2152
    public static Feature<int> REGEX_BACKTRACKING_LIMIT = new Feature<int>(
2153
            net.sf.saxon.lib.Feature.REGEX_BACKTRACKING_LIMIT);
2154

    
2155
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2156

    
2157

    
2158
    /// <summary><para>The XSD 1.1 specification states that XPath version 2.0 is used for expressions appearing in assertions and type
2159
    ///                alternatives. This option allows XPath 3.0 or 3.1 to be used instead.</para>
2160
    /// </summary>
2161
    /// <remarks>
2162
    ///            <para>The recognized values are the integers 20, 30, and 31 representing versions 2.0, 3.0, and 3.1 respectively.</para>           
2163
    ///        
2164
    /// </remarks>
2165

    
2166
    public static Feature<int> XPATH_VERSION_FOR_XSD = new Feature<int>(
2167
            net.sf.saxon.lib.Feature.XPATH_VERSION_FOR_XSD);
2168

    
2169
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2170

    
2171

    
2172
    /// <summary><para>The XSLT 3.0 specification states that processors are required to support XPath 3.0 expressions within stylesheets, together
2173
    ///                with some extensions (maps) selected from the XPath 3.1 specification. Support for the full syntax of XPath 3.1 is
2174
    ///                optional, but it is the default in Saxon. This option allows a different XPath language level to be selected.</para>
2175
    /// </summary>
2176
    /// <remarks>
2177
    ///            <para>The integer values 20, 30, and 31 denote XPath 2.0, 3.0, and 3.1 respectively, while the value 305 denotes XPath 3.0
2178
    ///                with the extensions defined in the XSLT 3.0 specification.</para>
2179
    ///        
2180
    /// </remarks>
2181

    
2182
    public static Feature<int> XPATH_VERSION_FOR_XSLT = new Feature<int>(
2183
            net.sf.saxon.lib.Feature.XPATH_VERSION_FOR_XSLT);
2184

    
2185
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2186

    
2187

    
2188
    /// <summary><para>Saxon-EE performs inlining of user-defined functions that are sufficiently simple: they must not be recursive,
2189
    ///                and they must be below a certain size. This option defines the size.</para>
2190
    /// </summary>
2191
    /// <remarks>
2192
    ///            <para>The value is (roughly) the number of nodes in the expression tree representing the function body. This
2193
    ///                includes both explicit subexpressions, and subexpressions added by Saxon itself to perform implicit
2194
    ///                operations such as type checking or conversion of function arguments. The default value is 100.</para>
2195
    ///        
2196
    /// </remarks>
2197

    
2198
    public static Feature<int> THRESHOLD_FOR_FUNCTION_INLINING = new Feature<int>(
2199
            net.sf.saxon.lib.Feature.THRESHOLD_FOR_FUNCTION_INLINING);
2200

    
2201
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2202

    
2203

    
2204
    /// <summary><para>Saxon-EE generates bytecode to give faster execution of frequently-evaluated subexpressions.
2205
    ///                Bytecode is generated when a candidate expression has been evaluated a certain number of
2206
    ///                times, controlled by this parameter.
2207
    ///            </para>
2208
    /// </summary>
2209
    /// <remarks>
2210
    ///            <para>Setting this parameter to 0 (or any negative value) has the effect of disabling bytecode
2211
    ///                generation completely. Setting the parameter to a positive value has the effect of enabling
2212
    ///                bytecode generation if it is not already enabled. Setting the value to 1 (one) causes bytecode
2213
    ///                to be generated for candidate expressions the first time it is executed.</para>
2214
    ///        
2215
    /// </remarks>
2216

    
2217
    public static Feature<int> THRESHOLD_FOR_HOTSPOT_BYTE_CODE = new Feature<int>(
2218
            net.sf.saxon.lib.Feature.THRESHOLD_FOR_HOTSPOT_BYTE_CODE);
2219

    
2220
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2221

    
2222

    
2223
} 
2224
}
2225

    
2226
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2227
// Copyright (c) 2018 Saxonica Limited.
2228
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
2229
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
2230
// This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0.
2231
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
(5-5/13)