Project

Profile

Help

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

he / latest9.3 / hen / csource / api / Saxon.Api / Destination.cs @ c740a133

1
using System;
2
using System.IO;
3
using System.Xml;
4
using System.Collections;
5
using JConfiguration = net.sf.saxon.Configuration;
6
using JReceiver = net.sf.saxon.@event.Receiver;
7
using JProperties = java.util.Properties;
8
using JOutputStream = java.io.OutputStream;
9
using JWriter = java.io.Writer;
10
using JFileOutputStream = java.io.FileOutputStream;
11
using JXPathException = net.sf.saxon.trans.XPathException;
12
using JResult = javax.xml.transform.Result;
13
using JStreamResult = javax.xml.transform.stream.StreamResult;
14
using JBuilder = net.sf.saxon.@event.Builder;
15
using JTinyBuilder = net.sf.saxon.tree.tiny.TinyBuilder;
16
using JTreeBuilder = net.sf.saxon.tree.linked.LinkedTreeBuilder;
17
using net.sf.saxon.@event;
18
using net.sf.saxon.lib;
19
using net.sf.saxon.om;
20
using net.sf.saxon.value;
21
using net.sf.saxon.query;
22
using net.sf.saxon.dotnet;
23

    
24

    
25
namespace Saxon.Api
26
{
27

    
28

    
29

    
30
    /// <summary>
31
    /// An abstract destination for the results of a query or transformation
32
    /// </summary>
33
    /// <remarks>
34
    /// <para>Note to implementors: To implement a new kind of destination, you need
35
    /// to supply a method <c>getResult</c> which returns an implementation of
36
    /// the JAXP <c>Result</c> interface. Optionally, if the destination
37
    /// performs serialization, you can also implement <c>getOutputProperties</c>,
38
    /// which returns the properties used for serialization.
39
    /// </para>
40
    /// </remarks>
41

    
42

    
43
    public abstract class XmlDestination
44
    {
45

    
46
        /// <summary>
47
        /// Get a <c>Result</c> to which the XML document can be sent as a series
48
        /// of events.
49
        /// </summary>
50
        /// <remarks>
51
        /// This must be an implementation of the JAXP <c>Result</c> interface that is
52
        /// recognized by Saxon.
53
        /// </remarks>
54

    
55
        public abstract JResult GetResult();
56

    
57
        /// <summary>
58
        /// Get a set of <c>Properties</c> representing the parameters to the serializer.
59
        /// The default implementation returns an empty set of properties.
60
        /// </summary>
61

    
62
        public virtual JProperties GetOutputProperties()
63
        {
64
            return new JProperties();
65
        }
66

    
67
        /// <summary>
68
        /// Close the Destination, releasing any resources that need to be released.
69
        /// </summary>
70
        /// <remarks>
71
        /// This method is called by the system on completion of a query or transformation.
72
        /// Some kinds of Destination may need to close an output stream, others might
73
        /// not need to do anything. The default implementation does nothing.
74
        /// </remarks>
75

    
76
        public virtual void Close()
77
        {
78
        }
79

    
80

    
81
    }
82

    
83
    /// <summary>
84
    /// A <c>Serializer</c> takes a tree representation of XML and turns
85
    /// it into lexical XML markup.
86
    /// </summary>
87
    /// <remarks>
88
    /// Note that this is serialization in the sense of the W3C XSLT and XQuery specifications.
89
    /// Unlike the class <c>System.Xml.Serialization.XmlSerializer</c>, this object does not
90
    /// serialize arbitrary CLI objects.
91
    /// </remarks>
92

    
93
    public class Serializer : XmlDestination
94
    {
95

    
96
        private JProperties props = new JProperties();
97
        private JOutputStream outputStream = null;
98
        private JWriter writer = null;
99
        private bool mustClose = true;
100

    
101

    
102
        /// <summary>QName identifying the serialization parameter "method". If the method
103
        /// is a user-defined method, then it is given as a QName in Clark notation, that is
104
        /// "{uri}local".</summary>
105

    
106
        public static readonly QName METHOD =
107
            new QName("", "method");
108

    
109
        /// <summary>QName identifying the serialization parameter "byte-order-mark"</summary>
110

    
111
        public static readonly QName BYTE_ORDER_MARK =
112
            new QName("", "byte-order-mark");
113

    
114
        /// <summary>QName identifying the serialization parameter "cdata-section-elements".
115
        /// The value of this parameter is given as a space-separated list of expanded QNames in
116
        /// Clark notation, that is "{uri}local".</summary>
117

    
118
        public static readonly QName CDATA_SECTION_ELEMENTS =
119
            new QName("", "cdata-section-elements");
120

    
121
        /// <summary>QName identifying the serialization parameter "doctype-public"</summary>
122

    
123
        public static readonly QName DOCTYPE_PUBLIC =
124
            new QName("", "doctype-public");
125

    
126
        /// <summary>QName identifying the serialization parameter "doctype-system"</summary>
127

    
128
        public static readonly QName DOCTYPE_SYSTEM =
129
            new QName("", "doctype-system");
130

    
131
        /// <summary>QName identifying the serialization parameter "encoding"</summary>
132

    
133
        public static readonly QName ENCODING =
134
            new QName("", "encoding");
135

    
136
        /// <summary>QName identifying the serialization parameter "escape-uri-attributes".
137
        /// The value is the string "yes" or "no".</summary>
138

    
139
        public static readonly QName ESCAPE_URI_ATTRIBUTES =
140
            new QName("", "escape-uri-attributes");
141

    
142
        /// <summary>QName identifying the serialization parameter "include-content-type".
143
        /// The value is the string "yes" or "no".</summary>
144

    
145
        public static readonly QName INCLUDE_CONTENT_TYPE =
146
            new QName("", "include-content-type");
147

    
148
        /// <summary>QName identifying the serialization parameter "indent".
149
        /// The value is the string "yes" or "no".</summary>
150

    
151
        public static readonly QName INDENT =
152
            new QName("", "indent");
153

    
154
        /// <summary>QName identifying the serialization parameter "media-type".</summary>
155

    
156
        public static readonly QName MEDIA_TYPE =
157
            new QName("", "media-type");
158

    
159
        /// <summary>QName identifying the serialization parameter "normalization-form"</summary>
160

    
161
        public static readonly QName NORMALIZATION_FORM =
162
            new QName("", "normalization-form");
163

    
164
        /// <summary>QName identifying the serialization parameter "omit-xml-declaration".
165
        /// The value is the string "yes" or "no".</summary>
166

    
167
        public static readonly QName OMIT_XML_DECLARATION =
168
            new QName("", "omit-xml-declaration");
169

    
170
        /// <summary>QName identifying the serialization parameter "standalone".
171
        /// The value is the string "yes" or "no" or "omit".</summary>
172

    
173
        public static readonly QName STANDALONE =
174
            new QName("", "standalone");
175

    
176
        /// <summary>QName identifying the serialization parameter "undeclare-prefixes".
177
        /// The value is the string "yes" or "no".</summary>
178

    
179
        public static readonly QName UNDECLARE_PREFIXES =
180
            new QName("", "undeclare-prefixes");
181

    
182
        /// <summary>QName identifying the serialization parameter "use-character-maps".
183
        /// This is available only with XSLT. The value of the parameter is a list of expanded QNames
184
        /// in Clark notation giving the names of character maps defined in the XSLT stylesheet.</summary>
185

    
186
        public static readonly QName USE_CHARACTER_MAPS =
187
            new QName("", "use-character-maps");
188

    
189
        /// <summary>QName identifying the serialization parameter "version"</summary>
190

    
191
        public static readonly QName VERSION =
192
            new QName("", "version");
193

    
194
        private const String SAXON = NamespaceConstant.SAXON;
195

    
196

    
197
        /// <summary>QName identifying the serialization parameter "saxon:character-representation"</summary>
198

    
199

    
200
        public static readonly QName SAXON_CHARACTER_REPRESENTATION =
201
            new QName(SAXON, "saxon:character-representation");
202

    
203
        /// <summary>QName identifying the serialization parameter "saxon:indent-spaces". The value
204
        /// is an integer (represented as a string) indicating the amount of indentation required.
205
        /// If specified, this parameter overrides indent="no".</summary>
206

    
207
        public static readonly QName SAXON_INDENT_SPACES =
208
            new QName(SAXON, "saxon:indent-spaces");
209

    
210
        /// <summary>QName identifying the serialization parameter "saxon:double-space". The value of this 
211
        /// parameter is given as a space-separated list of expanded QNames in Clark notation, that is 
212
        /// "{uri}local"; each QName identifies an element that should be preceded by an extra blank line within
213
        /// indented output.</summary>
214

    
215
        public static readonly QName SAXON_DOUBLE_SPACE =
216
            new QName(SAXON, "saxon:double-space");
217

    
218
        /// <summary>QName identifying the serialization parameter "suppress-indentation". The value of this 
219
        /// parameter is given as a space-separated list of expanded QNames in Clark notation, that is 
220
        /// "{uri}local"; each QName identifies an element whose content should not be indented even when
221
        /// indent=yes is specified. This serialization parameter was originally introduced in Saxon
222
        /// and has since been adopted as a standard W3C serialization parameter. It is therefore
223
        /// available both as SAXON_SUPPRESS_INDENTATION and as SUPPRESS_INDENTATION</summary>
224

    
225
        public static readonly QName SAXON_SUPPRESS_INDENTATION =
226
            new QName(SAXON, "suppress-indentation");
227
            
228
        public static readonly QName SUPPRESS_INDENTATION = SAXON_SUPPRESS_INDENTATION; 
229

    
230
        /// <summary>QName identifying the serialization parameter "saxon:next-in-chain". This
231
        /// is available only with XSLT, and identifies the URI of a stylesheet that is to be used to
232
        /// process the results before passing them to their final destination.</summary>
233

    
234
        public static readonly QName NEXT_IN_CHAIN =
235
            new QName(SAXON, "saxon:next-in-chain");
236

    
237
        /// <summary>QName identifying the serialization parameter "saxon:require-well-formed". The
238
        /// value is the string "yes" or "no". If set to "yes", the output must be a well-formed
239
        /// document, or an error will be reported. ("Well-formed" here means that the document node
240
        /// must have exactly one element child, and no text node children other than whitespace-only
241
        /// text nodes).</summary>
242

    
243
        public static readonly QName SAXON_REQUIRE_WELL_FORMED =
244
            new QName(SAXON, "saxon:require-well-formed");
245

    
246

    
247
        /// <summary>Create a Serializer</summary>
248

    
249
        public Serializer()
250
        {
251
        }
252

    
253
        /// <summary>Set a serialization property</summary>
254
        /// <remarks>In the case of XSLT, properties set within the serializer override
255
        /// any properties set in <c>xsl:output</c> declarations in the stylesheet.
256
        /// Similarly, with XQuery, they override any properties set in the Query
257
        /// prolog using <c>declare option saxon:output</c>.</remarks>
258
        /// <example>
259
        ///   <code>
260
        ///     Serializer qout = new Serializer();
261
        ///     qout.SetOutputProperty(Serializer.METHOD, "xml");
262
        ///     qout.SetOutputProperty(Serializer.INDENT, "yes");
263
        ///     qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "1");
264
        ///   </code>
265
        /// </example> 
266
        /// <param name="name">The name of the serialization property to be set</param>
267
        /// <param name="value">The value to be set for the serialization property. May be null
268
        /// to unset the property (that is, to set it back to the default value).</param>
269

    
270
        public void SetOutputProperty(QName name, String value)
271
        {
272
            props.setProperty(name.ClarkName, value);
273
        }
274

    
275
        /// <summary>Specify the destination of the serialized output, in the
276
        /// form of a file name</summary>
277
        /// <param name="filename">The name of the file to receive the serialized output</param>
278
        /// <exception>Throws a <c>DynamicError</c> if it is not possible to create an output
279
        /// stream to write to this file, for example, if the filename is in a directory
280
        /// that does not exist.</exception>
281

    
282
        public void SetOutputFile(String filename)
283
        {
284
            try
285
            {
286
                outputStream = new JFileOutputStream(filename);
287
                mustClose = true;
288
            }
289
            catch (java.io.IOException err)
290
            {
291
                JXPathException e = new JXPathException(err);
292
                throw new DynamicError(e);
293
            }
294
        }
295

    
296
        /// <summary>Specify the destination of the serialized output, in the
297
        /// form of a <c>Stream</c></summary>
298
        /// <remarks>Saxon will not close the stream on completion; this is the
299
        /// caller's responsibility.</remarks>
300
        /// <param name="stream">The stream to which the output will be written.
301
        /// This must be a stream that allows writing.</param>
302

    
303
        public void SetOutputStream(Stream stream)
304
        {
305
            outputStream = new DotNetOutputStream(stream);
306
            mustClose = false;
307
        }
308

    
309
        /// <summary>Specify the destination of the serialized output, in the
310
        /// form of a <c>TextWriter</c></summary>
311
        /// <remarks>Note that when writing to a <c>TextWriter</c>, character encoding is
312
        /// the responsibility of the <c>TextWriter</c>, not the <c>Serializer</c>. This
313
        /// means that the encoding requested in the output properties is ignored; it also
314
        /// means that characters that cannot be represented in the target encoding will
315
        /// use whatever fallback representation the <c>TextWriter</c> defines, rather than
316
        /// being represented as XML character references.</remarks>
317
        /// <param name="textWriter">The stream to which the output will be written.
318
        /// This must be a stream that allows writing. Saxon will not close the
319
        /// <c>textWriter</c> on completion; this is the caller's responsibility.</param>
320

    
321
        public void SetOutputWriter(TextWriter textWriter)
322
        {
323
            writer = new DotNetWriter(textWriter);
324
            mustClose = false;
325
        }
326

    
327
        internal JReceiver GetReceiver(JConfiguration config)
328
        {
329
            return config.getSerializerFactory().getReceiver(
330
                    GetResult(),
331
                    config.makePipelineConfiguration(),
332
                    GetOutputProperties());
333

    
334
        }
335

    
336

    
337
        /// <summary inherit="yes"/>
338

    
339
        public override JResult GetResult()
340
        {
341
            if (outputStream != null)
342
            {
343
                return new JStreamResult(outputStream);
344
            }
345
            else if (writer != null)
346
            {
347
                return new JStreamResult(writer);
348
            }
349
            else
350
            {
351
                return new JStreamResult(new DotNetWriter(Console.Out));
352
            }
353
        }
354

    
355
        /// <summary inherit="yes"/>
356

    
357
        public override JProperties GetOutputProperties()
358
        {
359
            return props;
360
        }
361

    
362
        /// <summary inherit="yes"/>
363

    
364
        public override void Close()
365
        {
366
            if (mustClose)
367
            {
368
                if (outputStream != null)
369
                {
370
                    outputStream.close();
371
                }
372
                if (writer != null)
373
                {
374
                    writer.close();
375
                }
376
            }
377
        }
378
    }
379

    
380
    /// <summary>
381
    /// A <c>DomDestination</c> represents an XmlDocument that is constructed to hold the
382
    /// output of a query or transformation.
383
    /// </summary>
384
    /// <remarks>
385
    /// No data needs to be supplied to the <c>DomDestination</c> object. The query or transformation
386
    /// populates an <c>XmlDocument</c>, which may then be retrieved as the value of the <c>XmlDocument</c>
387
    /// property
388
    /// </remarks>
389

    
390
    public class DomDestination : XmlDestination
391
    {
392

    
393
        internal DotNetDomBuilder builder;
394

    
395
        /// <summary>Construct a <c>DomDestination</c></summary>
396
        /// <remarks>With this constructor, the system will create a new DOM Document
397
        /// to act as the destination of the query or transformation results. The document
398
        /// node of the new document may be retrieved via the XmlDocument property.</remarks>
399

    
400
        public DomDestination()
401
        {
402
            builder = new DotNetDomBuilder();
403
        }
404

    
405
        /// <summary>Construct a <c>DomDestination</c> based on an existing Document node.</summary>
406
        /// <remarks>The new data will be added as a child of the supplied node.</remarks>
407
        /// <param name="attachmentPoint">The document node to which new contents will
408
        /// be attached. To ensure that the new document is well-formed, this document node
409
        /// should have no existing children.</param>
410

    
411
        public DomDestination(XmlDocument attachmentPoint)
412
        {
413
            builder = new DotNetDomBuilder();
414
            builder.setAttachmentPoint(attachmentPoint);
415
        }
416

    
417
        /// <summary>Construct a <c>DomDestination</c> based on an existing DocumentFragment node.</summary>
418
        /// <remarks>The new data will be added as a child of the supplied node.</remarks>
419
        /// <param name="attachmentPoint">The document fragment node to which new contents will
420
        /// be attached. The new contents will be added after any existing children.</param>
421

    
422
        public DomDestination(XmlDocumentFragment attachmentPoint)
423
        {
424
            builder = new DotNetDomBuilder();
425
            builder.setAttachmentPoint(attachmentPoint);
426
        }
427

    
428
        /// <summary>Construct a <c>DomDestination</c> based on an existing Element node.</summary>
429
        /// <remarks>The new data will be added as a child of the supplied element node.</remarks>
430
        /// <param name="attachmentPoint">The element node to which new contents will
431
        /// be attached. The new contents will be added after any existing children.</param>
432

    
433
        public DomDestination(XmlElement attachmentPoint)
434
        {
435
            builder = new DotNetDomBuilder();
436
            builder.setAttachmentPoint(attachmentPoint);
437
        }
438

    
439
        /// <summary>After construction, retrieve the constructed document node</summary>
440
        /// <remarks>If the zero-argument constructor was used, this will be a newly
441
        /// constructed document node. If the constructor supplied a document node, the
442
        /// same document node will be returned. If the constructor supplied a document fragment
443
        /// node or an element node, this method returns the <c>OwnerDocument</c> property of 
444
        /// that node.</remarks>
445

    
446
        public XmlDocument XmlDocument
447
        {
448
            get { return builder.getDocumentNode(); }
449
        }
450

    
451
        /// <summary inherit="yes"/>
452

    
453
        public override JResult GetResult()
454
        {
455
            return builder;
456
        }
457
    }
458

    
459
    /// <summary>
460
    /// A <c>NullDestination</c> is an XmlDestination that discards all its output.
461
    /// </summary>
462

    
463
    public class NullDestination : XmlDestination
464
    {
465
        /// <summary>Construct a <c>NullDestination</c></summary>
466

    
467
        public NullDestination()
468
        {}
469

    
470
        /// <summary inherit="yes"/>
471

    
472
        public override JResult GetResult()
473
        {
474
            return new net.sf.saxon.@event.Sink();
475
        }
476
    }
477

    
478
    /// <summary>
479
    /// A <c>TextWriterDestination</c> is an implementation of <c>XmlDestination</c> that wraps
480
    /// an instance of <c>XmlWriter</c>.
481
    /// </summary>
482
    /// <remarks>
483
    /// <para>The name <c>TextWriterDestination</c> is a misnomer; originally this class would
484
    /// only wrap an <c>XmlTextWriter</c>. It will now wrap any <c>XmlWriter</c>.</para>
485
    /// <para>Note that when a <c>TextWriterDestination</c> is used to process the output of a stylesheet
486
    /// or query, the output format depends only on the way the underlying <c>XmlWriter</c>
487
    /// is configured; serialization parameters present in the stylesheet or query are ignored.
488
    /// The XSLT <c>disable-output-escaping</c> option is also ignored. If serialization
489
    /// is to be controlled from the stylesheet or query, use a <c>Serializer</c> as the
490
    /// <c>Destination</c>.</para>
491
    /// </remarks>
492

    
493
    public class TextWriterDestination : XmlDestination
494
    {
495

    
496
        internal XmlWriter writer;
497
        internal bool closeAfterUse = true;
498

    
499
        /// <summary>Construct a TextWriterDestination</summary>
500
        /// <param name="writer">The <c>XmlWriter</c> that is to be notified of the events
501
        /// representing the XML document.</param>
502

    
503
        public TextWriterDestination(XmlWriter writer)
504
        {
505
            this.writer = writer;
506
        }
507

    
508
        /// <summary>
509
        /// The <c>CloseAfterUse</c> property indicates whether the underlying <c>XmlWriter</c> is closed
510
        /// (by calling its <c>Close()</c> method) when Saxon has finished writing to it. The default
511
        /// value is true, in which case <c>Close()</c> is called. If the property is set to <c>false</c>,
512
        /// Saxon will refrain from calling the <c>Close()</c> method, and merely call <c>Flush()</c>,
513
        /// which can be useful if further output is to be written to the <c>XmlWriter</c> by the application.
514
        /// </summary>
515

    
516
        public bool CloseAfterUse {
517
            get { return closeAfterUse; }
518
            set { closeAfterUse = value; }
519
        }
520

    
521
        /// <summary inherit="yes"/>
522

    
523
        public override JResult GetResult()
524
        {
525
            DotNetReceiver dnr = new DotNetReceiver(writer);
526
            dnr.setCloseAfterUse(closeAfterUse);
527
            return dnr;
528
            //net.sf.saxon.@event.TracingFilter filter = new net.sf.saxon.@event.TracingFilter();
529
            //filter.setUnderlyingReceiver(dnr);
530
            //return filter;
531
        }
532

    
533
    }
534

    
535

    
536
    /// <summary>
537
    /// An <c>XdmDestination</c> is an <c>XmlDestination</c> in which an <c>XdmNode</c> 
538
    /// is constructed to hold the output of a query or transformation: 
539
    /// that is, a tree using Saxon's implementation of the XDM data model
540
    /// </summary>
541
    /// <remarks>
542
    /// <para>No data needs to be supplied to the <c>XdmDestination</c> object. The query or transformation
543
    /// populates an <c>XmlNode</c>, which may then be retrieved as the value of the <c>XmlNode</c>
544
    /// property.</para>
545
    /// <para>An <c>XdmDestination</c> can be reused to hold the results of a second transformation only
546
    /// if the <c>reset</c> method is first called to reset its state.</para>
547
    /// </remarks>
548

    
549
    public class XdmDestination : XmlDestination
550
    {
551
        internal TreeModel treeModel;
552
        internal Uri baseUri;
553
        internal JBuilder builder;
554

    
555
        /// <summary>Construct an <c>XdmDestination</c></summary>
556

    
557
        public XdmDestination()
558
        {
559
            //builder = new JTinyBuilder();
560
        }
561

    
562
        ///<summary>
563
        /// The Tree Model implementation to be used for the constructed document. By default
564
        /// the TinyTree is used. The main reason for using the LinkedTree alternative is if
565
        /// updating is required (the TinyTree is not updateable)
566
        ///</summary>
567

    
568
        public TreeModel TreeModel
569
        {
570
            get
571
            {
572
                return treeModel;
573
            }
574
            set
575
            {
576
                treeModel = value;
577
            }
578
        }
579

    
580
        /// <summary>This property determines the base URI of the constructed XdmNode. 
581
        /// If the baseURI property of the XdmDestination is set before the destination is written to,
582
        /// then the constructed XdmNode will have this base URI. Setting this property after constructing the node
583
        /// has no effect.
584
        /// </summary>
585

    
586
        public Uri BaseUri
587
        {
588
            get { return baseUri; }
589
            set { baseUri = value; }
590
        }
591

    
592

    
593
        /// <summary>Reset the state of the <c>XdmDestination</c> so that it can be used to hold
594
        /// the result of another query or transformation.</summary>
595

    
596
        public void Reset()
597
        {
598
            builder = null;
599
        }
600

    
601
        /// <summary>After construction, retrieve the constructed document node</summary>
602
        /// <remarks>
603
        /// <para>The value of the property will be null if no data has been written to the
604
        /// XdmDestination, either because the process that writes to the destination has not
605
        /// yet been run, or because the process produced no output.</para>
606
        /// </remarks>
607

    
608
        public XdmNode XdmNode
609
        {
610
            get
611
            {
612
                NodeInfo node = builder.getCurrentRoot();
613
                return (node == null ? null : (XdmNode)XdmValue.Wrap(builder.getCurrentRoot()));
614
            }
615
        }
616

    
617
        /// <summary inherit="yes"/>
618

    
619
        public override JResult GetResult()
620
        {
621
            builder = (treeModel == TreeModel.TinyTree ? (JBuilder)new JTinyBuilder() : (JBuilder)new JTreeBuilder());
622
            if (baseUri != null)
623
            {
624
                builder.setBaseURI(baseUri.ToString());
625
            }
626
            return builder;
627
        }
628
    }
629

    
630

    
631
}
632

    
633
//
634
// The contents of this file are subject to the Mozilla Public License Version 1.0 (the "License");
635
// you may not use this file except in compliance with the License. You may obtain a copy of the
636
// License at http://www.mozilla.org/MPL/
637
//
638
// Software distributed under the License is distributed on an "AS IS" basis,
639
// WITHOUT WARRANTY OF ANY KIND, either express or implied.
640
// See the License for the specific language governing rights and limitations under the License.
641
//
642
// The Original Code is: all this file.
643
//
644
// The Initial Developer of the Original Code is Michael H. Kay.
645
//
646
// Portions created by (your name) are Copyright (C) (your legal entity). All Rights Reserved.
647
//
648
// Contributor(s): none.
649
//
(2-2/10)