Project

Profile

Help

Revision 0641bed1

Added by Debbie Lockett 9 months ago

Documentation: remove generated dotnetdoc-xml and javadoc-xml from src/viewer_appJS

View differences:

src/viewer_appJS/dotnetdoc-xml/packages.xml
1
<?xml version="1.0" encoding="UTF-8"?>
2
<article id="dotnetdoc-packages">
3
   <section id="Saxon.Api">
4
      <div>
5
         <p>This namespace contains Saxon's application programming interfaces for using XSLT, XQuery,
6
                            XPath and XSD on .NET.</p>
7
         <p>The top-level object is the <a class="javalink" href="Saxon.Api.Processor">Processor</a>;
8
                            this allows creation of factory classes for using each of the different processing
9
                            languages.</p>
10
      </div>
11
   </section>
12
</article>
src/viewer_appJS/dotnetdoc-xml/packages/Saxon.Api.xml
1
<?xml version="1.0" encoding="UTF-8"?>
2
<package id="Saxon.Api">
3
   <class id="DocumentBuilder"
4
          fulltype="Saxon.Api.DocumentBuilder"
5
          visibility="public"
6
          superclass="object"
7
          superclassfulltype="System.Object">
8
      <comment>
9
         <sentence>
10
            The <code>DocumentBuilder</code> class enables XDM documents to be built from various sources.
11
            The class is always instantiated using the <code>NewDocumentBuilder</code> method
12
            on the <code>Processor</code> object.
13
            </sentence>
14
      </comment>
15
      <property id="BaseUri"
16
                type="Uri"
17
                fulltype="System.Uri"
18
                get="true"
19
                set="true">
20
         <comment>
21
            <sentence>
22
            The base URI of a document loaded using this <code>DocumentBuilder</code>.
23
            This is used for resolving any relative URIs appearing
24
            within the document, for example in references to DTDs and external entities.
25
            </sentence>
26
            <body>
27
               <div>
28
                  <p>
29
            The base URI of a document loaded using this <code>DocumentBuilder</code>.
30
            This is used for resolving any relative URIs appearing
31
            within the document, for example in references to DTDs and external entities.
32
            </p>
33
                  <p>
34
            This information is required when the document is loaded from a source that does not
35
            provide an intrinsic URI, notably when loading from a <code>Stream</code> or a <code>TextReader</code>.
36
            </p>
37
               </div>
38
            </body>
39
         </comment>
40
      </property>
41
      <property id="DocumentProjectionQuery"
42
                type="XQueryExecutable"
43
                fulltype="Saxon.Api.XQueryExecutable"
44
                get="true"
45
                set="true">
46
         <comment>
47
            <sentence>
48
            Set a compiled query to be used for implementing document projection. 
49
            </sentence>
50
            <body>
51
               <div>
52
                  <p>
53
            Set a compiled query to be used for implementing document projection. 
54
            </p>
55
                  <p>
56
            The effect of using this option is that the tree constructed by the 
57
            <code>DocumentBuilder</code> contains only those parts
58
            of the source document that are needed to answer this query. Running this query against
59
            the projected document should give the same results as against the raw document, but the
60
            projected document typically occupies significantly less memory. It is permissible to run
61
            other queries against the projected document, but unless they are carefully chosen, they
62
            will give the wrong answer, because the document being used is different from the original.
63
            </p>
64
                  <p>The query should be written to use the projected document as its initial context item.
65
            For example, if the query is <code>//ITEM[COLOR='blue']</code>, then only <code>ITEM</code>
66
            elements and their <code>COLOR</code> children will be retained in the projected document.</p>
67
                  <p>This facility is only available in Saxon-EE; if the facility is not available,
68
            calling this method has no effect.</p>
69
               </div>
70
            </body>
71
         </comment>
72
      </property>
73
      <property id="DtdValidation"
74
                type="bool"
75
                fulltype="System.Boolean"
76
                get="true"
77
                set="true">
78
         <comment>
79
            <sentence>
80
            Determines whether DTD validation is applied to documents loaded using this
81
            <code>DocumentBuilder</code>.
82
            </sentence>
83
            <body>
84
               <div>
85
                  <p>
86
            Determines whether DTD validation is applied to documents loaded using this
87
            <code>DocumentBuilder</code>.
88
            </p>
89
                  <p>By default, no DTD validation takes place.</p>
90
               </div>
91
            </body>
92
         </comment>
93
      </property>
94
      <property id="IsLineNumbering"
95
                type="bool"
96
                fulltype="System.Boolean"
97
                get="true"
98
                set="true">
99
         <comment>
100
            <sentence>
101
            Determines whether line numbering is enabled for documents loaded using this
102
            <code>DocumentBuilder</code>.
103
            </sentence>
104
            <body>
105
               <div>
106
                  <p>
107
            Determines whether line numbering is enabled for documents loaded using this
108
            <code>DocumentBuilder</code>.
109
            </p>
110
                  <p>By default, line numbering is disabled.</p>
111
                  <p>Line numbering is not available for all kinds of source: in particular,
112
            it is not available when loading from an existing <code>XmlDocument</code>.</p>
113
                  <p>The resulting line numbers are accessible to applications using the
114
            extension function <code>saxon:line-number()</code> applied to a node.</p>
115
                  <p>Line numbers are maintained only for element nodes; the line number
116
            returned for any other node will be that of the most recent element.</p>
117
               </div>
118
            </body>
119
         </comment>
120
      </property>
121
      <property id="SchemaValidationMode"
122
                type="SchemaValidationMode"
123
                fulltype="Saxon.Api.SchemaValidationMode"
124
                get="true"
125
                set="true">
126
         <comment>
127
            <sentence>
128
            Determines whether schema validation is applied to documents loaded using this
129
            <code>DocumentBuilder</code>, and if so, whether it is strict or lax.
130
            </sentence>
131
            <body>
132
               <div>
133
                  <p>
134
            Determines whether schema validation is applied to documents loaded using this
135
            <code>DocumentBuilder</code>, and if so, whether it is strict or lax.
136
            </p>
137
                  <p>By default, no schema validation takes place.</p>
138
                  <p>This option requires Saxon Enterprise Edition (Saxon-EE).</p>
139
               </div>
140
            </body>
141
         </comment>
142
      </property>
143
      <property id="SchemaValidator"
144
                type="SchemaValidator"
145
                fulltype="Saxon.Api.SchemaValidator"
146
                get="true"
147
                set="true">
148
         <comment>
149
            <sentence>
150
            Property to set and get the schemaValidator to be used. This determines whether schema validation is applied
151
            to an input document and whether type annotations in a supplied document are retained. If no schemaValidator
152
            is supplied, then schema validation does not take place.
153
            </sentence>
154
         </comment>
155
      </property>
156
      <property id="TopLevelElementName"
157
                type="QName"
158
                fulltype="Saxon.Api.QName"
159
                get="true"
160
                set="true">
161
         <comment>
162
            <sentence>
163
            The required name of the top level element in a document instance being validated
164
            against a schema.
165
            </sentence>
166
            <body>
167
               <div>
168
                  <p>
169
            The required name of the top level element in a document instance being validated
170
            against a schema.
171
            </p>
172
                  <p>If this property is set, and if schema validation is requested, then validation will
173
            fail unless the outermost element of the document has the required name.</p>
174
                  <p>This option requires the schema-aware version of the Saxon product (Saxon-EE).</p>
175
               </div>
176
            </body>
177
         </comment>
178
      </property>
179
      <property id="TreeModel"
180
                type="TreeModel"
181
                fulltype="Saxon.Api.TreeModel"
182
                get="true"
183
                set="true">
184
         <comment>
185
            <sentence>
186
             The Tree Model implementation to be used for the constructed document. By default
187
             the <code>TinyTree</code> is used. The main reason for using the <code>LinkedTree</code> alternative is if
188
             updating is required (the <code>TinyTree</code> is not updateable).
189
            </sentence>
190
         </comment>
191
      </property>
192
      <property id="WhitespacePolicy"
193
                type="WhitespacePolicy"
194
                fulltype="Saxon.Api.WhitespacePolicy"
195
                get="true"
196
                set="true">
197
         <comment>
198
            <sentence>
199
            Determines the whitespace stripping policy applied when loading a document
200
            using this <code>DocumentBuilder</code>.
201
            </sentence>
202
            <body>
203
               <div>
204
                  <p>
205
            Determines the whitespace stripping policy applied when loading a document
206
            using this <code>DocumentBuilder</code>.
207
            </p>
208
                  <p>By default, whitespace text nodes appearing in element-only content
209
            are stripped, and all other whitespace text nodes are retained.</p>
210
               </div>
211
            </body>
212
         </comment>
213
      </property>
214
      <property id="XmlResolver"
215
                type="XmlResolver"
216
                fulltype="System.Xml.XmlResolver"
217
                get="true"
218
                set="true">
219
         <comment>
220
            <sentence>
221
            An <code>XmlResolver</code>, which will be used to resolve URIs of documents being loaded
222
            and of references to external entities within those documents (including any external DTD).
223
            </sentence>
224
            <body>
225
               <div>
226
                  <p>
227
            An <code>XmlResolver</code>, which will be used to resolve URIs of documents being loaded
228
            and of references to external entities within those documents (including any external DTD).
229
            </p>
230
                  <p>By default an <code>XmlUrlResolver</code> is used. This means that the responsibility
231
            for resolving and dereferencing URIs rests with the .NET platform (and not with the
232
            GNU Classpath).</p>
233
                  <p>When Saxon invokes a user-written <code>XmlResolver</code>, the <code>GetEntity</code> method
234
            may return any of: a <code>System.IO.Stream</code>; a <code>System.IO.TextReader</code>; or a
235
            <code>java.xml.transform.Source</code>. However, if the <code>XmlResolver</code> is called
236
            by the XML parser to resolve external entity references, then it must return an 
237
            instance of <code>System.IO.Stream</code>.</p>
238
               </div>
239
            </body>
240
         </comment>
241
      </property>
242
      <methods>
243
         <method id="Build"
244
                 visibility="public"
245
                 type="XdmNode"
246
                 fulltype="Saxon.Api.XdmNode">
247
            <comment>
248
               <sentence>
249
            Load an XML document, retrieving it via a URI.
250
            </sentence>
251
               <body>
252
                  <div>
253
                     <p>
254
            Load an XML document, retrieving it via a URI.
255
            </p>
256
                     <p>Note that the type <code>Uri</code> requires an absolute URI.</p>
257
                     <p>The URI is dereferenced using the registered <code>XmlResolver</code>.</p>
258
                     <p>This method takes no account of any fragment part in the URI.</p>
259
                     <p>The <code>role</code> passed to the <code>GetEntity</code> method of the <code>XmlResolver</code> 
260
            is "application/xml", and the required return type is <code>System.IO.Stream</code>.</p>
261
                     <p>The document located via the URI is parsed using the <code>System.Xml</code> parser.</p>
262
                     <p>Note that the Microsoft <code>System.Xml</code> parser does not report whether attributes are
263
            defined in the DTD as being of type <code>ID</code> and <code>IDREF</code>. This is true whether or not
264
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
265
            <code>id()</code> and <code>idref()</code> functions.</p>
266
                  </div>
267
               </body>
268
               <return>
269
                  <body>
270
                     <div>An <code>XdmNode</code>, the document node at the root of the tree of the resulting
271
            in-memory document.
272
            </div>
273
                  </body>
274
               </return>
275
            </comment>
276
            <params>
277
               <param fulltype="System.Uri" type="Uri" name="uri">
278
                  <body>
279
                     <div>The URI identifying the location where the document can be
280
            found. This will also be used as the base URI of the document (regardless
281
            of the setting of the <code>BaseUri</code> property).</div>
282
                  </body>
283
               </param>
284
            </params>
285
         </method>
286
         <method id="Build"
287
                 visibility="public"
288
                 type="XdmNode"
289
                 fulltype="Saxon.Api.XdmNode">
290
            <comment>
291
               <sentence>
292
            Load an XML document supplied as raw (lexical) XML on a <code>Stream</code>.
293
            </sentence>
294
               <body>
295
                  <div>
296
                     <p>
297
            Load an XML document supplied as raw (lexical) XML on a <code>Stream</code>.
298
            </p>
299
                     <p>The document is parsed using the Microsoft <code>System.Xml</code> parser if the
300
            "http://saxon.sf.net/feature/preferJaxpParser" property on the <code>Processor</code> is set to false;
301
            otherwise it is parsed using the Apache Xerces XML parser.</p>
302
                     <p>Before calling this method, the <code>BaseUri</code> property must be set to identify the
303
            base URI of this document, used for resolving any relative URIs contained within it.</p>
304
                     <p>Note that the Microsoft <code>System.Xml</code> parser does not report whether attributes are
305
            defined in the DTD as being of type <code>ID</code> and <code>IDREF</code>. This is true whether or not
306
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
307
            <code>id()</code> and <code>idref()</code> functions.</p>
308
                  </div>
309
               </body>
310
               <return>
311
                  <body>
312
                     <div>An <code>XdmNode</code>, the document node at the root of the tree of the resulting
313
            in-memory document.
314
            </div>
315
                  </body>
316
               </return>
317
            </comment>
318
            <params>
319
               <param fulltype="System.IO.Stream" type="Stream" name="input">
320
                  <body>
321
                     <div>The <code>Stream</code> containing the XML source to be parsed. Closing this stream
322
            on completion is the responsibility of the caller.</div>
323
                  </body>
324
               </param>
325
            </params>
326
         </method>
327
         <method id="Build"
328
                 visibility="public"
329
                 type="XdmNode"
330
                 fulltype="Saxon.Api.XdmNode">
331
            <comment>
332
               <sentence>
333
            Load an XML document supplied using a <code>TextReader</code>.
334
            </sentence>
335
               <body>
336
                  <div>
337
                     <p>
338
            Load an XML document supplied using a <code>TextReader</code>.
339
            </p>
340
                     <p>The document is parsed using the Microsoft <code>System.Xml</code> parser if the
341
            "http://saxon.sf.net/feature/preferJaxpParser" property on the <code>Processor</code> is set to false;
342
            otherwise it is parsed using the Apache Xerces XML parser.</p>
343
                     <p>Before calling this method, the <code>BaseUri</code> property must be set to identify the
344
            base URI of this document, used for resolving any relative URIs contained within it.</p>
345
                     <p>Note that the Microsoft <code>System.Xml</code> parser does not report whether attributes are
346
            defined in the DTD as being of type <code>ID</code> and <code>IDREF</code>. This is true whether or not
347
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
348
            <code>id()</code> and <code>idref()</code> functions.</p>
349
                  </div>
350
               </body>
351
               <return>
352
                  <body>
353
                     <div>An <code>XdmNode</code>, the document node at the root of the tree of the resulting
354
            in-memory document.
355
            </div>
356
                  </body>
357
               </return>
358
            </comment>
359
            <params>
360
               <param fulltype="System.IO.TextReader" type="TextReader" name="input">
361
                  <body>
362
                     <div>The <code>TextReader</code> containing the XML source to be parsed</div>
363
                  </body>
364
               </param>
365
            </params>
366
         </method>
367
         <method id="Build"
368
                 visibility="public"
369
                 type="XdmNode"
370
                 fulltype="Saxon.Api.XdmNode">
371
            <comment>
372
               <sentence>
373
            Load an XML document, delivered using an <code>XmlReader</code>.
374
            </sentence>
375
               <body>
376
                  <div>
377
                     <p>
378
            Load an XML document, delivered using an <code>XmlReader</code>.
379
            </p>
380
                     <p>The <code>XmlReader</code> is responsible for parsing the document; this method builds a tree
381
            representation of the document (in an internal Saxon format) and returns its document node.
382
            The <code>XmlReader</code> is not required to perform validation but it must expand any entity references.
383
            Saxon uses the properties of the <code>XmlReader</code> as supplied.</p>
384
                     <p>Use of a plain <code>XmlTextReader</code> is discouraged, because it does not expand entity
385
            references. This should only be used if you know in advance that the document will contain
386
            no entity references (or perhaps if your query or stylesheet is not interested in the content
387
            of text and attribute nodes). Instead, with .NET 1.1 use an <code>XmlValidatingReader</code> (with <code>ValidationType</code>
388
            set to <code>None</code>). The constructor for <code>XmlValidatingReader</code> is obsolete in .NET 2.0,
389
            but the same effect can be achieved by using the <code>Create</code> method of <code>XmlReader</code> with
390
            appropriate <code>XmlReaderSettings</code>.</p>
391
                     <p>Conformance with the W3C specifications requires that the <code>Normalization</code> property
392
            of an <code>XmlTextReader</code> should be set to <code>true</code>. However, Saxon does not insist
393
            on this.</p>
394
                     <p>If the <code>XmlReader</code> performs schema validation, Saxon will ignore any resulting type
395
            information. Type information can only be obtained by using Saxon's own schema validator, which
396
            will be run if the <code>SchemaValidationMode</code> property is set to <code>Strict</code> or <code>Lax</code>.</p>
397
                     <p>Note that the Microsoft <code>System.Xml</code> parser does not report whether attributes are
398
            defined in the DTD as being of type <code>ID</code> and <code>IDREF</code>. This is true whether or not
399
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
400
            <code>id()</code> and <code>idref()</code> functions.</p>
401
                     <p>Note that setting the <code>XmlResolver</code> property of the <code>DocumentBuilder</code>
402
            has no effect when this method is used; if an <code>XmlResolver</code> is required, it must
403
            be set on the <code>XmlReader</code> itself.</p>
404
                  </div>
405
               </body>
406
               <return>
407
                  <body>
408
                     <div>An <code>XdmNode</code>, the document node at the root of the tree of the resulting
409
            in-memory document.
410
            </div>
411
                  </body>
412
               </return>
413
            </comment>
414
            <params>
415
               <param fulltype="System.Xml.XmlReader" type="XmlReader" name="reader">
416
                  <body>
417
                     <div>The <code>XMLReader</code> that supplies the parsed XML source</div>
418
                  </body>
419
               </param>
420
            </params>
421
         </method>
422
         <method id="Build"
423
                 visibility="public"
424
                 type="XdmNode"
425
                 fulltype="Saxon.Api.XdmNode">
426
            <comment>
427
               <sentence>
428
            Load an XML DOM document, supplied as an <code>XmlNode</code>, into a Saxon <code>XdmNode</code>.
429
            </sentence>
430
               <body>
431
                  <div>
432
                     <p>
433
            Load an XML DOM document, supplied as an <code>XmlNode</code>, into a Saxon <code>XdmNode</code>.
434
            </p>
435
                     <p>
436
            The returned document will contain only the subtree rooted at the supplied node.
437
            </p>
438
                     <p>
439
            This method copies the DOM tree to create a Saxon tree. See the <code>Wrap</code> method for
440
            an alternative that creates a wrapper around the DOM tree, allowing it to be modified in situ.
441
            </p>
442
                  </div>
443
               </body>
444
               <return>
445
                  <body>
446
                     <div>An <code>XdmNode</code>, the document node at the root of the tree of the resulting
447
            in-memory document.
448
            </div>
449
                  </body>
450
               </return>
451
            </comment>
452
            <params>
453
               <param fulltype="System.Xml.XmlNode" type="XmlNode" name="source">
454
                  <body>
455
                     <div>The DOM Node to be copied to form a Saxon tree</div>
456
                  </body>
457
               </param>
458
            </params>
459
         </method>
460
         <method id="Wrap"
461
                 visibility="public"
462
                 type="XdmNode"
463
                 fulltype="Saxon.Api.XdmNode">
464
            <comment>
465
               <sentence>
466
            Wrap an XML DOM document, supplied as an <code>XmlNode</code>, as a Saxon <code>XdmNode</code>.
467
            </sentence>
468
               <body>
469
                  <div>
470
                     <p>
471
            Wrap an XML DOM document, supplied as an <code>XmlNode</code>, as a Saxon <code>XdmNode</code>.
472
            </p>
473
                     <p>
474
            This method must be applied at the level of the Document Node. Unlike the
475
            <code>Build</code> method, the original DOM is not copied. This saves memory and
476
            time, but it also means that it is not possible to perform operations such as
477
            whitespace stripping and schema validation.
478
            </p>
479
                  </div>
480
               </body>
481
               <return>
482
                  <body>
483
                     <div>An <code>XdmNode</code>, the Saxon document node at the root of the tree of the resulting
484
            in-memory document.
485
            </div>
486
                  </body>
487
               </return>
488
            </comment>
489
            <params>
490
               <param fulltype="System.Xml.XmlDocument" type="XmlDocument" name="doc">
491
                  <body>
492
                     <div>The DOM document node to be wrapped</div>
493
                  </body>
494
               </param>
495
            </params>
496
         </method>
497
      </methods>
498
   </class>
499
   <class id="DomDestination"
500
          fulltype="Saxon.Api.DomDestination"
501
          visibility="public"
502
          superclass="XmlDestination"
503
          superclassfulltype="Saxon.Api.XmlDestination">
504
      <implements>
505
         <interface fulltype="Saxon.Api.XmlDestination" type="XmlDestination"/>
506
      </implements>
507
      <comment>
508
         <sentence>
509
            A <code>DomDestination</code> represents an <code>XmlDocument</code> that is constructed to hold the
510
            output of a query or transformation.
511
            </sentence>
512
         <body>
513
            <div>
514
               <p>
515
            A <code>DomDestination</code> represents an <code>XmlDocument</code> that is constructed to hold the
516
            output of a query or transformation.
517
            </p>
518
               <p>
519
            No data needs to be supplied to the <code>DomDestination</code> object. The query or transformation
520
            populates an <code>XmlDocument</code>, which may then be retrieved as the value of the <code>XmlDocument</code>
521
            property.
522
            </p>
523
            </div>
524
         </body>
525
      </comment>
526
      <property id="XmlDocument"
527
                type="XmlDocument"
528
                fulltype="System.Xml.XmlDocument"
529
                get="true">
530
         <comment>
531
            <sentence>After construction, retrieve the constructed document node.</sentence>
532
            <body>
533
               <div>
534
                  <p>After construction, retrieve the constructed document node.</p>
535
                  <p>If the zero-argument constructor was used, this will be a newly
536
            constructed document node. If the constructor supplied a document node, the
537
            same document node will be returned. If the constructor supplied a document fragment
538
            node or an element node, this method returns the <code>OwnerDocument</code> property of 
539
            that node.</p>
540
               </div>
541
            </body>
542
         </comment>
543
      </property>
544
      <methods>
545
         <constructor id="DomDestination" visibility="public">
546
            <comment>
547
               <sentence>Construct a <code>DomDestination</code>.</sentence>
548
               <body>
549
                  <div>
550
                     <p>Construct a <code>DomDestination</code>.</p>
551
                     <p>With this constructor, the system will create a new DOM Document
552
            to act as the destination of the query or transformation results. The document
553
            node of the new document may be retrieved via the <code>XmlDocument</code> property.</p>
554
                  </div>
555
               </body>
556
            </comment>
557
         </constructor>
558
         <constructor id="DomDestination" visibility="public">
559
            <params>
560
               <param fulltype="System.Xml.XmlDocument"
561
                      type="XmlDocument"
562
                      name="attachmentPoint">
563
                  <body>
564
                     <div>The document node to which new contents will
565
            be attached. To ensure that the new document is well-formed, this document node
566
            should have no existing children.</div>
567
                  </body>
568
               </param>
569
            </params>
570
            <comment>
571
               <sentence>Construct a <code>DomDestination</code> based on an existing document node.</sentence>
572
               <body>
573
                  <div>
574
                     <p>Construct a <code>DomDestination</code> based on an existing document node.</p>
575
                     <p>The new data will be added as a child of the supplied node.</p>
576
                  </div>
577
               </body>
578
            </comment>
579
         </constructor>
580
         <constructor id="DomDestination" visibility="public">
581
            <params>
582
               <param fulltype="System.Xml.XmlDocumentFragment"
583
                      type="XmlDocumentFragment"
584
                      name="attachmentPoint">
585
                  <body>
586
                     <div>The document fragment node to which new contents will
587
            be attached. The new contents will be added after any existing children.</div>
588
                  </body>
589
               </param>
590
            </params>
591
            <comment>
592
               <sentence>Construct a <code>DomDestination</code> based on an existing document fragment node.</sentence>
593
               <body>
594
                  <div>
595
                     <p>Construct a <code>DomDestination</code> based on an existing document fragment node.</p>
596
                     <p>The new data will be added as a child of the supplied node.</p>
597
                  </div>
598
               </body>
599
            </comment>
600
         </constructor>
601
         <constructor id="DomDestination" visibility="public">
602
            <params>
603
               <param fulltype="System.Xml.XmlElement"
604
                      type="XmlElement"
605
                      name="attachmentPoint">
606
                  <body>
607
                     <div>The element node to which new contents will
608
            be attached. The new contents will be added after any existing children.</div>
609
                  </body>
610
               </param>
611
            </params>
612
            <comment>
613
               <sentence>Construct a <code>DomDestination</code> based on an existing element node.</sentence>
614
               <body>
615
                  <div>
616
                     <p>Construct a <code>DomDestination</code> based on an existing element node.</p>
617
                     <p>The new data will be added as a child of the supplied element node.</p>
618
                  </div>
619
               </body>
620
            </comment>
621
         </constructor>
622
         <method id="Close" visibility="public" type="void" fulltype="void">
623
            <comment>
624
               <sentence>
625
            Close any resources associated with this destination. Note that this does <b>not</b>
626
            close any user-supplied OutputStream or Writer; those must be closed explicitly
627
            by the calling application.
628
            </sentence>
629
            </comment>
630
         </method>
631
         <method id="GetUnderlyingDestination"
632
                 visibility="public"
633
                 type="Destination"
634
                 fulltype="net.sf.saxon.s9api.Destination">
635
            <comment>
636
               <sentence>
637
            The underlying <code>Destination</code> object in the Saxon implementation
638
            </sentence>
639
               <body>
640
                  <div>
641
                     <p>
642
            The underlying <code>Destination</code> object in the Saxon implementation
643
            </p>
644
                     <p>This property provides access to internal methods in the Saxon engine that are
645
            not specifically exposed in the .NET API. In general these methods should be
646
            considered to be less stable than the classes in the Saxon.Api namespace.</p>
647
                     <p>The internal methods follow
648
            Java naming conventions rather than .NET conventions.</p>
649
                     <p>Information about the returned <tag kind="see">net.sf.saxon.Configuration</tag> object 
650
            (and the objects it provides access to) is included in the Saxon JavaDoc docmentation.
651
            </p>
652
                  </div>
653
               </body>
654
               <return>
655
                  <body>
656
                     <div>returns the underlying Destination object</div>
657
                  </body>
658
               </return>
659
            </comment>
660
         </method>
661
      </methods>
662
   </class>
663
   <class id="DynamicContext"
664
          fulltype="Saxon.Api.DynamicContext"
665
          visibility="public"
666
          superclass="object"
667
          superclassfulltype="System.Object">
668
      <comment>
669
         <sentence>
670
            The class <code>DynamicContext</code> provides information about the dynamic context of an expression
671
            </sentence>
672
      </comment>
673
      <property id="ContextItem"
674
                type="XdmItem"
675
                fulltype="Saxon.Api.XdmItem"
676
                get="true">
677
         <comment>
678
            <sentence>
679
            The context item. May be null if no context item is defined
680
            </sentence>
681
         </comment>
682
      </property>
683
      <property id="ContextPosition"
684
                type="int"
685
                fulltype="System.Int32"
686
                get="true">
687
         <comment>
688
            <sentence>
689
            The context position (equivalent to the XPath <code>position()</code> function).
690
            </sentence>
691
            <body>
692
               <div>
693
                  <p>
694
            The context position (equivalent to the XPath <code>position()</code> function).
695
            </p>
696
                  <p>Calling this method throws an exception if the context item is undefined.</p>
697
               </div>
698
            </body>
699
         </comment>
700
      </property>
701
      <property id="ContextSize" type="int" fulltype="System.Int32" get="true">
702
         <comment>
703
            <sentence>
704
            The context size (equivalent to the XPath <code>last()</code> function).
705
            </sentence>
706
            <body>
707
               <div>
708
                  <p>
709
            The context size (equivalent to the XPath <code>last()</code> function).
710
            </p>
711
                  <p>Calling this method throws an exception if the context item is undefined.</p>
712
               </div>
713
            </body>
714
         </comment>
715
      </property>
716
      <property id="Implementation"
717
                type="XPathContext"
718
                fulltype="net.sf.saxon.expr.XPathContext"
719
                get="true">
720
         <comment>
721
            <sentence>
722
            The underlying object in the Saxon implementation, an instance of class
723
            <code>net.sf.saxon.expr.XPathContext</code>
724
            </sentence>
725
            <body>
726
               <div>
727
                  <p>
728
            The underlying object in the Saxon implementation, an instance of class
729
            <code>net.sf.saxon.expr.XPathContext</code>
730
                  </p>
731
                  <p>This property provides access to internal methods in the Saxon engine that are
732
            not specifically exposed in the .NET API. In general these methods should be
733
            considered to be less stable than the classes in the Saxon.Api namespace.</p>
734
                  <p>The internal methods follow
735
            Java naming conventions rather than .NET conventions.</p>
736
                  <p>Information about the returned object (and the objects it provides access to)
737
            is included in the Saxon JavaDoc documentation, see <tag kind="see">net.sf.saxon.expr.XPathContext</tag>
738
                  </p>
739
               </div>
740
            </body>
741
         </comment>
742
      </property>
743
   </class>
744
   <class id="DynamicError"
745
          fulltype="Saxon.Api.DynamicError"
746
          visibility="public"
747
          superclass="Exception"
748
          superclassfulltype="System.Exception">
749
      <extends>
750
         <interface fulltype="System.Exception" type="Exception"/>
751
      </extends>
752
      <comment>
753
         <sentence>
754
            The <code>DynamicError</code> class contains information about a dynamic error detected during
755
            execution of a stylesheet, query, or XPath expression.
756
            </sentence>
757
      </comment>
758
      <property id="ErrorCode"
759
                type="QName"
760
                fulltype="Saxon.Api.QName"
761
                get="true">
762
         <comment>
763
            <sentence>
764
            The error code, as a <code>QName</code>. May be null if no error code has been assigned.
765
            </sentence>
766
         </comment>
767
      </property>
768
      <property id="IsTypeError"
769
                type="bool"
770
                fulltype="System.Boolean"
771
                get="true">
772
         <comment>
773
            <sentence>
774
            Indicate whether this condition is a type error.
775
            </sentence>
776
         </comment>
777
      </property>
778
      <property id="IsWarning"
779
                type="bool"
780
                fulltype="System.Boolean"
781
                get="true"
782
                set="true">
783
         <comment>
784
            <sentence>
785
            Indicate whether this error is being reported as a warning condition. If so, applications
786
            may ignore the condition, though the results may not be as intended.
787
            </sentence>
788
         </comment>
789
      </property>
790
      <property id="LineNumber" type="int" fulltype="System.Int32" get="true">
791
         <comment>
792
            <sentence>
793
            The line number locating the error within a query or stylesheet module.
794
            </sentence>
795
            <body>
796
               <div>
797
                  <p>
798
            The line number locating the error within a query or stylesheet module.
799
            </p>
800
                  <p>
801
            May be set to -1 if the location of the error is unknown.
802
            </p>
803
               </div>
804
            </body>
805
         </comment>
806
      </property>
807
      <property id="Message" type="string" fulltype="System.String" get="true">
808
         <comment>
809
            <sentence>
810
            Return the message associated with this error.
811
            </sentence>
812
         </comment>
813
      </property>
814
      <property id="ModuleUri"
815
                type="string"
816
                fulltype="System.String"
817
                get="true">
818
         <comment>
819
            <sentence>
820
            The URI of the query or stylesheet module in which the error was detected
821
            (as a string).
822
            </sentence>
823
            <body>
824
               <div>
825
                  <p>
826
            The URI of the query or stylesheet module in which the error was detected
827
            (as a string).
828
            </p>
829
                  <p>
830
            May be null if the location of the error is unknown, or if the error is not
831
            localized to a specific module, or if the module in question has no known URI
832
            (for example, if it was supplied as an anonymous <code>Stream</code>).
833
            </p>
834
               </div>
835
            </body>
836
         </comment>
837
      </property>
838
      <property id="UnderlyingException"
839
                type="XPathException"
840
                fulltype="net.sf.saxon.trans.XPathException"
841
                get="true">
842
         <comment>
843
            <sentence>
844
            Return the underlying exception. This is unstable as this is an internal object.
845
            </sentence>
846
            <return>
847
               <body>
848
                  <div>The underlying <code>XPathException</code>
849
                  </div>
850
               </body>
851
            </return>
852
         </comment>
853
      </property>
854
      <methods>
855
         <constructor id="DynamicError" visibility="public">
856
            <params>
857
               <param fulltype="System.String" type="string" name="message">
858
                  <body>
859
                     <div>The error message</div>
860
                  </body>
861
               </param>
862
            </params>
863
            <comment>
864
               <sentence>
865
            Create a new <code>DynamicError</code>, specifying the error message.
866
            </sentence>
867
            </comment>
868
         </constructor>
869
         <method id="ToString"
870
                 visibility="public"
871
                 type="string"
872
                 fulltype="System.String">
873
            <comment>
874
               <sentence>
875
            Return the error message.
876
            </sentence>
877
            </comment>
878
         </method>
879
      </methods>
880
   </class>
881
   <class id="EmptyEnumerator"
882
          fulltype="Saxon.Api.EmptyEnumerator"
883
          visibility="public"
884
          superclass="IEnumerator"
885
          superclassfulltype="System.Collections.IEnumerator">
886
      <extends>
887
         <interface fulltype="System.Collections.IEnumerator" type="IEnumerator">
888
            <type fulltype="T" type="T"/>
889
         </interface>
890
      </extends>
891
      <type fulltype="T" type="T"/>
892
      <comment>
893
         <sentence>
894
            An implementation of <code>IEnumerator</code> that iterates over an empty sequence.
895
            </sentence>
896
      </comment>
897
      <methods>
898
         <method id="Dispose" visibility="public" type="void" fulltype="void">
899
            <comment>
900
               <sentence>
901
            The Dispose method is not implemented on this Enumerator
902
            </sentence>
903
            </comment>
904
         </method>
905
         <method id="MoveNext"
906
                 visibility="public"
907
                 type="bool"
908
                 fulltype="System.Boolean">
909
            <comment>
910
               <sentence>
911
            Move to the next item in the enumerator..
912
            </sentence>
913
               <return>
914
                  <body>
915
                     <div>true if successful move, false otherwise.</div>
916
                  </body>
917
               </return>
918
            </comment>
919
         </method>
920
         <method id="Reset" visibility="public" type="void" fulltype="void">
921
            <comment>
922
               <sentence>
923
            Reset the enumerator
924
            </sentence>
925
            </comment>
926
         </method>
927
      </methods>
928
      <fields>
929
         <field id="INSTANCE"
930
                type="EmptyEnumerator"
931
                fulltype="Saxon.Api.EmptyEnumerator"
932
                visibility="public"
933
                static="true">
934
            <type fulltype="Saxon.Api.XdmItem" type="XdmItem"/>
935
            <comment>
936
               <sentence>
937
            Create an instance of the enumerator with the <code>XdmItem</code> as the generic type
938
            </sentence>
939
            </comment>
940
         </field>
941
         <field id="NODE_INSTANCE"
942
                type="EmptyEnumerator"
943
                fulltype="Saxon.Api.EmptyEnumerator"
944
                visibility="public"
945
                static="true">
946
            <type fulltype="Saxon.Api.XdmNode" type="XdmNode"/>
947
            <comment>
948
               <sentence>
949
            Create an instance of the enumerator with the <code>XdmNode</code> as the generic type
950
            </sentence>
951
            </comment>
952
         </field>
953
      </fields>
954
   </class>
955
   <class id="ErrorReporter"
956
          fulltype="Saxon.Api.ErrorReporter"
957
          visibility="public"
958
          superclass="ErrorReporter"
959
          superclassfulltype="net.sf.saxon.lib.ErrorReporter">
960
      <extends>
961
         <interface fulltype="net.sf.saxon.lib.ErrorReporter" type="ErrorReporter"/>
962
      </extends>
963
      <comment>
964
         <sentence>
965
            The <code>ErrorReporter</code> is a generic functional class for reporting errors and warnings.
966
            This class wraps an <code>IList</code> of <code>XmlProcessingError</code> objects.
967
            It is designed to be used internally by Saxon.
968
            </sentence>
969
      </comment>
970
      <property id="ErrorList"
971
                type="IList"
972
                fulltype="System.Collections.IList"
973
                get="true">
974
         <type fulltype="Saxon.Api.XmlProcessingError" type="XmlProcessingError"/>
975
         <comment>
976
            <sentence>
977
            Get property on the wrapped error list.
978
            </sentence>
979
         </comment>
980
      </property>
981
      <methods>
982
         <constructor id="ErrorReporter" visibility="public">
983
            <params>
984
               <param fulltype="System.Collections.IList" type="IList" name="errorList">
985
                  <type fulltype="Saxon.Api.XmlProcessingError" type="XmlProcessingError"/>
986
                  <body>
987
                     <div>Error list.</div>
988
                  </body>
989
               </param>
990
            </params>
991
            <comment>
992
               <sentence>
993
            Initializes a new instance of the <tag kind="see">Saxon.Api.ErrorReporter</tag> class.
994
            </sentence>
995
            </comment>
996
         </constructor>
997
         <method id="report" visibility="public" type="void" fulltype="void">
998
            <comment>
999
               <sentence>
1000
            Report an error. This method is called by Saxon when an error needs to be reported to the calling application.
1001
            </sentence>
1002
            </comment>
1003
            <params>
1004
               <param fulltype="Saxon.Api.XmlProcessingError"
1005
                      type="XmlProcessingError"
1006
                      name="error">
1007
                  <body>
1008
                     <div>Details of the error to be reported</div>
1009
                  </body>
1010
               </param>
1011
            </params>
1012
         </method>
1013
      </methods>
1014
   </class>
1015
   <class id="ErrorReporterToStaticError"
1016
          fulltype="Saxon.Api.ErrorReporterToStaticError"
1017
          visibility="public"
1018
          superclass="ErrorReporter"
1019
          superclassfulltype="net.sf.saxon.lib.ErrorReporter">
1020
      <extends>
1021
         <interface fulltype="net.sf.saxon.lib.ErrorReporter" type="ErrorReporter"/>
1022
      </extends>
1023
      <comment>
1024
         <sentence>
1025
            <code>ErrorReporter</code> for gathering errors as <code>XmlProcessorError</code> to then
1026
            convert them to a list of <code>StaticError</code>s.
1027
            </sentence>
1028
      </comment>
1029
      <property id="ErrorList"
1030
                type="IList"
1031
                fulltype="System.Collections.IList"
1032
                get="true">
1033
         <type fulltype="Saxon.Api.StaticError" type="StaticError"/>
1034
      </property>
1035
      <methods>
1036
         <constructor id="ErrorReporterToStaticError" visibility="public">
1037
            <params>
1038
               <param fulltype="System.Collections.IList" type="IList" name="errorList">
1039
                  <type fulltype="Saxon.Api.StaticError" type="StaticError"/>
1040
                  <body>
1041
                     <div>Error list.</div>
1042
                  </body>
1043
               </param>
1044
            </params>
1045
            <comment>
1046
               <sentence>
1047
            Initializes a new instance of the <tag kind="see">Saxon.Api.ErrorReporter</tag> class.
1048
            </sentence>
1049
            </comment>
1050
         </constructor>
1051
         <method id="report" visibility="public" type="void" fulltype="void">
1052
            <params>
1053
               <param fulltype="net.sf.saxon.s9api.XmlProcessingError"
1054
                      type="XmlProcessingError"
1055
                      name="xpe"/>
1056
            </params>
1057
         </method>
1058
      </methods>
1059
   </class>
1060
   <class id="ErrorReporterWrapper"
1061
          fulltype="Saxon.Api.ErrorReporterWrapper"
1062
          visibility="public"
1063
          superclass="ErrorReporter"
1064
          superclassfulltype="net.sf.saxon.lib.ErrorReporter">
1065
      <extends>
1066
         <interface fulltype="net.sf.saxon.lib.ErrorReporter" type="ErrorReporter"/>
1067
      </extends>
1068
      <comment>
1069
         <sentence>
1070
            <code>ErrorReporter</code> wrapper class for internal use in Saxon.
1071
            </sentence>
1072
      </comment>
1073
      <property id="ErrorReporter"
1074
                type="IErrorReporter"
1075
                fulltype="Saxon.Api.IErrorReporter"
1076
                get="true">
1077
      </property>
1078
      <methods>
1079
         <constructor id="ErrorReporterWrapper" visibility="public">
1080
            <params>
1081
               <param fulltype="Saxon.Api.IErrorReporter"
1082
                      type="IErrorReporter"
1083
                      name="reporter">
1084
                  <body>
1085
                     <div>The .NET <code>IErrorReporter</code>
1086
                     </div>
1087
                  </body>
1088
               </param>
1089
            </params>
1090
            <comment>
1091
               <sentence>
1092
            Create a standard <code>ErrorReporter</code>
1093
               </sentence>
1094
            </comment>
1095
         </constructor>
1096
         <method id="report" visibility="public" type="void" fulltype="void">
1097
            <params>
1098
               <param fulltype="net.sf.saxon.s9api.XmlProcessingError"
1099
                      type="XmlProcessingError"
1100
                      name="xpe"/>
1101
            </params>
1102
         </method>
1103
      </methods>
1104
   </class>
1105
   <interface id="ExtensionFunction"
1106
              fulltype="Saxon.Api.ExtensionFunction"
1107
              visibility="public"
1108
              superclass="object"
1109
              superclassfulltype="System.Object">
1110
      <comment>
1111
         <sentence>
1112
            This is an interface for simple external/extension functions.
1113
            Users can implement this interface and register the implementation with the <tag kind="see">Saxon.Api.Processor</tag>;
1114
            the function will then be available for calling from all queries, stylesheets, and XPath expressions compiled
1115
            under this Processor.
1116
            </sentence>
1117
         <body>
1118
            <div>
1119
               <p>
1120
            This is an interface for simple external/extension functions.
1121
            Users can implement this interface and register the implementation with the <tag kind="see">Saxon.Api.Processor</tag>;
1122
            the function will then be available for calling from all queries, stylesheets, and XPath expressions compiled
1123
            under this Processor.
1124
            </p>
1125
               <p>Extension functions implemented using this interface are expected to be free of side-effects,
1126
            and to have no dependencies on the static or dynamic context. A richer interface for extension
1127
            functions is provided via the <tag kind="see">Saxon.Api.ExtensionFunctionDefinition</tag> class.</p>
1128
            </div>
1129
         </body>
1130
      </comment>
1131
      <methods>
1132
         <method id="Call"
1133
                 visibility="public"
1134
                 type="XdmValue"
1135
                 fulltype="Saxon.Api.XdmValue">
1136
            <comment>
1137
               <sentence>
1138
            Method called at run time to evaluate the function.
1139
            </sentence>
1140
               <return>
1141
                  <body>
1142
                     <div>An <code>XdmValue</code>, representing the result of the extension function. 
1143
            (Note: in many cases it will be convenient to return an <code>XdmAtomicValue</code> or <code>XdmNode</code>, 
1144
            both of which are instances of <code>XdmValue</code>).</div>
1145
                  </body>
1146
               </return>
1147
            </comment>
1148
            <params>
1149
               <param fulltype="Saxon.Api.XdmValue[]" type="XdmValue[]" name="arguments">
1150
                  <body>
1151
                     <div>The values of the arguments supplied in the XPath function call.</div>
1152
                  </body>
1153
               </param>
1154
            </params>
1155
         </method>
1156
         <method id="GetArgumentTypes"
1157
                 visibility="public"
1158
                 type="XdmSequenceType[]"
1159
                 fulltype="Saxon.Api.XdmSequenceType">
1160
            <comment>
1161
               <sentence>
1162
            Declare the type of the arguments
1163
            </sentence>
1164
               <return>
1165
                  <body>
1166
                     <div>an array of <code>XdmSequenceType</code> objects, one for each argument to the function,
1167
            representing the expected types of the arguments</div>
1168
                  </body>
1169
               </return>
1170
            </comment>
1171
         </method>
1172
         <method id="GetName"
1173
                 visibility="public"
1174
                 type="QName"
1175
                 fulltype="Saxon.Api.QName">
1176
            <comment>
1177
               <sentence>
1178
            Return the name of the external function
1179
            </sentence>
1180
               <return>
1181
                  <body>
1182
                     <div>the name of the function, as a <code>QName</code>
1183
                     </div>
1184
                  </body>
1185
               </return>
1186
            </comment>
1187
         </method>
1188
         <method id="GetResultType"
1189
                 visibility="public"
1190
                 type="XdmSequenceType"
1191
                 fulltype="Saxon.Api.XdmSequenceType">
1192
            <comment>
1193
               <sentence>
1194
            Declare the result type of the external function
1195
            </sentence>
1196
               <return>
1197
                  <body>
1198
                     <div>the result type of the external function</div>
1199
                  </body>
1200
               </return>
1201
            </comment>
1202
         </method>
1203
      </methods>
1204
   </interface>
1205
   <class id="ExtensionFunctionCall"
1206
          fulltype="Saxon.Api.ExtensionFunctionCall"
1207
          visibility="public"
1208
          superclass="object"
1209
          superclassfulltype="System.Object"
1210
          abstract="true">
1211
      <comment>
1212
         <sentence>
1213
            An instance of this class will be created by the compiler for each function call to this extension function
1214
            that is found in the source code. The class is always instantiated by calling the method <code>MakeFunctionCall()</code>
1215
            of the corresponding <code>ExtensionFunctionDefinition</code>. 
1216
            The implementation may therefore retain information about the static context of the
1217
            call. Once compiled, however, the instance object must be immutable.
1218
            </sentence>
1219
      </comment>
1220
      <methods>
1221
         <method id="Call"
1222
                 visibility="public"
1223
                 type="IEnumerator"
1224
                 fulltype="System.Collections.IEnumerator"
1225
                 abstract="true">
1226
            <type fulltype="Saxon.Api.XdmItem" type="XdmItem"/>
1227
            <comment>
1228
               <sentence>
1229
            Method called at run time to evaluate the function.
1230
            </sentence>
1231
               <return>
1232
                  <body>
1233
                     <div>An iterator over a sequence, representing the result of the extension function.
1234
            Note that Saxon does not guarantee to read this sequence to completion, so calls on the iterator
1235
            must have no side-effects. In rare circumstances (for example, when <code>last()</code> is
1236
            used) Saxon may clone the returned iterator by calling its <code>GetAnother()</code> method, 
1237
            allowing the function results to be read more than once.</div>
1238
                  </body>
1239
               </return>
1240
            </comment>
1241
            <params>
1242
               <param fulltype="System.Collections.IEnumerator"
1243
                      type="IEnumerator"
1244
                      name="arguments">
1245
                  <type fulltype="Saxon.Api.XdmItem" type="XdmItem"/>
1246
                  <body>
1247
                     <div>The values of the arguments to the function, supplied as iterators over XPath
1248
            sequence values.</div>
1249
                  </body>
1250
               </param>
1251
               <param fulltype="Saxon.Api.DynamicContext"
1252
                      type="DynamicContext"
1253
                      name="context">
1254
                  <body>
1255
                     <div>The dynamic context for evaluation of the function. This provides access
1256
            to the context item, position, and size, and if required to internal data maintained by the Saxon
1257
            engine.</div>
1258
                  </body>
1259
               </param>
1260
            </params>
1261
         </method>
1262
         <method id="CopyLocalData"
1263
                 visibility="public"
1264
                 type="void"
1265
                 fulltype="void">
1266
            <comment>
1267
               <sentence>
1268
            A subclass must implement this method if it retains any local data at the instance level. On some occasions
1269
            (for example, when XSLT or XQuery code is inlined), Saxon will make a copy of an <code>ExtensionFunction</code> object.
1270
            It will then call this method on the old object, supplying the new object as the value of the argument, and the
1271
            method must copy all local data items from the old object to the new.
1272
            </sentence>
1273
            </comment>
1274
            <params>
1275
               <param fulltype="Saxon.Api.ExtensionFunctionCall"
1276
                      type="ExtensionFunctionCall"
1277
                      name="destination">
1278
                  <body>
1279
                     <div>The new extension function object. This will always be an instance of the same
1280
            class as the existing object.</div>
1281
                  </body>
1282
               </param>
1283
            </params>
1284
         </method>
1285
         <method id="SupplyStaticContext"
1286
                 visibility="public"
1287
                 type="void"
1288
                 fulltype="void">
1289
            <comment>
1290
               <sentence>
1291
            Method called by the compiler (at compile time) to provide information about the static context of the
1292
            function call. The implementation may retain this information for use at run-time, if the result of the
1293
            function depends on information in the static context.
1294
            </sentence>
1295
               <body>
1296
                  <div>
1297
                     <p>
1298
            Method called by the compiler (at compile time) to provide information about the static context of the
1299
            function call. The implementation may retain this information for use at run-time, if the result of the
1300
            function depends on information in the static context.
1301
            </p>
1302
                     <p>
1303
            For efficiency, the implementation should only retain copies of the information that it actually needs. It
1304
            is not a good idea to hold a reference to the static context itself, since that can result in a great deal of
1305
            compile-time information being locked into memory during run-time execution.
1306
            </p>
1307
                  </div>
1308
               </body>
1309
            </comment>
1310
            <params>
1311
               <param fulltype="Saxon.Api.StaticContext"
1312
                      type="StaticContext"
1313
                      name="context">
1314
                  <body>
1315
                     <div>Information about the static context in which the function is called</div>
1316
                  </body>
1317
               </param>
1318
            </params>
1319
         </method>
1320
      </methods>
1321
   </class>
1322
   <class id="ExtensionFunctionDefinition"
1323
          fulltype="Saxon.Api.ExtensionFunctionDefinition"
1324
          visibility="public"
1325
          superclass="object"
1326
          superclassfulltype="System.Object"
1327
          abstract="true">
1328
      <comment>
1329
         <sentence>
1330
            <p>Abstract superclass for user-written extension functions. An extension function may be implemented as a subclass
1331
            of this class, with appropriate implementations of the defined methods.</p>
1332
            <p>More precisely, a subclass of <code>ExtensionFunctionDefinition</code> identifies a family of extension functions
1333
            with the same (namespace-qualified) name but potentially having different arity (number of arguments).</p>
1334
         </sentence>
1335
         <body>
1336
            <div>
1337
               <p>
1338
                  <p>Abstract superclass for user-written extension functions. An extension function may be implemented as a subclass
1339
            of this class, with appropriate implementations of the defined methods.</p>
1340
                  <p>More precisely, a subclass of <code>ExtensionFunctionDefinition</code> identifies a family of extension functions
1341
            with the same (namespace-qualified) name but potentially having different arity (number of arguments).</p>
1342
               </p>
1343
               <p>A user-defined extension function is typically implemented using a pair of classes: a class that extends 
1344
            <code>ExtensionFunctionDefinition</code>, whose purpose is to define the properties of the extension function
1345
            (in particular, its signature -- the types of its arguments and result); and a class that extends
1346
            <code>ExtensionFunctionCall</code>, whose purpose is to perform the actual evaluation.</p>
1347
               <p>The <code>ExtensionFunctionDefinition</code> is immutable and will normally have a singleton instance
1348
            for each subclass; this singleton instance is registered with the <code>Processor</code> to associate the
1349
            name of the extension function with its definition.</p>
1350
               <p>The <code>ExtensionFunctionCall</code> has one instance for each call on the extension function appearing
1351
            in the source code of a stylesheet or query; this instance is created when Saxon calls the method <code>MakeFunctionCall</code>
1352
            provided by the <code>ExtensionFunctionDefinition</code> object. The instance of <code>ExtensionFunctionCall</code>
1353
            holds information about the static context of the function call, and its <code>Call</code> method is called
1354
            (by Saxon) to evaluate the extension function at run-time.</p>
1355
            </div>
1356
         </body>
1357
      </comment>
1358
      <property id="ArgumentTypes"
1359
                type="XdmSequenceType[]"
1360
                fulltype="Saxon.Api.XdmSequenceType"
1361
                abstract="true"
1362
                get="true">
1363
         <comment>
1364
            <sentence>
1365
            Read-only property giving the required types of the arguments to this extension function. 
1366
            If the number of items in the array is less than the maximum number of arguments, 
1367
            then the last entry in the returned <code>ArgumentTypes</code> is assumed to apply to all the rest; 
1368
            if the returned array is empty, then all arguments are assumed to be of type <code>item()*</code>
1369
            </sentence>
1370
            <body>
1371
               <div>
1372
                  <p>
1373
            Read-only property giving the required types of the arguments to this extension function. 
1374
            If the number of items in the array is less than the maximum number of arguments, 
1375
            then the last entry in the returned <code>ArgumentTypes</code> is assumed to apply to all the rest; 
1376
            if the returned array is empty, then all arguments are assumed to be of type <code>item()*</code>
1377
                  </p>
1378
                  <p>
1379
            A getter for this property must be implemented in every subclass.
1380
            </p>
1381
               </div>
1382
            </body>
1383
            <return>
1384
               <body>
1385
                  <div>
1386
            An array of <code>XdmSequenceType</code> objects representing the required types of the arguments 
1387
            to the extension function.
1388
            </div>
1389
               </body>
1390
            </return>
1391
         </comment>
1392
      </property>
1393
      <property id="DependsOnFocus"
1394
                type="bool"
1395
                fulltype="System.Boolean"
1396
                get="true">
1397
         <comment>
1398
            <sentence>
1399
            This property must return true for a subclass if the evaluation of the function makes use of the context
1400
            item, position, or size from the dynamic context. It should also return true (despite the property name)
1401
            if the function makes use of parts of the static context that vary from one part of the query or stylesheet
1402
            to another. Setting the property to true inhibits certain Saxon optimizations, such as extracting the call
1403
            from a loop, or moving it into a global variable.
1404
            </sentence>
1405
            <body>
1406
               <div>
1407
                  <p>
1408
            This property must return true for a subclass if the evaluation of the function makes use of the context
1409
            item, position, or size from the dynamic context. It should also return true (despite the property name)
1410
            if the function makes use of parts of the static context that vary from one part of the query or stylesheet
1411
            to another. Setting the property to true inhibits certain Saxon optimizations, such as extracting the call
1412
            from a loop, or moving it into a global variable.
1413
            </p>
1414
                  <p>
1415
            The default value of this property is <code>false</code>. A getter for this property may be implemented in a subclass
1416
            to return a different value.
1417
            </p>
1418
               </div>
1419
            </body>
1420
         </comment>
1421
      </property>
1422
      <property id="FunctionName"
1423
                type="QName"
1424
                fulltype="Saxon.Api.QName"
1425
                abstract="true"
1426
                get="true">
1427
         <comment>
1428
            <sentence>
1429
            Read-only property returning the name of the extension function, as a <code>QName</code>.
1430
            </sentence>
1431
            <body>
1432
               <div>
1433
                  <p>
1434
            Read-only property returning the name of the extension function, as a <code>QName</code>.
1435
            </p>
1436
                  <p>
1437
            A getter for this property must be implemented in every subclass.
1438
            </p>
1439
               </div>
1440
            </body>
1441
         </comment>
1442
      </property>
1443
      <property id="HasSideEffects"
1444
                type="bool"
1445
                fulltype="System.Boolean"
1446
                get="true">
1447
         <comment>
1448
            <sentence>
1449
            This property should return true for a subclass if the evaluation of the function has side-effects.
1450
            Saxon never guarantees the result of calling functions with side-effects, but if this property is set,
1451
            then certain aggressive optimizations will be avoided, making it more likely that the function behaves
1452
            as expected.
1453
            </sentence>
1454
            <body>
1455
               <div>
1456
                  <p>
1457
            This property should return true for a subclass if the evaluation of the function has side-effects.
1458
            Saxon never guarantees the result of calling functions with side-effects, but if this property is set,
1459
            then certain aggressive optimizations will be avoided, making it more likely that the function behaves
1460
            as expected.
1461
            </p>
1462
                  <p>
1463
            The default value of this property is <code>false</code>. A getter for this property may be implemented in a subclass
1464
            to return a different value.
1465
            </p>
1466
               </div>
1467
            </body>
1468
         </comment>
1469
      </property>
1470
      <property id="MaximumNumberOfArguments"
1471
                type="int"
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff