Project

Profile

Help

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

he / latest10 / hen / csource / api / Feature.cs @ aac4a1be

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, 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 10 include the use of type aliases (<code>type(...)</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>.{. + 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>If run-time tracing of stylesheet or query execution is required, then the code must
221
    ///                be compiled with tracing enabled.</para>
222
    /// </summary>
223
    /// <remarks>
224
    ///            <para>Default is false. This option causes code to be
225
    ///                compiled that makes calls to a <see cref="net.sf.saxon.lib.TraceListener" />, but this
226
    ///                has no effect unless a <code>TraceListener</code> is registered at execution
227
    ///                time.</para>
228
    ///        
229
    /// </remarks>
230

    
231
    public static Feature<bool> COMPILE_WITH_TRACING = new Feature<bool>(
232
            net.sf.saxon.lib.Feature.COMPILE_WITH_TRACING);
233

    
234
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
235

    
236

    
237
    /// <summary><para>This attribute cannot be set on the <see cref="net.sf.saxon.Configuration" /> itself,
238
    ///                but it can be set on various JAXP factory objects such as a
239
    ///                <code>TransformerFactory</code> or <code>DocumentBuilderFactory</code>, to
240
    ///                ensure that several such factories use the same <code>Configuration</code>.</para>
241
    /// </summary>
242
    /// <remarks>
243
    ///            <para>Note that other configuration options are held in the <code>Configuration</code> object,
244
    ///                so setting this attribute will cancel all others that have been set. Also, if two
245
    ///                factories share the same <code>Configuration</code>, then setting an attribute on
246
    ///                one affects all the others.</para>
247
    ///        
248
    /// </remarks>
249

    
250
    public static Feature<net.sf.saxon.Configuration> CONFIGURATION = new Feature<net.sf.saxon.Configuration>(
251
            net.sf.saxon.lib.Feature.CONFIGURATION);
252

    
253
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
254

    
255

    
256
    /// <summary><para>Defines a configuration file to be applied to the configuration.</para>
257
    /// </summary>
258
    /// <remarks>
259
    ///            <para>This attribute cannot be set on the <see cref="net.sf.saxon.Configuration" /> itself, but it can be
260
    ///                set on various JAXP factory objects such as a <code>TransformerFactory</code> or
261
    ///                    <code>DocumentBuilderFactory</code>. It is particularly useful when running
262
    ///                transformations via the Ant xslt task, where it can be set as follows to define all
263
    ///                configuration settings: </para>
264
    ///            <para><code>&lt;factory name="net.sf.saxon.TransformerFactoryImpl"&gt; &lt;attribute
265
    ///                    name="http://saxon.sf.net/feature/configuration-file"
266
    ///                    value="c:/saxon/config.xml"/&gt; &lt;/factory&gt;</code>
267
    ///            </para>
268
    ///        
269
    /// </remarks>
270

    
271
    public static Feature<String> CONFIGURATION_FILE = new Feature<String>(
272
            net.sf.saxon.lib.Feature.CONFIGURATION_FILE);
273

    
274
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
275

    
276

    
277
    /// <summary><para>This option is set to indicate that bytecode generation should be run in debugging
278
    ///                mode; it injects diagnostic tracing calls into the generated bytecode. This should
279
    ///                be used only if requested by Saxonica support to diagnose a problem related to
280
    ///                bytecode generation.</para>
281
    /// </summary>
282

    
283
    public static Feature<bool> DEBUG_BYTE_CODE = new Feature<bool>(
284
            net.sf.saxon.lib.Feature.DEBUG_BYTE_CODE);
285

    
286
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
287

    
288

    
289
    /// <summary><para>This option is relevant only if <code>DISPLAY_BYTE_CODE</code> is set to true. It
290
    ///                defines a directory to which files containing bytecode in human-readable form will
291
    ///                be written. There will be one such file for each generated class, with a filename
292
    ///                designed to give some kind of clue as to its relationship to the source code.</para>
293
    /// </summary>
294
    /// <remarks>
295
    ///            <para>The default value is the directory <code>saxonByteCode</code> within the current
296
    ///                working directory.</para>
297
    ///            <para>The named directory is created if it does not already exist.</para>
298
    ///            <para>Because the generation of class names involves random numbers, files will tend to
299
    ///                accumulate in the supplied directory, even when the same source code is compiled
300
    ///                repeatedly.</para>
301
    ///        
302
    /// </remarks>
303

    
304
    public static Feature<String> DEBUG_BYTE_CODE_DIR = new Feature<String>(
305
            net.sf.saxon.lib.Feature.DEBUG_BYTE_CODE_DIR);
306

    
307
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
308

    
309

    
310
    /// <summary><para>This option determines the collation that is used for comparing strings when no
311
    ///                explicit collation is requested. It is not necessary for this collation to exist (or
312
    ///                to have been registered) when setting this option; it only needs to exist by the
313
    ///                time it is used.</para>
314
    /// </summary>
315
    /// <remarks>
316
    ///            <para>In XSLT it is possible to override this setting using the
317
    ///                    <code>[xsl:]default-collation</code> attribute on any stylesheet element. In
318
    ///                XQuery, it can be overridden using the <code>declare default collation</code>
319
    ///                declaration in the query prolog, or via a setter method in class
320
    ///                    <see cref="net.sf.saxon.query.StaticQueryContext" />.</para>
321
    ///            <para>If no value is specified, the Unicode codepoint collation is used.</para>
322
    ///        
323
    /// </remarks>
324

    
325
    public static Feature<String> DEFAULT_COLLATION = new Feature<String>(
326
            net.sf.saxon.lib.Feature.DEFAULT_COLLATION);
327

    
328
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
329

    
330

    
331
    /// <summary><para>This determines the collection that is used when the <code>fn:collection()</code>
332
    ///                function is called with no arguments; the effect is the same as if it were called
333
    ///                passing the URI that is the value of this configuration property.</para>
334
    /// </summary>
335

    
336
    public static Feature<String> DEFAULT_COLLECTION = new Feature<String>(
337
            net.sf.saxon.lib.Feature.DEFAULT_COLLECTION);
338

    
339
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
340

    
341

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

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

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

    
353

    
354
    /// <summary><para>This option determines the language that is used by <code>format-date()</code>,
355
    ///                    <code>xsl:number</code> and similar constructs if no language code is supplied
356
    ///                explicitly. If no value is given for this property, the default is taken from the
357
    ///                Java Locale, which in turn typically depends on settings for the current user in the
358
    ///                operating system.</para>
359
    /// </summary>
360

    
361
    public static Feature<String> DEFAULT_LANGUAGE = new Feature<String>(
362
            net.sf.saxon.lib.Feature.DEFAULT_LANGUAGE);
363

    
364
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
365

    
366

    
367
    /// <summary><para>Determines which regular expression engine should be used for evaluating regular expressions occuring in constructs
368
    ///            such as <code>fn:matches()</code>, <code>fn:replace</code>, and <code>xsl:analyze-string</code>, and also
369
    ///            in the pattern facet of a schema.</para>
370
    /// </summary>
371
    /// <remarks>
372
    ///            <para>On the Java platform the permitted values are "S" (default), and "J". The value "J" selects the regex engine
373
    ///            provided in the JDK in preference to the Saxon regular expression engine. This means that regular expressions must
374
    ///            follow the Java syntax and semantics rather than the XPath syntax and semantics.</para>
375
    ///            <para>On the .NET platform the permitted values are "S" (default), "J", and "N". The value "J" selects the regex engine
376
    ///                provided in the IKVMC run-time, which is derived from OpenJDK. The value "N" selects the regex engine provided
377
    ///            in the Microsoft .NET platform. In each case, the regular expression must follow the syntax and semantics of the selected
378
    ///            regex engine.</para>
379
    ///            <para>The choice of regular expression may be overridden in a particular invocation by appending the value ";s",
380
    ///            ";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>
381
    ///            <para>Use of this feature is not conformant with W3C specifications. Use of the setting "N", however, can be useful
382
    ///            when schemas have been written with the Microsoft schema processor in mind, since this uses the Microsoft regular
383
    ///            expression dialect rather than the W3C dialect.</para>
384
    ///        
385
    /// </remarks>
386

    
387
    public static Feature<String> DEFAULT_REGEX_ENGINE = new Feature<String>(
388
            net.sf.saxon.lib.Feature.DEFAULT_REGEX_ENGINE);
389

    
390
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
391

    
392

    
393
    /// <summary><para>This option disables the <code>xsl:evaluate</code> instruction.</para>
394
    /// </summary>
395
    /// <remarks>
396
    ///            <para>If set at stylesheet compile time, the feature is statically disabled. If set at 
397
    ///                run-time it is dynamically disabled. (These terms are defined in the XSLT 3.0 spec.) 
398
    ///                The feature is always disabled (statically) in Saxon-HE.</para>
399
    ///        
400
    /// </remarks>
401

    
402
    public static Feature<bool> DISABLE_XSL_EVALUATE = new Feature<bool>(
403
            net.sf.saxon.lib.Feature.DISABLE_XSL_EVALUATE);
404

    
405
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
406

    
407

    
408
    /// <summary><para>This option is set to indicate that bytecode generation should be run in display
409
    ///                mode. The effect is to output files (one per class) containing a human-readable
410
    ///                print of the generated bytecode. The files are placed in the directory identified by
411
    ///                the <code>DEBUG_BYTE_CODE_DIR</code> option.</para>
412
    /// </summary>
413

    
414
    public static Feature<bool> DISPLAY_BYTE_CODE = new Feature<bool>(
415
            net.sf.saxon.lib.Feature.DISPLAY_BYTE_CODE);
416

    
417
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
418

    
419

    
420
    /// <summary><para>If true, the XML parser is requested to perform validation of source documents
421
    ///                against their DTD. Default is false.</para>
422
    /// </summary>
423
    /// <remarks>
424
    ///            <para>This option establishes a default for use whenever source documents (not stylesheets
425
    ///                or schema documents) are parsed. The option can be overridden for individual
426
    ///                documents by setting the <see cref="net.sf.saxon.lib.ParseOptions" /> for that
427
    ///                individual document, for example from a <code>URIResolver</code>.</para>
428
    ///        
429
    /// </remarks>
430

    
431
    public static Feature<bool> DTD_VALIDATION = new Feature<bool>(
432
            net.sf.saxon.lib.Feature.DTD_VALIDATION);
433

    
434
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
435

    
436

    
437
    /// <summary><para>This option determines whether DTD validation failures should be treated as
438
    ///                recoverable. If the option is set, a validation failure is reported as a warning
439
    ///                rather than an error. The default is false.</para>
440
    /// </summary>
441
    /// <remarks>
442
    ///            <para>This option establishes a default for use whenever source documents (not stylesheets
443
    ///                or schema documents) are parsed. The option can be overridden for individual
444
    ///                documents by setting the <see cref="net.sf.saxon.lib.ParseOptions" /> for that
445
    ///                individual document, for example from a <code>URIResolver</code>.</para>
446
    ///        
447
    /// </remarks>
448

    
449
    public static Feature<bool> DTD_VALIDATION_RECOVERABLE = new Feature<bool>(
450
            net.sf.saxon.lib.Feature.DTD_VALIDATION_RECOVERABLE);
451

    
452
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
453

    
454

    
455
    /// <summary><para>Forces Saxon to do eager evaluation of expressions in contexts where normally it would do lazy evaluation,
456
    ///                for example when evaluating variables and function results. This can make for easier debugging.</para>
457
    /// </summary>
458
    /// <remarks>
459
    ///            <para>Note that this only applies to situations where Saxon would normally save a <code>Closure</code>
460
    ///            object as the result of an expression. It does not prevent Saxon from using pipelined evaluation of
461
    ///            intermediate expressions using iterators.</para>
462
    ///        
463
    /// </remarks>
464

    
465
    public static Feature<bool> EAGER_EVALUATION = new Feature<bool>(
466
            net.sf.saxon.lib.Feature.EAGER_EVALUATION);
467

    
468
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
469

    
470

    
471
    /// <summary><para>The supplied class is instantiated and the resulting <code>EntityResolver</code> is
472
    ///                used whenever Saxon itself creates an <code>XMLReader</code> for parsing source
473
    ///                documents. It is not used with a user-supplied <code>XMLReader</code>.</para>
474
    /// </summary>
475
    /// <remarks>
476
    ///            <para>The default value is <see cref="net.sf.saxon.lib.StandardEntityResolver" />. This is an entity
477
    ///                resolver that recognizes the names of many standard W3C DTDs and external entity
478
    ///                files, and resolves them against local copies issued with the Saxon software, to
479
    ///                avoid the need to fetch them from the web.</para>
480
    ///            <para>The property can be set to a zero-length string, in which case no
481
    ///                    <code>EntityResolver</code> will be used.</para>
482
    ///
483
    ///        
484
    /// </remarks>
485

    
486
    public static Feature<String> ENTITY_RESOLVER_CLASS = new Feature<String>(
487
            net.sf.saxon.lib.Feature.ENTITY_RESOLVER_CLASS);
488

    
489
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
490

    
491

    
492
    /// <summary><para>Setting the <code>ENVIRONMENT_VARIABLE_RESOLVER</code> causes the supplied object to
493
    ///                be registered as the environment variable resolver for the
494
    ///                    <code>Configuration</code>. The setting is global: it affects all queries and
495
    ///                transformations using this configuration.</para>
496
    /// </summary>
497
    /// <remarks>
498
    ///            <para>The environment variable resolver is used when the XPath functions
499
    ///                    <code>available-environment-variables()</code> or
500
    ///                    <code>environment-variable()</code> are called. Saxon essentially delegates the
501
    ///                evaluation of the function to the external resolver.</para>
502
    ///        
503
    /// </remarks>
504

    
505
    public static Feature<net.sf.saxon.lib.EnvironmentVariableResolver> ENVIRONMENT_VARIABLE_RESOLVER = new Feature<net.sf.saxon.lib.EnvironmentVariableResolver>(
506
            net.sf.saxon.lib.Feature.ENVIRONMENT_VARIABLE_RESOLVER);
507

    
508
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
509

    
510

    
511
    /// <summary><para>Setting <code>ENVIRONMENT_VARIABLE_RESOLVER_CLASS</code> causes an instance of the
512
    ///                supplied class to be created, and registered as the environment variable resolver
513
    ///                for the <code>Configuration</code>. The setting is global: it affects all queries
514
    ///                and transformations using this configuration.</para>
515
    /// </summary>
516
    /// <remarks>
517
    ///            <para>The environment variable resolver is used when the XPath functions
518
    ///                    <code>available-environment-variables()</code> or
519
    ///                    <code>environment-variable()</code> are called. Saxon essentially delegates the
520
    ///                evaluation of the function to the external resolver.</para>
521
    ///        
522
    /// </remarks>
523

    
524
    public static Feature<String> ENVIRONMENT_VARIABLE_RESOLVER_CLASS = new Feature<String>(
525
            net.sf.saxon.lib.Feature.ENVIRONMENT_VARIABLE_RESOLVER_CLASS);
526

    
527
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
528

    
529

    
530
    /// <summary><para><code>ERROR_LISTENER_CLASS</code> is the name of the class used to implement the JAXP
531
    ///                <code>ErrorListener</code>. This is used both at compile time and at run-time.</para>
532
    /// </summary>
533
    /// <remarks>
534
    ///            <para>Currently if this option is specified, the class is instantiated, and the same
535
    ///                instance is used for all processes running under this configuration. This may change
536
    ///                in future so that a new instance is created for each compilation or evaluation.</para>
537
    ///            <para>Finer control can be obtained by setting the <code>ErrorListener</code> for a
538
    ///                specific XSLT or XQuery compilation or evaluation.</para>
539
    ///        
540
    /// </remarks>
541

    
542
    public static Feature<String> ERROR_LISTENER_CLASS = new Feature<String>(
543
            net.sf.saxon.lib.Feature.ERROR_LISTENER_CLASS);
544

    
545
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
546

    
547

    
548
    /// <summary><para><code>EXPAND_ATTRIBUTE_DEFAULTS</code> determines whether fixed and default values
549
    ///                defined in a schema or DTD will be expanded (both on input and on output documents,
550
    ///                if validation is requested).</para>
551
    /// </summary>
552
    /// <remarks>
553
    ///            <para>By default (and for conformance with the specification)
554
    ///                validation against a DTD or schema will cause default values defined in the schema
555
    ///                or DTD to be inserted into the document. Setting this feature to false suppresses
556
    ///                this behavior. In the case of DTD-defined defaults this only works if the XML parser
557
    ///                reports whether each attribute was specified in the source or generated by expanding
558
    ///                a default value. Not all XML parsers report this information.</para>
559
    ///        
560
    /// </remarks>
561

    
562
    public static Feature<bool> EXPAND_ATTRIBUTE_DEFAULTS = new Feature<bool>(
563
            net.sf.saxon.lib.Feature.EXPAND_ATTRIBUTE_DEFAULTS);
564

    
565
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
566

    
567

    
568
    /// <summary><para><code>EXPATH_FILE_DELETE_TEMPORARY_FILES</code> determines whether temporary files
569
    ///                and directories created in the EXPath File module should be automatically deleted on
570
    ///                closure of the JVM.</para>
571
    /// </summary>
572
    /// <remarks>
573
    ///            <para>The default value is <b>false</b>, to align with the standard. The setting
574
    ///                    <b>false</b> is recommended when external 'sweep-up' features aren't
575
    ///                available.</para>
576
    ///        
577
    /// </remarks>
578

    
579
    public static Feature<bool> EXPATH_FILE_DELETE_TEMPORARY_FILES = new Feature<bool>(
580
            net.sf.saxon.lib.Feature.EXPATH_FILE_DELETE_TEMPORARY_FILES);
581

    
582
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
583

    
584

    
585
    /// <summary><para>By default, Saxon-EE attempts to generate Java bytecode for evaluation of parts of a
586
    ///                query or stylesheet that are amenable to such treatment. Setting this option to
587
    ///                false disables this.</para>
588
    /// </summary>
589
    /// <remarks>
590
    ///            <para>For backwards compatibility, this option when used at the level of <code>Configuration.setConfigurationProperty()</code>
591
    ///            can also be used to set the value of <code>THRESHOLD_FOR_HOTSPOT_BYTECODE</code>. If the value on that interface is supplied
592
    ///            as an integer (or a string in the form of an integer) then a value of 1 or more sets the threshold for hotspot detection, while
593
    ///            a value of zero or less disables bytecode generation entirely. On other interfaces the value of the property must be a boolean.</para>
594
    ///        
595
    /// </remarks>
596

    
597
    public static Feature<bool> GENERATE_BYTE_CODE = new Feature<bool>(
598
            net.sf.saxon.lib.Feature.GENERATE_BYTE_CODE);
599

    
600
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
601

    
602

    
603
    /// <summary><para>If this option is set to true, then when a <code>SAXSource</code> is supplied as the
604
    ///                input to an XSLT transformation, Saxon will ignore the <code>XMLReader</code>
605
    ///                supplied in the <code>SAXSource</code> (in fact, it will modify the supplied
606
    ///                    <code>SAXSource</code> setting the <code>XMLReader</code> to null) and use an
607
    ///                    <code>XMLReader</code> created using the value of the
608
    ///                    <code>SOURCE_PARSER_CLASS</code> option in preference.</para>
609
    /// </summary>
610
    /// <remarks>
611
    ///            <para>The defining use case for this feature is when calling a Saxon transformation from
612
    ///                Ant. Ant always supplies the source document as a <code>SAXSource</code> using a
613
    ///                parser instantiated using the default JAXP mechanism. A different parser set using
614
    ///                the property <code>http://saxon.sf.net/feature/sourceParserClass</code> will
615
    ///                normally be ignored in this case; setting the <code>ignoreSAXSourceParser</code>
616
    ///                option overrides this. This is especially useful if the input format is not in fact
617
    ///                XML, but some other format converted to a SAX event stream by means of a custom
618
    ///                parser.</para>
619
    ///        
620
    /// </remarks>
621

    
622
    public static Feature<bool> IGNORE_SAX_SOURCE_PARSER = new Feature<bool>(
623
            net.sf.saxon.lib.Feature.IGNORE_SAX_SOURCE_PARSER);
624

    
625
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
626

    
627

    
628
    /// <summary><para><code>IMPLICIT_SCHEMA_IMPORTS</code> allows reference to schema components without an <code>xs:import</code> for the relevant namespace being
629
    ///                present in the containing schema document. </para>
630
    /// </summary>
631
    /// <remarks>
632
    ///            <para>This only works if the referenced components are already present among the schema components known to the configuration, perhaps
633
    ///            because they were part of a different schema, or because there are cyclic references within a schema.</para>
634
    ///            <para>This option is not conformant with the XSD specification, which requires explicit <code>xs:import</code> declarations
635
    ///            for all cross-namespace component references. However, some "industry-standard" schemas are known to violate this rule,
636
    ///            and setting this option allows such schemas to be loaded by Saxon.</para>
637
    ///        
638
    /// </remarks>
639

    
640
    public static Feature<bool> IMPLICIT_SCHEMA_IMPORTS = new Feature<bool>(
641
            net.sf.saxon.lib.Feature.IMPLICIT_SCHEMA_IMPORTS);
642

    
643
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
644

    
645

    
646
    /// <summary><para><code>LAZY_CONSTRUCTION_MODE</code> determines whether temporary trees are
647
    ///                constructed lazily. The default setting is false; there are a few situations (but
648
    ///                not many) where setting this to true can give a performance benefit (especially a
649
    ///                memory saving).</para>
650
    /// </summary>
651
    /// <remarks>
652
    ///            <para>The option is most likely to be effective when executing XQuery in "pull" mode, that
653
    ///                is, when the client calls the query processor to deliver the result as a stream of
654
    ///                nodes, rather than running the query and piping the results into a serializer.</para>
655
    ///        
656
    /// </remarks>
657

    
658
    public static Feature<bool> LAZY_CONSTRUCTION_MODE = new Feature<bool>(
659
            net.sf.saxon.lib.Feature.LAZY_CONSTRUCTION_MODE);
660

    
661
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
662

    
663

    
664
    /// <summary><para><code>LICENSE_FILE_LOCATION</code> holds the filename in which the Saxon license file
665
    ///                is held.</para>
666
    /// </summary>
667
    /// <remarks>
668
    ///            <para>This is the full file name, for example <code>c:/saxon/license/license.lic</code>. 
669
    ///                Setting this property causes Saxon to
670
    ///                immediately read the specified file and register the license data, assuming it can
671
    ///                be found at this location. The property is not recognized for reading, and it is not
672
    ///                recognized for writing except in Saxon-PE and Saxon-EE.</para>
673
    ///        
674
    /// </remarks>
675

    
676
    public static Feature<String> LICENSE_FILE_LOCATION = new Feature<String>(
677
            net.sf.saxon.lib.Feature.LICENSE_FILE_LOCATION);
678

    
679
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
680

    
681

    
682
    /// <summary><para>Default is false. If true, line and column number information is retained for all
683
    ///                source documents. This information is accessible using the
684
    ///                    <code>saxon:line-number()</code> and <code>saxon:column-number()</code>
685
    ///                extension functions.</para>
686
    /// </summary>
687
    /// <remarks>
688
    ///            <para>Note that the information is only as good as the XML parser supplies. SAX parsers
689
    ///                generally report the position of an element node using the line and column number of
690
    ///                the "&gt;" character that forms the last character of the start tag.</para>
691
    ///            <para>When this option is set, location information attached to a node (system ID, line
692
    ///            number, and column number) is retained when the node is copied. This has the side effect
693
    ///            that the base URI of a node is also copied, which in some cases runs contrary to the
694
    ///            XSLT or XQuery specification.</para>
695
    ///        
696
    /// </remarks>
697

    
698
    public static Feature<bool> LINE_NUMBERING = new Feature<bool>(
699
            net.sf.saxon.lib.Feature.LINE_NUMBERING);
700

    
701
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
702

    
703

    
704
    /// <summary><para>Setting the <code>MARK_DEFAULTED_ATTRIBUTES</code> option causes Saxon to retain details of attributes
705
    ///            that were notified by the XML parser as being defaulted (that is, the attribute was not present in the instance
706
    ///            document but was defined by a default value in a DTD or schema). This information is available to applications
707
    ///            via the <code>saxon:is-defaulted()</code> extension function.</para>
708
    /// </summary>
709
    /// <remarks>
710
    ///            <para>Note: information about defaulted attributes is retained automatically where the attribute is processed
711
    ///            using Saxon's schema processor; but in the case where the information comes from an external XML parser, it
712
    ///            is retained only if this option is set.</para>
713
    ///        
714
    /// </remarks>
715

    
716
    public static Feature<bool> MARK_DEFAULTED_ATTRIBUTES = new Feature<bool>(
717
            net.sf.saxon.lib.Feature.MARK_DEFAULTED_ATTRIBUTES);
718

    
719
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
720

    
721

    
722
    /// <summary><para>Places a limit on the number of classes for which Saxon will generate bytecode.</para>
723
    /// </summary>
724
    /// <remarks>
725
    ///            <para>If bytecode generation is enabled, Saxon will generate bytecode for frequently used constructs appearing
726
    ///                in stylesheets or queries. This can become problematic if a configuration uses a very large number
727
    ///                of different stylesheets and queries, because it creates memory pressure (in some environments classes
728
    ///                are never garbage collected). When this limit (which defaults to 10,000) is exceeded, no more bytecode
729
    ///            is generated, and queries/stylesheets are interpreted instead.</para>
730
    ///        
731
    /// </remarks>
732

    
733
    public static Feature<int> MAX_COMPILED_CLASSES = new Feature<int>(
734
            net.sf.saxon.lib.Feature.MAX_COMPILED_CLASSES);
735

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

    
738

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

    
768
    public static Feature<String> MESSAGE_EMITTER_CLASS = new Feature<String>(
769
            net.sf.saxon.lib.Feature.MESSAGE_EMITTER_CLASS);
770

    
771
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
772

    
773

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

    
779
    public static Feature<net.sf.saxon.lib.ModuleURIResolver> MODULE_URI_RESOLVER = new Feature<net.sf.saxon.lib.ModuleURIResolver>(
780
            net.sf.saxon.lib.Feature.MODULE_URI_RESOLVER);
781

    
782
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
783

    
784

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

    
790
    public static Feature<String> MODULE_URI_RESOLVER_CLASS = new Feature<String>(
791
            net.sf.saxon.lib.Feature.MODULE_URI_RESOLVER_CLASS);
792

    
793
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
794

    
795

    
796
    /// <summary><para>When set from the Transform or Query command line, a report on bytecode generation is
797
    ///                produced at the end of the transformation or query.</para>
798
    /// </summary>
799
    /// <remarks>
800
    ///            <para>When set from an application, the bytecode report is produced only on request, by
801
    ///                calling <code>Configuration.createByteCodeReport(fileName)</code>.</para>
802
    ///            <para>The bytecode report is an XML file containing one entry for each expression that has
803
    ///                been compiled into bytecode. Each entry contains the following details, where
804
    ///                applicable:</para>
805
    ///                <list>
806
    ///                <item><code>text</code> Abbreviated text of the expression</item>
807
    ///                <item><code>intCount</code> Number of times the expression was evaluated in the interpreter</item>
808
    ///                <item><code>intTime</code> Cumulative time spent evaluating the expression (including subexpressions) in the interpreter</item>
809
    ///                <item><code>bcCount</code> Number of times the expression was evaluated as byte-code</item>
810
    ///                <item><code>bcTime</code> Cumulative time spent evaluating the expression (including subexpressions) as byte-code</item>
811
    ///                <item><code>compileTime</code> Time spent generating bytecode for the expression</item>
812
    ///                <item><code>ratio</code> Average byte-code execution time as a proportion of average interpreted execution time</item>
813
    ///                <item><code>ebv</code> Number of evaluations of the expressions <code>effectiveBooleanValue()</code> method</item>
814
    ///                <item><code>eval</code> Number of evaluations of the expressions <code>evaluateItem()</code> method</item>
815
    ///                <item><code>iterate</code> Number of evaluations of the expressions <code>iterate()</code> method</item>
816
    ///                <item><code>process</code> Number of evaluations of the expressions <code>process()</code> method</item>
817
    ///                <item><code>module</code> URI of the module containing the expression</item>
818
    ///                <item><code>line</code> Line number of the expression within this module</item>
819
    ///            </list>
820
    ///        
821
    /// </remarks>
822

    
823
    public static Feature<bool> MONITOR_HOT_SPOT_BYTE_CODE = new Feature<bool>(
824
            net.sf.saxon.lib.Feature.MONITOR_HOT_SPOT_BYTE_CODE);
825

    
826
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
827

    
828

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

    
852
    public static Feature<bool> MULTIPLE_SCHEMA_IMPORTS = new Feature<bool>(
853
            net.sf.saxon.lib.Feature.MULTIPLE_SCHEMA_IMPORTS);
854

    
855
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
856

    
857

    
858
    /// <summary><para>Indicates that the supplied <code>NamePool</code> should be used as the target
859
    ///                (run-time) <code>NamePool</code> by all stylesheets compiled (using
860
    ///                <code>newTemplates()</code>) after this call on <code>setAttribute</code>.</para>
861
    /// </summary>
862
    /// <remarks>
863
    ///            <para>Normally a single system-allocated <code>NamePool</code> is used for all stylesheets
864
    ///                compiled while the Java VM remains loaded; this attribute allows user control over
865
    ///                the allocation of name pools. Note that source trees used as input to a
866
    ///                transformation must be built using the same <code>NamePool</code> that is used when
867
    ///                the stylesheet is compiled: this will happen automatically if the input to a
868
    ///                transformation is supplied as a <code>SAXSource</code> or <code>StreamSource</code>
869
    ///                but it is under user control if you build the source tree yourself.</para>
870
    ///            <para>This option can be used to make two <code>Configuration</code> objects share a
871
    ///                    <code>NamePool</code> even though they differ in other respects.</para>
872
    ///        
873
    /// </remarks>
874

    
875
    public static Feature<net.sf.saxon.om.NamePool> NAME_POOL = new Feature<net.sf.saxon.om.NamePool>(
876
            net.sf.saxon.lib.Feature.NAME_POOL);
877

    
878
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
879

    
880

    
881
    /// <summary><para><code>OCCURRENCE_LIMITS</code> determines the largest values of
882
    ///                <code>minOccurs</code> and <code>maxOccurs</code> that can be accommodated when
883
    ///                compiling an "expanded" finite state machine to represent an XSD content model
884
    ///                grammar.</para>
885
    /// </summary>
886
    /// <remarks>
887
    ///            <para>These limits do not apply in the common cases where the grammar can be
888
    ///                implemented using a counting finite-state-machine, but in those cases where this is
889
    ///                not possible, any <code>minOccurs</code> value greater than the first integer is
890
    ///                reduced to the value of the first integer, and any <code>maxOccurs</code> value
891
    ///                greater than the second integer is treated as "unbounded".</para>
892
    ///            <para>Setting these values too high may cause an <code>OutOfMemoryException</code> since
893
    ///                the size of the finite state machine constructed by Saxon increases linearly with
894
    ///                the values of <code>minOccurs</code> and <code>maxOccurs</code>.</para>
895
    ///        
896
    /// </remarks>
897

    
898
    public static Feature<Object> OCCURRENCE_LIMITS = new Feature<Object>(
899
            net.sf.saxon.lib.Feature.OCCURRENCE_LIMITS);
900

    
901
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
902

    
903

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

    
938
    public static Feature<Object> OPTIMIZATION_LEVEL = new Feature<Object>(
939
            net.sf.saxon.lib.Feature.OPTIMIZATION_LEVEL);
940

    
941
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
942

    
943

    
944
    /// <summary><para>The supplied <code>OutputURIResolver</code> will be used to resolve URIs of secondary
945
    ///                result documents selected in the <code>href</code> attribute of the XSLT
946
    ///                    <code>xsl:result-document</code> instruction.</para>
947
    /// </summary>
948

    
949
    public static Feature<net.sf.saxon.lib.OutputURIResolver> OUTPUT_URI_RESOLVER = new Feature<net.sf.saxon.lib.OutputURIResolver>(
950
            net.sf.saxon.lib.Feature.OUTPUT_URI_RESOLVER);
951

    
952
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
953

    
954

    
955
    /// <summary><para>The supplied class will be instantiated, and the resulting
956
    ///                    <code>OutputURIResolver</code> will be used to resolve URIs of secondary result
957
    ///                documents selected in the <code>href</code> attribute of the XSLT
958
    ///                    <code>xsl:result-document</code> instruction.</para>
959
    /// </summary>
960

    
961
    public static Feature<String> OUTPUT_URI_RESOLVER_CLASS = new Feature<String>(
962
            net.sf.saxon.lib.Feature.OUTPUT_URI_RESOLVER_CLASS);
963

    
964
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
965

    
966

    
967
    /// <summary><para>If true, calls on the <code>doc()</code> and <code>document()</code> functions, if
968
    ///                their arguments are known at compile time, will be evaluated at compile time, and
969
    ///                the resulting document will be stored as part of the Saxon
970
    ///                <see cref="net.sf.saxon.Configuration" /> and shared by all queries and
971
    ///                transformations running within that <code>Configuration</code>.</para>
972
    /// </summary>
973
    /// <remarks>
974
    ///            <para>This is useful for reference documents that have stable content and are used by many different 
975
    ///                queries and transformations. The default is false, which means each query or transformation
976
    ///                will reload the document from disk.</para>
977
    ///            <para>In XSLT 3.0 a better way of having external documents pre-loaded at stylesheet
978
    ///                compile time is to use the new facility of static global variables.</para>
979
    ///        
980
    /// </remarks>
981

    
982
    public static Feature<bool> PRE_EVALUATE_DOC_FUNCTION = new Feature<bool>(
983
            net.sf.saxon.lib.Feature.PRE_EVALUATE_DOC_FUNCTION);
984

    
985
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
986

    
987

    
988
    /// <summary><para>Relevant only on .NET, determines whether the Java Classpath parser is used in
989
    ///                preference to the Microsoft .NET parser.</para>
990
    /// </summary>
991
    /// <remarks>
992
    ///            <para>This option has no effect on the Java platform. The default is <b>true</b>. When
993
    ///                running on the .NET platform, if the option is true it causes the Apache Xerces
994
    ///                parser (cross-compiled using IKVMC) to be used in preference to the .NET XML parser.
995
    ///                If false the .NET XML parser (<code>System.Xml.XmlTextReader</code>) is used. One
996
    ///                reason for providing this option is that the .NET XML parser does not report ID
997
    ///                attributes, which means that the <code>id()</code> function does not work.</para>
998
    ///        
999
    /// </remarks>
1000

    
1001
    public static Feature<bool> PREFER_JAXP_PARSER = new Feature<bool>(
1002
            net.sf.saxon.lib.Feature.PREFER_JAXP_PARSER);
1003

    
1004
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1005

    
1006

    
1007
    /// <summary><para>True if the standard URI resolver is to recognize query parameters included in
1008
    ///                the URI (for example, <code>?val=strict</code>). Such parameters can then be used in
1009
    ///                URIs passed to the <code>doc()</code> or <code>document()</code> functions. For
1010
    ///                details of the query parameters available, see <span class="link" data-href="/sourcedocs">Source Documents</span>. The default is false.</para>
1011
    /// </summary>
1012
    /// <remarks>
1013
    ///            <para>This option has no effect if a user-supplied <code>URIResolver</code> is in use,
1014
    ///                unless the user-supplied <code>URIResolver</code> chooses to inherit this
1015
    ///                functionality from the standard <code>URIResolver</code>.</para>
1016
    ///            <para>Allowed parameters include <code>validation=strict|lax|strip</code> to perform schema
1017
    ///                validation, <code>strip-space=yes|ignorable|no</code> to control whitespace
1018
    ///                stripping, and <code>xinclude=yes|no</code> to control whether XInclude processing
1019
    ///                takes place (assuming the XML parser supports it).</para>
1020
    ///        
1021
    /// </remarks>
1022

    
1023
    public static Feature<bool> RECOGNIZE_URI_QUERY_PARAMETERS = new Feature<bool>(
1024
            net.sf.saxon.lib.Feature.RECOGNIZE_URI_QUERY_PARAMETERS);
1025

    
1026
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1027

    
1028

    
1029
    /// <summary><para>An integer, one of <see cref="net.sf.saxon.trans.RecoveryPolicy#RECOVER_SILENTLY" />,
1030
    ///                <see cref="net.sf.saxon.trans.RecoveryPolicy#RECOVER_WITH_WARNINGS" />, or
1031
    ///                <see cref="net.sf.saxon.trans.RecoveryPolicy#DO_NOT_RECOVER" />. Indicates the policy for
1032
    ///                handling dynamic errors that the XSLT specification defines as recoverable.</para>
1033
    /// </summary>
1034
    /// <remarks>
1035
    ///            <para>0 means recover silently; 1 means recover after signalling a warning to the
1036
    ///                    <code>ErrorListener</code>; 2 means treat the error as fatal. An example of a
1037
    ///                recoverable error is when two template rules match the same node.</para>
1038
    ///            <para>Note that XSLT 3.0 has eliminated all "recoverable errors" from the
1039
    ///                specification.</para>
1040
    ///        
1041
    /// </remarks>
1042

    
1043
    public static Feature<int> RECOVERY_POLICY = new Feature<int>(
1044
            net.sf.saxon.lib.Feature.RECOVERY_POLICY);
1045

    
1046
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1047

    
1048

    
1049
    /// <summary><para>Indicates the policy for handling dynamic errors that the XSLT specification defines
1050
    ///                as recoverable.</para>
1051
    /// </summary>
1052
    /// <remarks>
1053
    ///            <para>"recoverSilently" means recover silently; "recoverWithWarnings"
1054
    ///                means recover after signalling a warning to the <code>ErrorListener</code>;
1055
    ///                "doNotRecover" means treat the error as fatal. An example of a recoverable error is
1056
    ///                when two template rules match the same node. </para>
1057
    ///            <para>Note that XSLT 3.0 has eliminated all "recoverable errors" from the
1058
    ///                specification.</para>
1059
    ///        
1060
    /// </remarks>
1061

    
1062
    public static Feature<String> RECOVERY_POLICY_NAME = new Feature<String>(
1063
            net.sf.saxon.lib.Feature.RECOVERY_POLICY_NAME);
1064

    
1065
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1066

    
1067

    
1068
    /// <summary><para>Indicates the maximum number of threads to be used for processing
1069
    ///                    <code>xsl:result-document</code> instructions in parallel. If the maximum number
1070
    ///                of threads are already in use, the <code>xsl:result-document</code> instruction will
1071
    ///                be executed synchronously within its parent thread.</para>
1072
    /// </summary>
1073
    /// <remarks>
1074
    ///            <para>The default value is initialized to
1075
    ///                    <code>Runtime.getRuntime().availableProcessors()</code> which is intended to
1076
    ///                represent the number of "processors" (under some definition) available from the
1077
    ///                hardware.</para>
1078
    ///            <para>The limit applies per <code>Configuration</code>. If multiple workloads are running
1079
    ///                on the same server under separate Saxon <code>Configuration</code> objects, then it
1080
    ///                may be desirable to lower the limit.</para>
1081
    ///            <para>Setting a value of zero or one suppresses multithreading entirely. This can also be
1082
    ///                achieved (for a specific <code>xsl:result-document</code> instruction) by setting
1083
    ///                the attribute <code>saxon:asynchronous="no"</code> in the stylesheet. Suppressing
1084
    ///                multithreading may be desirable in a stylesheet that calls extension functions with
1085
    ///                side-effects.</para>
1086
    ///        
1087
    /// </remarks>
1088

    
1089
    public static Feature<int> RESULT_DOCUMENT_THREADS = new Feature<int>(
1090
            net.sf.saxon.lib.Feature.RESULT_DOCUMENT_THREADS);
1091

    
1092
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1093

    
1094

    
1095
    /// <summary><para>If set to true, indicates that when input is obtained from a SAX parser, the
1096
    ///                DTD-based attribute type notified by the XML parser should be used to set the type
1097
    ///                annotation of the resulting node: for example a DTD type of NMTOKENS results in a
1098
    ///                type annotation of xs:NMTOKENS. </para>
1099
    /// </summary>
1100
    /// <remarks>
1101
    ///            <para>This option is retained for backwards compatibility (at some time in the past, it was
1102
    ///                the default), but is deprecated.</para>
1103
    ///        
1104
    /// </remarks>
1105

    
1106
    public static Feature<bool> RETAIN_DTD_ATTRIBUTE_TYPES = new Feature<bool>(
1107
            net.sf.saxon.lib.Feature.RETAIN_DTD_ATTRIBUTE_TYPES);
1108

    
1109
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1110

    
1111

    
1112
    /// <summary><para>The supplied <code>SchemaURIResolver</code> will be used to resolve URIs of schema
1113
    ///                documents referenced in <code>xsl:import-schema</code> declarations in XSLT,
1114
    ///                    <code>import schema</code> in XQuery, references from one schema document to
1115
    ///                another using <code>xs:include</code> or <code>xs:import</code>, and references from
1116
    ///                an instance document to a schema using <code>xsi:schemaLocation</code>.</para>
1117
    /// </summary>
1118

    
1119
    public static Feature<net.sf.saxon.lib.SchemaURIResolver> SCHEMA_URI_RESOLVER = new Feature<net.sf.saxon.lib.SchemaURIResolver>(
1120
            net.sf.saxon.lib.Feature.SCHEMA_URI_RESOLVER);
1121

    
1122
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1123

    
1124

    
1125
    /// <summary><para>The name of a class that implements the interface <code>SchemaURIResolver</code>;
1126
    ///                this class will be instantiated and the resulting instance will be used as the value
1127
    ///                of the <see cref="SCHEMA_URI_RESOLVER" /> property.</para>
1128
    /// </summary>
1129

    
1130
    public static Feature<String> SCHEMA_URI_RESOLVER_CLASS = new Feature<String>(
1131
            net.sf.saxon.lib.Feature.SCHEMA_URI_RESOLVER_CLASS);
1132

    
1133
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1134

    
1135

    
1136
    /// <summary><para>Indicates whether and how schema validation should be applied to source
1137
    ///                documents.</para>
1138
    /// </summary>
1139

    
1140
    public static Feature<int> SCHEMA_VALIDATION = new Feature<int>(
1141
            net.sf.saxon.lib.Feature.SCHEMA_VALIDATION);
1142

    
1143
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1144

    
1145

    
1146
    /// <summary><para>Indicates whether and how schema validation should be applied to source
1147
    ///                documents.</para>
1148
    /// </summary>
1149

    
1150
    public static Feature<String> SCHEMA_VALIDATION_MODE = new Feature<String>(
1151
            net.sf.saxon.lib.Feature.SCHEMA_VALIDATION_MODE);
1152

    
1153
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1154

    
1155

    
1156
    /// <summary><para>The class will be instantiated and the resulting <code>SerializerFactory</code> will
1157
    ///                be used to create the serialization pipeline for XSLT and XQuery results.</para>
1158
    /// </summary>
1159
    /// <remarks>
1160
    ///            <para>By subclassing the standard <code>SerializerFactory</code> it is possible to customize
1161
    ///                many aspects of the output produced by the Serializer, or to introduce new
1162
    ///                serialization methods and parameters.</para>
1163
    ///        
1164
    /// </remarks>
1165

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

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

    
1171

    
1172
    /// <summary><para>XML parser used for source documents.</para>
1173
    /// </summary>
1174
    /// <remarks>
1175
    ///            <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
1176
    ///                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
1177
    ///                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
1178
    ///                parse source documents (that is, the principal source document plus any secondary
1179
    ///                source documents read using the <code>doc()</code>, <code>document()</code>, or
1180
    ///                    <code>collection()</code> function).</para>
1181
    ///            <para>Note that the selected parser is used only when the input is supplied in the form of
1182
    ///                a <code>StreamSource</code>; it is ignored when a <code>SAXSource</code> with a
1183
    ///                pre-initialized <code>XMLReader</code> is supplied. A consequence is that this
1184
    ///                configuration option has no effect when running transformations from an Ant script,
1185
    ///                since the Ant <code>xslt</code> task always supplies the input in the form of a
1186
    ///                    <code>SAXSource</code>.</para>
1187
    ///        
1188
    /// </remarks>
1189

    
1190
    public static Feature<String> SOURCE_PARSER_CLASS = new Feature<String>(
1191
            net.sf.saxon.lib.Feature.SOURCE_PARSER_CLASS);
1192

    
1193
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1194

    
1195

    
1196
    /// <summary><para>On interfaces that allow an <code>org.xml.sax.Source</code> to be supplied, if a kind
1197
    ///                of <code>Source</code> is provided that Saxon does not recognize, it will be passed
1198
    ///                to the user-supplied <code>SourceResolver</code>, which has the opportunity to
1199
    ///                convert it to a kind of <code>Source</code> that Saxon does recognize. This allows
1200
    ///                new kinds of input to be supplied as input to Saxon's query, transformation, and
1201
    ///                validation engines.</para>
1202
    /// </summary>
1203

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

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

    
1209

    
1210
    /// <summary><para><code>STABLE_COLLECTION_URI</code>, if set, indicates that collections returned by
1211
    ///                the <code>fn:collection()</code> and <code>fn:uri-collection()</code> functions
1212
    ///                should be <i>stable</i>, that is, repeated calls on these functions with the same
1213
    ///                collection URI (within the scope of a single query or transformation) should return
1214
    ///                identical results.</para>
1215
    /// </summary>
1216
    /// <remarks>
1217
    ///            <para>Setting this option may be expensive because it requires that the entire collection
1218
    ///                be saved in memory; it is rarely necessary in practice, but is required for strict
1219
    ///                conformance with the W3C specifications.</para>
1220
    ///            <para>It is also possible to indicate that a collection is stable by means of the
1221
    ///                    <code>CollectionFinder</code> API.</para>
1222
    ///        
1223
    /// </remarks>
1224

    
1225
    public static Feature<bool> STABLE_COLLECTION_URI = new Feature<bool>(
1226
            net.sf.saxon.lib.Feature.STABLE_COLLECTION_URI);
1227

    
1228
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1229

    
1230

    
1231
    /// <summary><para><code>STABLE_UNPARSED_TEXT</code>, if set, indicates that the results returned by
1232
    ///                repeated calls of <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>,
1233
    ///                and <code>unparsed-text-available()</code> are consistent: calling these functions
1234
    ///                twice during the evaluation of a stylesheet or query will return the same
1235
    ///                results.</para>
1236
    /// </summary>
1237
    /// <remarks>
1238
    ///            <para>Setting this option may be expensive because it requires that the file contents be
1239
    ///                saved in memory; it is rarely necessary in practice, but is required for strict
1240
    ///                conformance with the W3C specifications.</para>
1241
    ///        
1242
    /// </remarks>
1243

    
1244
    public static Feature<bool> STABLE_UNPARSED_TEXT = new Feature<bool>(
1245
            net.sf.saxon.lib.Feature.STABLE_UNPARSED_TEXT);
1246

    
1247
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1248

    
1249

    
1250
    /// <summary><para><code>STANDARD_ERROR_OUTPUT_FILE</code> is the name of a file to which Saxon will
1251
    ///                redirect output that would otherwise go to the operating system standard error
1252
    ///                stream (System.err). This is the fallback destination for various tracing and
1253
    ///                diagnostic output. In some cases a more specific mechanism exists to select the
1254
    ///                destination for particular kinds of output.</para>
1255
    /// </summary>
1256
    /// <remarks>
1257
    ///            <para>Note that if the <code>Configuration</code> is used in more than one processing
1258
    ///                thread, the messages from different threads will be interleaved in the output file.
1259
    ///                A more selective approach is to use a different <code>ErrorListener</code> in
1260
    ///                different processing threads, and arrange for each <code>ErrorListener</code> to
1261
    ///                write to its own logging destination.</para>
1262
    ///        
1263
    /// </remarks>
1264

    
1265
    public static Feature<String> STANDARD_ERROR_OUTPUT_FILE = new Feature<String>(
1266
            net.sf.saxon.lib.Feature.STANDARD_ERROR_OUTPUT_FILE);
1267

    
1268
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1269

    
1270

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

    
1294
    public static Feature<String> STREAMABILITY = new Feature<String>(
1295
            net.sf.saxon.lib.Feature.STREAMABILITY);
1296

    
1297
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1298

    
1299

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

    
1321
    public static Feature<bool> STRICT_STREAMABILITY = new Feature<bool>(
1322
            net.sf.saxon.lib.Feature.STRICT_STREAMABILITY);
1323

    
1324
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1325

    
1326

    
1327
    /// <summary><para>If the <code>STREAMING_FALLBACK</code> option is set, then constructs for which
1328
    ///                streaming is requested (such as templates in a streaming mode, the
1329
    ///                    <code>xsl:source-document</code> instruction with attribute
1330
    ///                    <code>streamable="yes"</code>, and streamable accumulators) will be executed in
1331
    ///                non-streaming mode if the code is not actually streamable. A compile-time warning
1332
    ///                will always be given when the fallback option is taken.</para>
1333
    /// </summary>
1334

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

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

    
1340

    
1341
    /// <summary><para>Indicates whether all whitespace, no whitespace, or whitespace in elements defined in
1342
    ///                a DTD or schema as having element-only content should be stripped from source
1343
    ///                documents.</para>
1344
    /// </summary>
1345
    /// <remarks>
1346
    ///            <para>The default is "ignorable". This whitespace stripping is additional to
1347
    ///                any stripping done as a result of the <code>xsl:strip-space</code> declaration in an
1348
    ///                XSLT stylesheet.</para>
1349
    ///        
1350
    /// </remarks>
1351

    
1352
    public static Feature<String> STRIP_WHITESPACE = new Feature<String>(
1353
            net.sf.saxon.lib.Feature.STRIP_WHITESPACE);
1354

    
1355
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1356

    
1357

    
1358
    /// <summary><para>XML parser used for stylesheets and schema documents.</para>
1359
    /// </summary>
1360
    /// <remarks>
1361
    ///            <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
1362
    ///                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
1363
    ///                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
1364
    ///                parse stylesheet documents (that is, the principal stylesheet module plus any
1365
    ///                secondary source documents read using <code>xsl:include</code> or
1366
    ///                    <code>xsl:import</code>) and also schema documents.</para>
1367
    ///        
1368
    /// </remarks>
1369

    
1370
    public static Feature<String> STYLE_PARSER_CLASS = new Feature<String>(
1371
            net.sf.saxon.lib.Feature.STYLE_PARSER_CLASS);
1372

    
1373
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1374

    
1375

    
1376
    /// <summary><para>This is set to true to suppress the warning otherwise issued by command-line
1377
    ///                interfaces indicating that an evaluation license is in use and is due to expire in a
1378
    ///                set number of days.</para>
1379
    /// </summary>
1380

    
1381
    public static Feature<bool> SUPPRESS_EVALUATION_EXPIRY_WARNING = new Feature<bool>(
1382
            net.sf.saxon.lib.Feature.SUPPRESS_EVALUATION_EXPIRY_WARNING);
1383

    
1384
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1385

    
1386

    
1387
    /// <summary><para>Suppresses all warnings issued by the XPath and XQuery parsers.</para>
1388
    /// </summary>
1389
    /// <remarks>
1390
    ///            <para>Examples of warnings that are suppressed are the warning produced when keywords such
1391
    ///                as <code>true</code> and <code>return</code> are interpreted as element names.</para>
1392
    ///        
1393
    /// </remarks>
1394

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

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

    
1400

    
1401
    /// <summary><para>This is set to true to suppress the warning when there is no commonality between the
1402
    ///                namespaces used in stylesheet match patterns and the namespaces used in the source
1403
    ///                document.</para>
1404
    /// </summary>
1405

    
1406
    public static Feature<bool> SUPPRESS_XSLT_NAMESPACE_CHECK = new Feature<bool>(
1407
            net.sf.saxon.lib.Feature.SUPPRESS_XSLT_NAMESPACE_CHECK);
1408

    
1409
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1410

    
1411

    
1412
    /// <summary><para>Indicates how often an XSD simple type definition must be used before Saxon generates
1413
    ///                bytecode to implement validation of input data against that type.</para>
1414
    /// </summary>
1415
    /// <remarks>
1416
    ///            <para>By default, Saxon-EE generates Java bytecode to speed up the validation of input
1417
    ///                strings against user-defined simple types after the type has been used 100 times
1418
    ///                (during the life of a Saxon Configuration). This threshold may be changed using this
1419
    ///                configuration option. It may be useful to raise the threshold if the number of
1420
    ///                user-defined types is large, and the bytecode is creating memory pressure.</para>
1421
    ///        
1422
    /// </remarks>
1423

    
1424
    public static Feature<int> THRESHOLD_FOR_COMPILING_TYPES = new Feature<int>(
1425
            net.sf.saxon.lib.Feature.THRESHOLD_FOR_COMPILING_TYPES);
1426

    
1427
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1428

    
1429

    
1430
    /// <summary><para>This is set to true to cause basic timing and tracing information to be output to the
1431
    ///                standard error output stream.</para>
1432
    /// </summary>
1433
    /// <remarks>
1434
    ///            <para>The name of the feature is poorly chosen, since much
1435
    ///                of the information that is output has nothing to do with timing, for example the
1436
    ///                names of output files for <code>xsl:result-document</code> are traced, as are the
1437
    ///                names of schema documents loaded.</para>
1438
    ///        
1439
    /// </remarks>
1440

    
1441
    public static Feature<bool> TIMING = new Feature<bool>(
1442
            net.sf.saxon.lib.Feature.TIMING);
1443

    
1444
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1445

    
1446

    
1447
    /// <summary><para>If this option is set, Saxon will output (to the standard error output) progress
1448
    ///                information about its attempts to locate and disambiguate references to reflexive
1449
    ///                Java extension functions. This is useful for diagnostics if the XQuery or XSLT
1450
    ///                compiler is failing to locate user-written extension functions.</para>
1451
    /// </summary>
1452

    
1453
    public static Feature<bool> TRACE_EXTERNAL_FUNCTIONS = new Feature<bool>(
1454
            net.sf.saxon.lib.Feature.TRACE_EXTERNAL_FUNCTIONS);
1455

    
1456
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1457

    
1458

    
1459
    /// <summary><para>The <code>TraceListener</code> will be notified of significant events occurring
1460
    ///                during a query or transformation, for tracing or debugging purposes.</para>
1461
    /// </summary>
1462
    /// <remarks>
1463
    ///            <para>Setting a <code>TraceListener</code> automatically sets the
1464
    ///                    <see cref="COMPILE_WITH_TRACING" /> option.</para>
1465
    ///            <para>Avoid this option if more than one transformation or query is running concurrently:
1466
    ///                use the feature <see cref="TRACE_LISTENER_CLASS" />
1467
    ///                instead. Alternatively, it is possible to set a <code>TraceListener</code> for an
1468
    ///                individual query or transformation.</para>
1469
    ///        
1470
    /// </remarks>
1471

    
1472
    public static Feature<net.sf.saxon.lib.TraceListener> TRACE_LISTENER = new Feature<net.sf.saxon.lib.TraceListener>(
1473
            net.sf.saxon.lib.Feature.TRACE_LISTENER);
1474

    
1475
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1476

    
1477

    
1478
    /// <summary><para>The class will be instantiated once for each query or transformation, and the
1479
    ///                resulting <code>TraceListener</code> will be notified of significant events
1480
    ///                occurring during that query or transformation, for tracing or debugging
1481
    ///                purposes.</para>
1482
    /// </summary>
1483
    /// <remarks>
1484
    ///            <para>Setting a <code>TraceListener</code> automatically sets the
1485
    ///                    <see cref="COMPILE_WITH_TRACING" /> option.</para>
1486
    ///        
1487
    /// </remarks>
1488

    
1489
    public static Feature<String> TRACE_LISTENER_CLASS = new Feature<String>(
1490
            net.sf.saxon.lib.Feature.TRACE_LISTENER_CLASS);
1491

    
1492
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1493

    
1494

    
1495
    /// <summary><para>When trace listening is switched on (for example by using -T on the command line),
1496
    ///                this file will be supplied to the trace listener to use as the output destination.
1497
    ///                If the option is not supplied, trace listener output is sent to the standard error
1498
    ///                stream.</para>
1499
    /// </summary>
1500

    
1501
    public static Feature<String> TRACE_LISTENER_OUTPUT_FILE = new Feature<String>(
1502
            net.sf.saxon.lib.Feature.TRACE_LISTENER_OUTPUT_FILE);
1503

    
1504
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1505

    
1506

    
1507
    /// <summary><para>If this option is set, Saxon will output (to the standard error output) detailed
1508
    ///                information about the rewrites to the expression tree made by the optimizer. This
1509
    ///                information is mainly useful for internal system debugging, but it is also possible
1510
    ///                to digest it to analyze the ways in which the expression has been optimized for the
1511
    ///                purpose of performance analysis and tuning.</para>
1512
    /// </summary>
1513

    
1514
    public static Feature<bool> TRACE_OPTIMIZER_DECISIONS = new Feature<bool>(
1515
            net.sf.saxon.lib.Feature.TRACE_OPTIMIZER_DECISIONS);
1516

    
1517
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1518

    
1519

    
1520
    /// <summary><para>Selects an implementation of the Saxon tree model. The default is
1521
    ///                    <code>TINY_TREE</code>.</para>
1522
    /// </summary>
1523
    /// <remarks>
1524
    ///            <para>For running XQuery Update, use the linked tree, because it is the only implementation
1525
    ///                that is updateable.</para>
1526
    ///        
1527
    /// </remarks>
1528

    
1529
    public static Feature<int> TREE_MODEL = new Feature<int>(
1530
            net.sf.saxon.lib.Feature.TREE_MODEL);
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>tinyTree</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<String> TREE_MODEL_NAME = new Feature<String>(
1545
            net.sf.saxon.lib.Feature.TREE_MODEL_NAME);
1546

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

    
1549

    
1550
    /// <summary><para>The supplied <code>UnparsedTextURIResolver</code> will be used to resolve
1551
    ///                (dereference) all URIs specifed in calls to the <code>unparsed-text()</code>,
1552
    ///                    <code>unparsed-text-lines()</code>, and <code>unparsed-text-available()</code>
1553
    ///                functions.</para>
1554
    /// </summary>
1555

    
1556
    public static Feature<net.sf.saxon.lib.UnparsedTextURIResolver> UNPARSED_TEXT_URI_RESOLVER = new Feature<net.sf.saxon.lib.UnparsedTextURIResolver>(
1557
            net.sf.saxon.lib.Feature.UNPARSED_TEXT_URI_RESOLVER);
1558

    
1559
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1560

    
1561

    
1562
    /// <summary><para>An instance of the specified <code>UnparsedTextURIResolver</code> class will be
1563
    ///                created, and used to resolve (dereference) all URIs specifed in calls to the
1564
    ///                    <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>, and
1565
    ///                    <code>unparsed-text-available()</code> functions.</para>
1566
    /// </summary>
1567

    
1568
    public static Feature<String> UNPARSED_TEXT_URI_RESOLVER_CLASS = new Feature<String>(
1569
            net.sf.saxon.lib.Feature.UNPARSED_TEXT_URI_RESOLVER_CLASS);
1570

    
1571
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1572

    
1573

    
1574
    /// <summary><para>An instance of the specified <code>URIResolver</code> class will be created, and used
1575
    ///                to resolve (dereference) all URIs specifed in calls to the <code>doc()</code> and
1576
    ///                    <code>document()</code> functions, as well as URIs used in
1577
    ///                    <code>xsl:include</code> and <code>xsl:import</code> and location hints for
1578
    ///                XQuery modules and XSD schema documents.</para>
1579
    /// </summary>
1580

    
1581
    public static Feature<String> URI_RESOLVER_CLASS = new Feature<String>(
1582
            net.sf.saxon.lib.Feature.URI_RESOLVER_CLASS);
1583

    
1584
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1585

    
1586

    
1587
    /// <summary><para>This option determines whether a <code>TransformerHandler</code> created with this
1588
    ///                    <code>TransformerFactory</code> or <code>Configuration</code> recognizes the
1589
    ///                JAXP-defined processing instructions <code>Result.PI_DISABLE_OUTPUT_ESCAPING</code>
1590
    ///                and <code>Result.PI_ENABLE_OUTPUT_ESCAPING</code> in the input stream as
1591
    ///                instructions to disable or to re-enable output escaping. The default value is
1592
    ///                    <b>false</b>.</para>
1593
    /// </summary>
1594

    
1595
    public static Feature<bool> USE_PI_DISABLE_OUTPUT_ESCAPING = new Feature<bool>(
1596
            net.sf.saxon.lib.Feature.USE_PI_DISABLE_OUTPUT_ESCAPING);
1597

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

    
1600

    
1601
    /// <summary><para>This option is relevant only when the TinyTree is used; it determines whether (for a
1602
    ///                validated document) a cache will be maintained containing the typed values of nodes.</para>
1603
    /// </summary>
1604
    /// <remarks>
1605
    ///            <para>Typed values are held in the cache only for elements and attributes whose type is
1606
    ///                other than string, untypedAtomic, or anyURI. The default value is true. Setting this
1607
    ///                value to false can reduce memory requirements at the cost of requiring recomputation
1608
    ///                of typed values on each access.</para>
1609
    ///        
1610
    /// </remarks>
1611

    
1612
    public static Feature<bool> USE_TYPED_VALUE_CACHE = new Feature<bool>(
1613
            net.sf.saxon.lib.Feature.USE_TYPED_VALUE_CACHE);
1614

    
1615
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1616

    
1617

    
1618
    /// <summary><para>This option determines whether or not to use the <code>xsi:schemaLocation</code>
1619
    ///                    and<code> xsi:noNamespaceSchemaLocation</code> attributes in an instance
1620
    ///                document to locate a schema for validation.</para>
1621
    /// </summary>
1622
    /// <remarks>
1623
    ///            <para>Note, these attribute are only consulted if validation is requested; the presence of
1624
    ///                one of these attributes never by itself triggers validation.</para>
1625
    ///        
1626
    /// </remarks>
1627

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

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

    
1633

    
1634
    /// <summary><para>This option determines whether non-fatal validation errors in XQuery or XSLT result
1635
    ///                documents should result in comments being inserted into the result tree. The
1636
    ///                command-line flag <code>-outval:recover</code> sets both this option and the
1637
    ///                    <see cref="VALIDATION_WARNINGS" /> option.</para>
1638
    /// </summary>
1639

    
1640
    public static Feature<bool> VALIDATION_COMMENTS = new Feature<bool>(
1641
            net.sf.saxon.lib.Feature.VALIDATION_COMMENTS);
1642

    
1643
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1644

    
1645

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

    
1669
    public static Feature<bool> VALIDATION_WARNINGS = new Feature<bool>(
1670
            net.sf.saxon.lib.Feature.VALIDATION_WARNINGS);
1671

    
1672
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1673

    
1674

    
1675
    /// <summary><para>Indicates whether a warning message should be notified (to the
1676
    ///                <code>ErrorListener</code>) if running Saxon against an XSLT stylesheet that
1677
    ///                specifies <code>version="1.0"</code>.</para>
1678
    /// </summary>
1679
    /// <remarks>
1680
    ///            <para>From Saxon 9.8, the warning is no longer output (since XSLT 3.0 does not require
1681
    ///                it), so this option is ignored.</para>
1682
    ///            
1683
    ///        
1684
    /// </remarks>
1685

    
1686
    public static Feature<bool> VERSION_WARNING = new Feature<bool>(
1687
            net.sf.saxon.lib.Feature.VERSION_WARNING);
1688

    
1689
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1690

    
1691

    
1692
    /// <summary><para>Indicates whether source documents should have any XInclude directives expanded.</para>
1693
    /// </summary>
1694
    /// <remarks>
1695
    ///            <para>The default is false. The option applies to all input XML documents, including
1696
    ///                stylesheets and schema documents. It can be overridden for individual documents
1697
    ///                using the <see cref="net.sf.saxon.lib.ParseOptions" /> class.</para>
1698
    ///            <para>This option relies on support in the underlying XML parser. If the XML parser does
1699
    ///                not support XInclude processing, the option is ignored.</para>
1700
    ///        
1701
    /// </remarks>
1702

    
1703
    public static Feature<bool> XINCLUDE = new Feature<bool>(
1704
            net.sf.saxon.lib.Feature.XINCLUDE);
1705

    
1706
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1707

    
1708

    
1709
    /// <summary><para>This determines the XML version used by the <code>Configuration</code>.</para>
1710
    /// </summary>
1711
    /// <remarks>
1712
    ///            <para>Note that source documents specifying <code>xml version="1.0"</code> or
1713
    ///                    <code>"1.1"</code> are accepted regardless of this setting. The effect of this
1714
    ///                switch is to change the validation rules for types such as <code>xs:Name</code> and
1715
    ///                    <code>xs:NCName</code>, to change the characters allowed in names within XPath
1716
    ///                expressions (etc.), to change the meaning of <code>\i</code> and <code>\c</code> in
1717
    ///                regular expressions, and to determine whether the serializer allows XML 1.1
1718
    ///                documents to be constructed. </para>
1719
    ///            <para>The default is currently 1.0, but may change.</para>
1720
    ///        
1721
    /// </remarks>
1722

    
1723
    public static Feature<String> XML_VERSION = new Feature<String>(
1724
            net.sf.saxon.lib.Feature.XML_VERSION);
1725

    
1726
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1727

    
1728

    
1729
    /// <summary><para>Sets the value of a parser feature flag. The feature name is any fully-qualified
1730
    ///                URI.</para>
1731
    /// </summary>
1732
    /// <remarks>
1733
    ///            <para>For example if the parser supports a feature
1734
    ///                    <code>http://xml.org/sax/features/external-parameter-entities</code> then this
1735
    ///                can be set by setting the value of the Configuration property:
1736
    ///                    <code>http://saxon.sf.net/feature/parserFeature?uri=http%3A//xml.org/sax/features/external-parameter-entities</code>
1737
    ///                to true.</para>
1738
    ///        
1739
    /// </remarks>
1740

    
1741
    public static Feature<bool> XML_PARSER_FEATURE = new Feature<bool>(
1742
            net.sf.saxon.lib.Feature.XML_PARSER_FEATURE);
1743

    
1744
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1745

    
1746

    
1747
    /// <summary><para>Sets the value of a parser property flag. The property name is any fully-qualified
1748
    ///                URI.</para>
1749
    /// </summary>
1750
    /// <remarks>
1751
    ///            <para>For example if the parser supports a property
1752
    ///                    <code>http://apache.org/xml/properties/schema/external-schemaLocation</code>
1753
    ///                then this can be set using the value of the Configuration property:
1754
    ///                    <code>http://saxon.sf.net/feature/parserProperty?uri=http%3A//apache.org/xml/properties/schema/external-schemaLocation</code>
1755
    ///                to the required value.</para>
1756
    ///        
1757
    /// </remarks>
1758

    
1759
    public static Feature<bool> XML_PARSER_PROPERTY = new Feature<bool>(
1760
            net.sf.saxon.lib.Feature.XML_PARSER_PROPERTY);
1761

    
1762
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1763

    
1764

    
1765
    /// <summary><para>Determines whether XQuery Update syntax is accepted.</para>
1766
    /// </summary>
1767
    /// <remarks>
1768
    ///            <para>If true, update syntax is accepted, if false, it is not accepted. Setting the value to 
1769
    ///                true does not mean that the query has to use update syntax, only that it may do so.</para>
1770
    ///            <para>From Saxon 9.6, XQuery Update syntax and XQuery 3.0 syntax can be mixed, although
1771
    ///                this combination is not defined by any W3C specification at the time of writing.</para>
1772
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1773
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1774
    ///            <para>On the command line, this option is combined with the option "discard" which
1775
    ///                indicates that updates are allowed, but the updates are not written back to
1776
    ///                filestore. This does not correspond to any option in the Java API, where writing an
1777
    ///                updated document back to filestore only happens if explicitly requested.</para>
1778
    ///        
1779
    /// </remarks>
1780

    
1781
    public static Feature<bool> XQUERY_ALLOW_UPDATE = new Feature<bool>(
1782
            net.sf.saxon.lib.Feature.XQUERY_ALLOW_UPDATE);
1783

    
1784
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1785

    
1786

    
1787
    /// <summary><para>This option defines the default value of the construction mode in the XQuery static
1788
    ///                context (overridable in the query prolog).</para>
1789
    /// </summary>
1790
    /// <remarks>
1791
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1792
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1793
    ///        
1794
    /// </remarks>
1795

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

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

    
1801

    
1802
    /// <summary><para>This property defines the default namespace for elements and types that are not
1803
    ///                qualified by a namespace prefix.</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<Object> XQUERY_DEFAULT_ELEMENT_NAMESPACE = new Feature<Object>(
1812
            net.sf.saxon.lib.Feature.XQUERY_DEFAULT_ELEMENT_NAMESPACE);
1813

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

    
1816

    
1817
    /// <summary><para>This property defines the default namespace for function names that are not qualified
1818
    ///                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_FUNCTION_NAMESPACE = new Feature<Object>(
1827
            net.sf.saxon.lib.Feature.XQUERY_DEFAULT_FUNCTION_NAMESPACE);
1828

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

    
1831

    
1832
    /// <summary><para>This property defines how the empty sequence is handled in XQuery sorting (the "order
1833
    ///                by" clause). If true, <code>()</code> comes at the start of the sorted sequence; if
1834
    ///                false, it comes last.</para>
1835
    /// </summary>
1836
    /// <remarks>
1837
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1838
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1839
    ///        
1840
    /// </remarks>
1841

    
1842
    public static Feature<bool> XQUERY_EMPTY_LEAST = new Feature<bool>(
1843
            net.sf.saxon.lib.Feature.XQUERY_EMPTY_LEAST);
1844

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

    
1847

    
1848
    /// <summary><para>This property defines the default value of the <code>inherit-namespaces</code>
1849
    ///                property in the XQuery static context.</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_INHERIT_NAMESPACES = new Feature<bool>(
1858
            net.sf.saxon.lib.Feature.XQUERY_INHERIT_NAMESPACES);
1859

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

    
1862

    
1863
    /// <summary><para>If the value is false, then when an <code>import module</code> declaration is
1864
    ///                encountered for a module URI that is already among the known loaded modules (or
1865
    ///                modules in the process of being compiled), the <code>import module</code> is treated
1866
    ///                as a reference to the existing module. If the value is true, the system first checks
1867
    ///                whether the supplied "location hints" match the known location of the existing
1868
    ///                module, and the existing module is used only if there is a match.</para>
1869
    /// </summary>
1870

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

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

    
1876

    
1877
    /// <summary><para>This property defines whether "boundary space" (insignificant space in direct element
1878
    ///                constructors) should be retained or not.</para>
1879
    /// </summary>
1880
    /// <remarks>
1881
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1882
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1883
    ///        
1884
    /// </remarks>
1885

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

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

    
1891

    
1892
    /// <summary><para>This property defines whether unused namespace declarations are retained by XQuery
1893
    ///                element copy operations.</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_NAMESPACES = new Feature<bool>(
1902
            net.sf.saxon.lib.Feature.XQUERY_PRESERVE_NAMESPACES);
1903

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

    
1906

    
1907
    /// <summary><para>This property defines the default expected context item type for a query.</para>
1908
    /// </summary>
1909
    /// <remarks>
1910
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1911
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1912
    ///        
1913
    /// </remarks>
1914

    
1915
    public static Feature<String> XQUERY_REQUIRED_CONTEXT_ITEM_TYPE = new Feature<String>(
1916
            net.sf.saxon.lib.Feature.XQUERY_REQUIRED_CONTEXT_ITEM_TYPE);
1917

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

    
1920

    
1921
    /// <summary><para>A query will automatically be schema-aware if it contains an <code>import
1922
    ///                    schema</code> declaration. This property allows a query to be marked as
1923
    ///                schema-aware even if it contains no <code>import schema</code> declaration. It is
1924
    ///                necessary for a query to be compiled as schema-aware if it is to handle typed
1925
    ///                (validated) input documents in which nodes have type annotations based on their
1926
    ///                schema-defined type.</para>
1927
    /// </summary>
1928
    /// <remarks>
1929
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1930
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1931
    ///        
1932
    /// </remarks>
1933

    
1934
    public static Feature<bool> XQUERY_SCHEMA_AWARE = new Feature<bool>(
1935
            net.sf.saxon.lib.Feature.XQUERY_SCHEMA_AWARE);
1936

    
1937
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1938

    
1939

    
1940
    /// <summary><para>The specified class is instantiated to create an <code>ErrorListener</code>, and all
1941
    ///                reports of static errors in a query will go to this <code>ErrorListener</code>.</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
    ///            <para>In the absence of this property, the global <code>ErrorListener</code> specified as
1947
    ///                the value of the <see cref="ERROR_LISTENER_CLASS" />
1948
    ///                property is used.</para>
1949
    ///        
1950
    /// </remarks>
1951

    
1952
    public static Feature<String> XQUERY_STATIC_ERROR_LISTENER_CLASS = new Feature<String>(
1953
            net.sf.saxon.lib.Feature.XQUERY_STATIC_ERROR_LISTENER_CLASS);
1954

    
1955
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1956

    
1957

    
1958
    /// <summary><para>This property determines the version of XQuery used by the
1959
    ///                <code>Configuration</code>.</para>
1960
    /// </summary>
1961
    /// <remarks>
1962
    ///            <para>From Saxon 9.8, an XQuery 3.1 processor is always used by default. So setting this
1963
    ///                property has no effect.</para>
1964
    ///            
1965
    ///        
1966
    /// </remarks>
1967

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

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

    
1973

    
1974
    /// <summary><para>This property determines the version of XML Schema used by the
1975
    ///                <code>Configuration</code>.</para>
1976
    /// </summary>
1977
    /// <remarks>
1978
    ///            <para>From Saxon 9.8, the default is XSD 1.1. If XSD 1.0 is
1979
    ///                selected, XSD 1.1 features will be rejected, with the exception of the version
1980
    ///                control attributes that allow sections of the schema to be marked as requiring XSD
1981
    ///                1.0 or XSD 1.1.</para>
1982
    ///        
1983
    /// </remarks>
1984

    
1985
    public static Feature<String> XSD_VERSION = new Feature<String>(
1986
            net.sf.saxon.lib.Feature.XSD_VERSION);
1987

    
1988
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1989

    
1990

    
1991
    /// <summary><para>This property indicates whether assertions (XSLT 3.0 xsl:assert instructions) are
1992
    ///                enabled or disabled. They are disabled by default. Setting this property on causes
1993
    ///                assertions to be enabled at compile time for all XSLT packages compiled using the
1994
    ///                default configuration options.</para>
1995
    /// </summary>
1996
    /// <remarks>
1997
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
1998
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
1999
    ///                acts as a default.</para>
2000
    ///            <para>If assertions have been enabled at compile time for a particular package, they can
2001
    ///                still be disabled at run-time (for all packages) by setting an option on the
2002
    ///                    <code>Xslt30Transformer</code>. But if assertions were disabled at compile time,
2003
    ///                enabling them at run-time has no effect.</para>
2004
    ///        
2005
    /// </remarks>
2006

    
2007
    public static Feature<bool> XSLT_ENABLE_ASSERTIONS = new Feature<bool>(
2008
            net.sf.saxon.lib.Feature.XSLT_ENABLE_ASSERTIONS);
2009

    
2010
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2011

    
2012

    
2013
    /// <summary><para>This property indicates the name of a mode within a stylesheet in which execution
2014
    ///                (using template rules) should begin.</para>
2015
    /// </summary>
2016
    /// <remarks>
2017
    ///            <para>This option can be set for a particular XSLT transformation. When the option is set
2018
    ///                at the <code>Configuration</code> (or on a <code>TransformerFactory</code>), it acts
2019
    ///                as a default.</para>
2020
    ///        
2021
    /// </remarks>
2022

    
2023
    public static Feature<String> XSLT_INITIAL_MODE = new Feature<String>(
2024
            net.sf.saxon.lib.Feature.XSLT_INITIAL_MODE);
2025

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

    
2028

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

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

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

    
2044

    
2045
    /// <summary><para>This property indicates whether stylesheets should be compiled with the ability to
2046
    ///                handle schema-typed input documents. By default a stylesheet is compiled to handle
2047
    ///                such input if it contains an <code>xsl:import-schema</code> instruction, and not
2048
    ///                otherwise. It is necessary for a stylesheet to be compiled as schema-aware if it is
2049
    ///                to handle typed (validated) input documents in which nodes have type annotations
2050
    ///                based on their schema-defined type.</para>
2051
    /// </summary>
2052
    /// <remarks>
2053
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2054
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2055
    ///                acts as a default.</para>
2056
    ///        
2057
    /// </remarks>
2058

    
2059
    public static Feature<bool> XSLT_SCHEMA_AWARE = new Feature<bool>(
2060
            net.sf.saxon.lib.Feature.XSLT_SCHEMA_AWARE);
2061

    
2062
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2063

    
2064

    
2065
    /// <summary><para>The specified class is instantiated to create an <code>ErrorListener</code>, and all
2066
    ///                reports of static errors in a stylesheet will go to this
2067
    ///                <code>ErrorListener</code>.</para>
2068
    /// </summary>
2069
    /// <remarks>
2070
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2071
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2072
    ///                acts as a default.</para>
2073
    ///            <para>In the absence of this property, the global <code>ErrorListener</code> specified as
2074
    ///                the value of the <see cref="ERROR_LISTENER_CLASS" />
2075
    ///                property is used.</para>
2076
    ///        
2077
    /// </remarks>
2078

    
2079
    public static Feature<String> XSLT_STATIC_ERROR_LISTENER_CLASS = new Feature<String>(
2080
            net.sf.saxon.lib.Feature.XSLT_STATIC_ERROR_LISTENER_CLASS);
2081

    
2082
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2083

    
2084

    
2085
    /// <summary><para>This property defines a <code>URIResolver</code> used when dereferencing the URIs
2086
    ///                that appear in the <code>href</code> attributes of the <code>xsl:include</code> and
2087
    ///                    <code>xsl:import</code> declarations. Note that this defaults to the setting of
2088
    ///                the global <code>URI_RESOLVER</code> property.</para>
2089
    /// </summary>
2090
    /// <remarks>
2091
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2092
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2093
    ///                acts as a default.</para>
2094
    ///            <para>In the absence of this property, the global <code>URIResolver</code> specified as the
2095
    ///                value of the <see cref="URI_RESOLVER_CLASS" /> property
2096
    ///                is used.</para>
2097
    ///        
2098
    /// </remarks>
2099

    
2100
    public static Feature<String> XSLT_STATIC_URI_RESOLVER_CLASS = new Feature<String>(
2101
            net.sf.saxon.lib.Feature.XSLT_STATIC_URI_RESOLVER_CLASS);
2102

    
2103
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2104

    
2105

    
2106
    /// <summary><para>This property determines the version of XSLT to be supported by default.</para>
2107
    /// </summary>
2108
    /// <remarks>
2109
    ///            <para>From Saxon 9.8, an XSLT 3.0 processor is always used by default. So setting this
2110
    ///                property has no effect.</para>
2111
    ///            
2112
    ///        
2113
    /// </remarks>
2114

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

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

    
2120

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

    
2137
    public static Feature<int> REGEX_BACKTRACKING_LIMIT = new Feature<int>(
2138
            net.sf.saxon.lib.Feature.REGEX_BACKTRACKING_LIMIT);
2139

    
2140
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2141

    
2142

    
2143
    /// <summary><para>The XSD 1.1 specification states that XPath version 2.0 is used for expressions appearing in assertions and type
2144
    ///                alternatives. This option allows XPath 3.0 or 3.1 to be used instead.</para>
2145
    /// </summary>
2146
    /// <remarks>
2147
    ///            <para>The recognized values are the integers 20, 30, and 31 representing versions 2.0, 3.0, and 3.1 respectively.</para>           
2148
    ///        
2149
    /// </remarks>
2150

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

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

    
2156

    
2157
    /// <summary><para>The XSLT 3.0 specification states that processors are required to support XPath 3.0 expressions within stylesheets, together
2158
    ///                with some extensions (maps) selected from the XPath 3.1 specification. Support for the full syntax of XPath 3.1 is
2159
    ///                optional, but it is the default in Saxon. This option allows a different XPath language level to be selected.</para>
2160
    /// </summary>
2161
    /// <remarks>
2162
    ///            <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
2163
    ///                with the extensions defined in the XSLT 3.0 specification.</para>
2164
    ///        
2165
    /// </remarks>
2166

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

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

    
2172

    
2173
    /// <summary><para>Saxon-EE performs inlining of user-defined functions that are sufficiently simple: they must not be recursive,
2174
    ///                and they must be below a certain size. This option defines the size.</para>
2175
    /// </summary>
2176
    /// <remarks>
2177
    ///            <para>The value is (roughly) the number of nodes in the expression tree representing the function body. This
2178
    ///                includes both explicit subexpressions, and subexpressions added by Saxon itself to perform implicit
2179
    ///                operations such as type checking or conversion of function arguments. The default value is 100.</para>
2180
    ///        
2181
    /// </remarks>
2182

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

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

    
2188

    
2189
    /// <summary><para>Saxon-EE generates bytecode to give faster execution of frequently-evaluated subexpressions.
2190
    ///                Bytecode is generated when a candidate expression has been evaluated a certain number of
2191
    ///                times, controlled by this parameter.
2192
    ///            </para>
2193
    /// </summary>
2194
    /// <remarks>
2195
    ///            <para>Setting this parameter to 0 (or any negative value) has the effect of disabling bytecode
2196
    ///                generation completely. Setting the parameter to a positive value has the effect of enabling
2197
    ///                bytecode generation if it is not already enabled. Setting the value to 1 (one) causes bytecode
2198
    ///                to be generated for candidate expressions the first time it is executed.</para>
2199
    ///        
2200
    /// </remarks>
2201

    
2202
    public static Feature<int> THRESHOLD_FOR_HOTSPOT_BYTE_CODE = new Feature<int>(
2203
            net.sf.saxon.lib.Feature.THRESHOLD_FOR_HOTSPOT_BYTE_CODE);
2204

    
2205
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2206

    
2207

    
2208
    /// <summary><para>When Saxon-supplied default resolvers are used for URIs (including the <code>URIResolver</code>,
2209
    ///                <code>UnparsedTextResolver</code>, <code>SchemaURIResolver</code>, <code>CollectionResolver</code>, <code>ModuleResolver</code>),
2210
    ///                this parameter defines which URI schemes/protocols are permitted.
2211
    ///            </para>
2212
    /// </summary>
2213
    /// <remarks>
2214
    ///            <para>The format is the same as for <code>XMLConstants.ACCESS_EXTERNAL_SCHEMA</code>: either <code>"all"</code> to allow
2215
    ///                all schemes/protocols, or a comma-separated list of scheme names such as <code>"http"</code>, <code>"file"</code>, <code>"ftp"</code>.
2216
    ///                For a JAR file scheme, use the format <code>"jar:<i>scheme</i>"</code>, for example <code>"jar:file"</code>. A zero-length
2217
    ///            string disallows all schemes.</para>
2218
    ///            <para>This configuration option affects the standard URI Resolvers built in to Saxon, but it does not constrain user-written
2219
    ///            resolvers.</para>
2220
    ///        
2221
    /// </remarks>
2222

    
2223
    public static Feature<Object> ALLOWED_PROTOCOLS = new Feature<Object>(
2224
            net.sf.saxon.lib.Feature.ALLOWED_PROTOCOLS);
2225

    
2226
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2227

    
2228

    
2229
    /// <summary><para>By default, Saxon attempts to ensure that the run-time code contains no links to the original source stylesheet tree.
2230
    ///                This allows the garbage collector to free memory.
2231
    ///            </para>
2232
    /// </summary>
2233
    /// <remarks>
2234
    ///            <para>If this option is set, then <code>Location</code> objects held in the run-time expression tree may contain a link
2235
    ///                to an element node in the source stylesheet, enabling a user-written <code>ErrorListener</code> to produce
2236
    ///                improved diagnostics. This may be an appropriate setting to use, for example, in an IDE.</para>
2237
    ///            <para>Links to source nodes are not retained in an exported SEF file, regardless of this setting.</para>
2238
    ///        
2239
    /// </remarks>
2240

    
2241
    public static Feature<bool> RETAIN_NODE_FOR_DIAGNOSTICS = new Feature<bool>(
2242
            net.sf.saxon.lib.Feature.RETAIN_NODE_FOR_DIAGNOSTICS);
2243

    
2244
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2245

    
2246

    
2247
    /// <summary><para>The W3C XSD specification (both 1.0 and 1.1) states that an unresolved
2248
    ///        reference to an absent schema component does not automatically make the schema
2249
    ///        invalid; the schema should be usable for validation provided that the missing
2250
    ///        components are not actually needed in a particular validation episode.
2251
    ///      </para>
2252
    /// </summary>
2253
    /// <remarks>
2254
    ///      <para>However, the W3C XSD conformance tests treat such an unresolved reference
2255
    ///      as an error; the test is expected to report the schema as invalid. And this
2256
    ///      is the way most schema processors actually operate, and probably what most
2257
    ///      users would expect.</para>
2258
    ///      <para>By default, the Saxon schema processor reports an unresolved reference
2259
    ///      as an error in the schema.</para>
2260
    ///      <para>If this option is set, then Saxon attempts to repair the schema so that
2261
    ///      it is usable for validation, by substituting the missing components with default
2262
    ///      components: for example if an attribute declaration refers to a type that has
2263
    ///      not been defined, then <code>xs:error</code> is substituted, making any instance
2264
    ///      of the attribute invalid.</para>
2265
    ///      
2266
    /// </remarks>
2267

    
2268
    public static Feature<bool> ALLOW_UNRESOLVED_SCHEMA_COMPONENTS = new Feature<bool>(
2269
            net.sf.saxon.lib.Feature.ALLOW_UNRESOLVED_SCHEMA_COMPONENTS);
2270

    
2271
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2272

    
2273

    
2274
} 
2275
}
2276

    
2277
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2278
// Copyright (c) 2020 Saxonica Limited.
2279
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
2280
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
2281
// This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0.
2282
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
(5-5/13)