Printer


1   /*
2    * The Apache Software License, Version 1.1
3    *
4    *
5    * Copyright (c) 1999 The Apache Software Foundation.  All rights
6    * reserved.
7    *
8    * Redistribution and use in source and binary forms, with or without
9    * modification, are permitted provided that the following conditions
10   * are met:
11   *
12   * 1. Redistributions of source code must retain the above copyright
13   *    notice, this list of conditions and the following disclaimer.
14   *
15   * 2. Redistributions in binary form must reproduce the above copyright
16   *    notice, this list of conditions and the following disclaimer in
17   *    the documentation and/or other materials provided with the
18   *    distribution.
19   *
20   * 3. The end-user documentation included with the redistribution,
21   *    if any, must include the following acknowledgment:
22   *       "This product includes software developed by the
23   *        Apache Software Foundation (http://www.apache.org/)."
24   *    Alternately, this acknowledgment may appear in the software itself,
25   *    if and wherever such third-party acknowledgments normally appear.
26   *
27   * 4. The names "Xerces" and "Apache Software Foundation" must
28   *    not be used to endorse or promote products derived from this
29   *    software without prior written permission. For written
30   *    permission, please contact apache@apache.org.
31   *
32   * 5. Products derived from this software may not be called "Apache",
33   *    nor may "Apache" appear in their name, without prior written
34   *    permission of the Apache Software Foundation.
35   *
36   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
40   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
43   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
44   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47   * SUCH DAMAGE.
48   * ====================================================================
49   *
50   * This software consists of voluntary contributions made by many
51   * individuals on behalf of the Apache Software Foundation and was
52   * originally based on software copyright (c) 1999, International
53   * Business Machines, Inc., http://www.apache.org.  For more
54   * information on the Apache Software Foundation, please see
55   * <http://www.apache.org/>.
56   */
57  
58  
59  // Sep 14, 2000:
60  //  Fixed serializer to report IO exception directly, instead at
61  //  the end of document processing.
62  //  Reported by Patrick Higgins <phiggins@transzap.com>
63  
64  
65  package org.enhydra.apache.xml.serialize;
66  
67  
68  import java.io.IOException  ;
69  import java.io.StringWriter  ;
70  import java.io.Writer  ;
71  
72  
73  /**
74   * The printer is responsible for sending text to the output stream
75   * or writer. This class performs direct writing for efficiency.
76   * {@link IndentPrinter} supports indentation and line wrapping by
77   * extending this class.
78   *
79   * @version $Revision: 1.2 $ $Date: 2005/01/26 08:28:45 $
80   * @author <a HREF="mailto:arkin@intalio.com">Assaf Arkin</a>
81   */
82  public class Printer
83  {
84  
85  
86      /**
87       * The output format associated with this serializer. This will never
88       * be a null reference. If no format was passed to the constructor,
89       * the default one for this document type will be used. The format
90       * object is never changed by the serializer.
91       */
92      protected final OutputFormat _format;
93  
94  
95      /**
96       * The writer to which the document is written.
97       */
98      protected Writer               _writer;
99  
100 
101     /**
102      * The DTD writer. When we switch to DTD mode, all output is
103      * accumulated in this DTD writer. When we switch out of it,
104      * the output is obtained as a string. Must not be reset to
105      * null until we're done with the document.
106      */
107     protected StringWriter         _dtdWriter;
108 
109 
110     /**
111      * Holds a reference to the document writer while we are
112      * in DTD mode.
113      */
114     protected Writer            _docWriter;
115 
116 
117     /**
118      * Holds the exception thrown by the serializer.  Exceptions do not cause
119      * the serializer to quit, but are held and one is thrown at the end.
120      */
121     protected IOException       _exception;
122 
123 
124     /**
125      * The size of the output buffer.
126      */
127     private static final int BufferSize = 4096;
128 
129 
130     /**
131      * Output buffer.
132      */
133     private final char[]  _buffer = new char[ BufferSize ];
134 
135 
136     /**
137      * Position within the output buffer.
138      */
139     private int           _pos = 0;
140 
141 
142     public Printer( Writer   writer, OutputFormat format)
143     {
144         _writer = writer;
145         _format = format;
146         _exception = null;
147         _dtdWriter = null;
148         _docWriter = null;
149         _pos = 0;
150     }
151 
152 
153     public IOException   getException()
154     {
155         return _exception;
156     }
157 
158 
159     /**
160      * Called by any of the DTD handlers to enter DTD mode.
161      * Once entered, all output will be accumulated in a string
162      * that can be printed as part of the document's DTD.
163      * This method may be called any number of time but will only
164      * have affect the first time it's called. To exist DTD state
165      * and get the accumulated DTD, call {@link #leaveDTD}.
166      */
167     public void enterDTD()
168         throws IOException  
169     {
170         // Can only enter DTD state once. Once we're out of DTD
171         // state, can no longer re-enter it.
172         if ( _dtdWriter == null ) {
173         flushLine( false );
174 
175             _dtdWriter = new StringWriter  ();
176             _docWriter = _writer;
177             _writer = _dtdWriter;
178         }
179     }
180 
181 
182     /**
183      * Called by the root element to leave DTD mode and if any
184      * DTD parts were printer, will return a string with their
185      * textual content.
186      */
187     public String   leaveDTD()
188         throws IOException  
189     {
190         // Only works if we're going out of DTD mode.
191         if ( _writer == _dtdWriter ) {
192         flushLine( false );
193 
194             _writer = _docWriter;
195             return _dtdWriter.toString();
196         } else
197             return null;
198     }
199 
200 
201     public void printText( String   text )
202         throws IOException  
203     {
204         try {
205             int length = text.length();
206             for ( int i = 0 ; i < length ; ++i ) {
207                 if ( _pos == BufferSize ) {
208                     _writer.write( _buffer );
209                     _pos = 0;
210                 }
211                 _buffer[ _pos ] = text.charAt( i );
212                 ++_pos;
213             }
214         } catch ( IOException   except ) {
215             // We don't throw an exception, but hold it
216             // until the end of the document.
217             if ( _exception == null )
218                 _exception = except;
219             throw except;
220         }
221     }
222 
223 
224     public void printText( StringBuffer   text )
225         throws IOException  
226     {
227         try {
228             int length = text.length();
229             for ( int i = 0 ; i < length ; ++i ) {
230                 if ( _pos == BufferSize ) {
231                     _writer.write( _buffer );
232                     _pos = 0;
233                 }
234                 _buffer[ _pos ] = text.charAt( i );
235                 ++_pos;
236             }
237         } catch ( IOException   except ) {
238             // We don't throw an exception, but hold it
239             // until the end of the document.
240             if ( _exception == null )
241                 _exception = except;
242             throw except;
243         }
244     }
245 
246 
247     public void printText( char[] chars, int start, int length )
248         throws IOException  
249     {
250         try {
251             while ( length-- > 0 ) {
252                 if ( _pos == BufferSize ) {
253                     _writer.write( _buffer );
254                     _pos = 0;
255                 }
256                 _buffer[ _pos ] = chars[ start ];
257                 ++start;
258                 ++_pos;
259             }
260         } catch ( IOException   except ) {
261             // We don't throw an exception, but hold it
262             // until the end of the document.
263             if ( _exception == null )
264                 _exception = except;
265             throw except;
266         }
267     }
268 
269 
270     public void printText( char ch )
271         throws IOException  
272     {
273         try {
274             if ( _pos == BufferSize ) {
275                 _writer.write( _buffer );
276                 _pos = 0;
277             }
278             _buffer[ _pos ] = ch;
279             ++_pos;
280         } catch ( IOException   except ) {
281             // We don't throw an exception, but hold it
282             // until the end of the document.
283             if ( _exception == null )
284                 _exception = except;
285             throw except;
286         }
287     }
288 
289 
290     public void printSpace()
291         throws IOException  
292     {
293         try {
294             if ( _pos == BufferSize ) {
295                 _writer.write( _buffer );
296                 _pos = 0;
297             }
298             _buffer[ _pos ] = ' ';
299             ++_pos;
300         } catch ( IOException   except ) {
301             // We don't throw an exception, but hold it
302             // until the end of the document.
303             if ( _exception == null )
304                 _exception = except;
305             throw except;
306         }
307     }
308 
309 
310     public void breakLine()
311         throws IOException  
312     {
313         try {
314             if ( _pos == BufferSize ) {
315                 _writer.write( _buffer );
316                 _pos = 0;
317             }
318             _buffer[ _pos ] = '\n';
319             ++_pos;
320         } catch ( IOException   except ) {
321             // We don't throw an exception, but hold it
322             // until the end of the document.
323             if ( _exception == null )
324                 _exception = except;
325             throw except;
326         }
327     }
328 
329 
330     public void breakLine( boolean preserveSpace )
331         throws IOException  
332     {
333         breakLine();
334     }
335 
336 
337     public void flushLine( boolean preserveSpace )
338         throws IOException  
339     {
340         // Write anything left in the buffer into the writer.
341         try {
342             _writer.write( _buffer, 0, _pos );
343         } catch ( IOException   except ) {
344             // We don't throw an exception, but hold it
345             // until the end of the document.
346             if ( _exception == null )
347                 _exception = except;
348         }
349         _pos = 0;
350     }
351 
352 
353     /**
354      * Flush the output stream. Must be called when done printing
355      * the document, otherwise some text might be buffered.
356      */
357     public void flush()
358         throws IOException  
359     {
360         try {
361             _writer.write( _buffer, 0, _pos );
362             _writer.flush();
363         } catch ( IOException   except ) {
364             // We don't throw an exception, but hold it
365             // until the end of the document.
366             if ( _exception == null )
367                 _exception = except;
368             throw except;
369         }
370         _pos = 0;
371     }
372 
373 
374     public void indent()
375     {
376         // NOOP
377     }
378 
379 
380     public void unindent()
381     {
382         // NOOP
383     }
384 
385 
386     public int getNextIndent()
387     {
388         return 0;
389     }
390 
391 
392     public void setNextIndent( int indent )
393     {
394     }
395 
396 
397     public void setThisIndent( int indent )
398     {
399     }
400 
401 
402 }
403
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags