Source code: org/apache/batik/ext/awt/image/codec/SeekableStream.java
1 /*
2
3 Copyright 2001,2003 The Apache Software Foundation
4
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
8
9 http://www.apache.org/licenses/LICENSE-2.0
10
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
16
17 */
18 package org.apache.batik.ext.awt.image.codec;
19
20 import java.io.DataInput;
21 import java.io.DataInputStream;
22 import java.io.EOFException;
23 import java.io.IOException;
24 import java.io.InputStream;
25
26 /**
27 * An abstract subclass of <code>java.io.InputStream</code> that allows seeking
28 * within the input, similar to the <code>RandomAccessFile</code> class.
29 * Additionally, the <code>DataInput</code> interface is supported and extended
30 * to include support for little-endian representations of fundamental data
31 * types.
32 *
33 * <p> In addition to the familiar methods from <code>InputStream</code>, the
34 * methods <code>getFilePointer()</code>, <code>seek()</code>, are defined as in
35 * the <code>RandomAccessFile</code> class. The <code>canSeekBackwards()</code>
36 * method will return <code>true</code> if it is permissible to seek to a
37 * position earlier in the stream than the current value of
38 * <code>getFilePointer()</code>. Some subclasses of
39 * <code>SeekableStream</code> guarantee the ability to seek backwards while
40 * others may not offer this feature in the interest of providing greater
41 * efficiency for those users who do not require it.
42 *
43 * <p> The <code>DataInput</code> interface is supported as well. This included
44 * the <code>skipBytes()</code> and <code>readFully()</code> methods and a
45 * variety of <code>read</code> methods for various data types.
46 *
47 * <p> A number of concrete subclasses of <code>SeekableStream</code> are
48 * supplied in the <code>com.sun.media.jai.codec</code> package.
49 *
50 * <p> Three classes are provided for the purpose of adapting a standard
51 * <code>InputStream</code> to the <code>SeekableStream</code> interface.
52 * <code>ForwardSeekableStream</code> does not allows seeking backwards, but is
53 * inexpensive to use. <code>FileCacheSeekableStream</code> maintains a copy of
54 * all of the data read from the input in a temporary file; this file will be
55 * discarded automatically when the <code>FileSeekableStream</code> is
56 * finalized, or when the JVM exits normally.
57 * <code>FileCacheSeekableStream</code> is intended to be reasonably efficient
58 * apart from the unavoidable use of disk space. In circumstances where the
59 * creation of a temporary file is not possible,
60 * <code>MemoryCacheSeekableStream</code> may be used.
61 * <code>MemoryCacheSeekableStream</code> creates a potentially large in-memory
62 * buffer to store the stream data and so should be avoided when possible.
63 *
64 * <p> The <code>FileSeekableStream</code> class wraps a <code>File</code> or
65 * <code>RandomAccessFile</code>. It forwards requests to the real underlying
66 * file. It performs a limited amount of caching in order to avoid excessive
67 * I/O costs.
68 *
69 * <p> The <code>SegmentedSeekableStream</code> class performs a different sort
70 * of function. It creates a <code>SeekableStream</code> from another
71 * <code>SeekableStream</code> by selecting a series of portions or "segments".
72 * Each segment starts at a specified location within the source
73 * <code>SeekableStream</code> and extends for a specified number of bytes. The
74 * <code>StreamSegmentMapper</code> interface and <code>StreamSegment</code>
75 * class may be used to compute the segment positions dynamically.
76 *
77 * <p> A convenience methods, <code>wrapInputStream</code> is provided to
78 * construct a suitable <code>SeekableStream</code> instance whose data is
79 * supplied by a given <code>InputStream</code>. The caller, by means of the
80 * <code>canSeekBackwards</code> parameter, determines whether support for
81 * seeking backwards is required.
82 *
83 */
84 public abstract class SeekableStream extends InputStream implements DataInput {
85
86 /**
87 * Returns a <code>SeekableStream</code> that will read from a
88 * given <code>InputStream</code>, optionally including support
89 * for seeking backwards. This is a convenience method that
90 * avoids the need to instantiate specific subclasses of
91 * <code>SeekableStream</code> depending on the current security
92 * model.
93 *
94 * @param is An <code>InputStream</code>.
95 * @param canSeekBackwards <code>true</code> if the ability to seek
96 * backwards in the output is required.
97 * @return An instance of <code>SeekableStream</code>.
98 */
99 public static SeekableStream wrapInputStream(InputStream is,
100 boolean canSeekBackwards) {
101 SeekableStream stream = null;
102
103 if (canSeekBackwards) {
104 try {
105 stream = new FileCacheSeekableStream(is);
106 } catch (Exception e) {
107 stream = new MemoryCacheSeekableStream(is);
108 }
109 } else {
110 stream = new ForwardSeekableStream(is);
111 }
112 return stream;
113 }
114
115 // Methods from InputStream
116
117 /**
118 * Reads the next byte of data from the input stream. The value byte is
119 * returned as an <code>int</code> in the range <code>0</code> to
120 * <code>255</code>. If no byte is available because the end of the stream
121 * has been reached, the value <code>-1</code> is returned. This method
122 * blocks until input data is available, the end of the stream is detected,
123 * or an exception is thrown.
124 *
125 * <p> A subclass must provide an implementation of this method.
126 *
127 * @return the next byte of data, or <code>-1</code> if the end of the
128 * stream is reached.
129 * @exception IOException if an I/O error occurs.
130 */
131 public abstract int read() throws IOException;
132
133 /**
134 * Reads up to <code>len</code> bytes of data from the input stream into
135 * an array of bytes. An attempt is made to read as many as
136 * <code>len</code> bytes, but a smaller number may be read, possibly
137 * zero. The number of bytes actually read is returned as an integer.
138 *
139 * <p> This method blocks until input data is available, end of stream is
140 * detected, or an exception is thrown.
141 *
142 * <p> If <code>b</code> is <code>null</code>, a
143 * <code>NullPointerException</code> is thrown.
144 *
145 * <p> If <code>off</code> is negative, or <code>len</code> is negative, or
146 * <code>off+len</code> is greater than the length of the array
147 * <code>b</code>, then an <code>IndexOutOfBoundsException</code> is
148 * thrown.
149 *
150 * <p> If <code>len</code> is zero, then no bytes are read and
151 * <code>0</code> is returned; otherwise, there is an attempt to read at
152 * least one byte. If no byte is available because the stream is at end of
153 * stream, the value <code>-1</code> is returned; otherwise, at least one
154 * byte is read and stored into <code>b</code>.
155 *
156 * <p> The first byte read is stored into element <code>b[off]</code>, the
157 * next one into <code>b[off+1]</code>, and so on. The number of bytes read
158 * is, at most, equal to <code>len</code>. Let <i>k</i> be the number of
159 * bytes actually read; these bytes will be stored in elements
160 * <code>b[off]</code> through <code>b[off+</code><i>k</i><code>-1]</code>,
161 * leaving elements <code>b[off+</code><i>k</i><code>]</code> through
162 * <code>b[off+len-1]</code> unaffected.
163 *
164 * <p> In every case, elements <code>b[0]</code> through
165 * <code>b[off]</code> and elements <code>b[off+len]</code> through
166 * <code>b[b.length-1]</code> are unaffected.
167 *
168 * <p> If the first byte cannot be read for any reason other than end of
169 * stream, then an <code>IOException</code> is thrown. In particular, an
170 * <code>IOException</code> is thrown if the input stream has been closed.
171 *
172 * <p> A subclass must provide an implementation of this method.
173 *
174 * @param b the buffer into which the data is read.
175 * @param off the start offset in array <code>b</code>
176 * at which the data is written.
177 * @param len the maximum number of bytes to read.
178 * @return the total number of bytes read into the buffer, or
179 * <code>-1</code> if there is no more data because the end of
180 * the stream has been reached.
181 * @exception IOException if an I/O error occurs.
182 */
183 public abstract int read(byte[] b, int off, int len) throws IOException;
184
185 // Implemented in InputStream:
186 //
187 // public int read(byte[] b) throws IOException {
188 // public long skip(long n) throws IOException
189 // public int available) throws IOException
190 // public void close() throws IOException;
191
192 /** Marked position */
193 protected long markPos = -1L;
194
195 /**
196 * Marks the current file position for later return using
197 * the <code>reset()</code> method.
198 */
199 public synchronized void mark(int readLimit) {
200 try {
201 markPos = getFilePointer();
202 } catch (IOException e) {
203 markPos = -1L;
204 }
205 }
206
207 /**
208 * Returns the file position to its position at the time of
209 * the immediately previous call to the <code>mark()</code>
210 * method.
211 */
212 public synchronized void reset() throws IOException {
213 if (markPos != -1) {
214 seek(markPos);
215 }
216 }
217
218 /**
219 * Returns <code>true</code> if marking is supported.
220 * Marking is automatically supported for <code>SeekableStream</code>
221 * subclasses that support seeking backeards. Subclasses that do
222 * not support seeking backwards but do support marking must override
223 * this method.
224 */
225 public boolean markSupported() {
226 return canSeekBackwards();
227 }
228
229 /**
230 * Returns <code>true</code> if this object supports calls to
231 * <code>seek(pos)</code> with an offset <code>pos</code> smaller
232 * than the current offset, as returned by <code>getFilePointer</code>.
233 */
234 public boolean canSeekBackwards() {
235 return false;
236 }
237
238 /**
239 * Returns the current offset in this stream.
240 *
241 * @return the offset from the beginning of the stream, in bytes,
242 * at which the next read occurs.
243 * @exception IOException if an I/O error occurs.
244 */
245 public abstract long getFilePointer() throws IOException;
246
247 /**
248 * Sets the offset, measured from the beginning of this
249 * stream, at which the next read occurs.
250 *
251 * <p> If <code>canSeekBackwards()</code> returns <code>false</code>,
252 * then setting <code>pos</code> to an offset smaller than
253 * the current value of <code>getFilePointer()</code> will have
254 * no effect.
255 *
256 * @param pos the offset position, measured in bytes from the
257 * beginning of the stream, at which to set the stream
258 * pointer.
259 * @exception IOException if <code>pos</code> is less than
260 * <code>0</code> or if an I/O error occurs.
261 */
262 public abstract void seek(long pos) throws IOException;
263
264 // Methods from RandomAccessFile
265
266 /**
267 * Reads <code>b.length</code> bytes from this stream into the byte
268 * array, starting at the current stream pointer. This method reads
269 * repeatedly from the stream until the requested number of bytes are
270 * read. This method blocks until the requested number of bytes are
271 * read, the end of the stream is detected, or an exception is thrown.
272 *
273 * @param b the buffer into which the data is read.
274 * @exception EOFException if this stream reaches the end before reading
275 * all the bytes.
276 * @exception IOException if an I/O error occurs.
277 */
278 public final void readFully(byte[] b) throws IOException {
279 readFully(b, 0, b.length);
280 }
281
282 /**
283 * Reads exactly <code>len</code> bytes from this stream into the byte
284 * array, starting at the current stream pointer. This method reads
285 * repeatedly from the stream until the requested number of bytes are
286 * read. This method blocks until the requested number of bytes are
287 * read, the end of the stream is detected, or an exception is thrown.
288 *
289 * @param b the buffer into which the data is read.
290 * @param off the start offset of the data.
291 * @param len the number of bytes to read.
292 * @exception EOFException if this stream reaches the end before reading
293 * all the bytes.
294 * @exception IOException if an I/O error occurs.
295 */
296 public final void readFully(byte[] b, int off, int len)
297 throws IOException {
298 int n = 0;
299 do {
300 int count = this.read(b, off + n, len - n);
301 if (count < 0)
302 throw new EOFException();
303 n += count;
304 } while (n < len);
305 }
306
307 // Methods from DataInput, plus little-endian versions
308
309 /**
310 * Attempts to skip over <code>n</code> bytes of input discarding the
311 * skipped bytes.
312 * <p>
313 *
314 * This method may skip over some smaller number of bytes, possibly zero.
315 * This may result from any of a number of conditions; reaching end of
316 * stream before <code>n</code> bytes have been skipped is only one
317 * possibility. This method never throws an <code>EOFException</code>.
318 * The actual number of bytes skipped is returned. If <code>n</code>
319 * is negative, no bytes are skipped.
320 *
321 * @param n the number of bytes to be skipped.
322 * @return the actual number of bytes skipped.
323 * @exception IOException if an I/O error occurs.
324 */
325 public int skipBytes(int n) throws IOException {
326 if (n <= 0) {
327 return 0;
328 }
329 return (int)skip(n);
330 }
331
332 /**
333 * Reads a <code>boolean</code> from this stream. This method reads a
334 * single byte from the stream, starting at the current stream pointer.
335 * A value of <code>0</code> represents
336 * <code>false</code>. Any other value represents <code>true</code>.
337 * This method blocks until the byte is read, the end of the stream
338 * is detected, or an exception is thrown.
339 *
340 * @return the <code>boolean</code> value read.
341 * @exception EOFException if this stream has reached the end.
342 * @exception IOException if an I/O error occurs.
343 */
344 public final boolean readBoolean() throws IOException {
345 int ch = this.read();
346 if (ch < 0)
347 throw new EOFException();
348 return (ch != 0);
349 }
350
351 /**
352 * Reads a signed eight-bit value from this stream. This method reads a
353 * byte from the stream, starting from the current stream pointer.
354 * If the byte read is <code>b</code>, where
355 * <code>0 <= b <= 255</code>,
356 * then the result is:
357 * <blockquote><pre>
358 * (byte)(b)
359 * </pre></blockquote>
360 * <p>
361 * This method blocks until the byte is read, the end of the stream
362 * is detected, or an exception is thrown.
363 *
364 * @return the next byte of this stream as a signed eight-bit
365 * <code>byte</code>.
366 * @exception EOFException if this stream has reached the end.
367 * @exception IOException if an I/O error occurs.
368 */
369 public final byte readByte() throws IOException {
370 int ch = this.read();
371 if (ch < 0)
372 throw new EOFException();
373 return (byte)(ch);
374 }
375
376 /**
377 * Reads an unsigned eight-bit number from this stream. This method reads
378 * a byte from this stream, starting at the current stream pointer,
379 * and returns that byte.
380 * <p>
381 * This method blocks until the byte is read, the end of the stream
382 * is detected, or an exception is thrown.
383 *
384 * @return the next byte of this stream, interpreted as an unsigned
385 * eight-bit number.
386 * @exception EOFException if this stream has reached the end.
387 * @exception IOException if an I/O error occurs.
388 */
389 public final int readUnsignedByte() throws IOException {
390 int ch = this.read();
391 if (ch < 0)
392 throw new EOFException();
393 return ch;
394 }
395
396 /**
397 * Reads a signed 16-bit number from this stream.
398 * The method reads two
399 * bytes from this stream, starting at the current stream pointer.
400 * If the two bytes read, in order, are
401 * <code>b1</code> and <code>b2</code>, where each of the two values is
402 * between <code>0</code> and <code>255</code>, inclusive, then the
403 * result is equal to:
404 * <blockquote><pre>
405 * (short)((b1 << 8) | b2)
406 * </pre></blockquote>
407 * <p>
408 * This method blocks until the two bytes are read, the end of the
409 * stream is detected, or an exception is thrown.
410 *
411 * @return the next two bytes of this stream, interpreted as a signed
412 * 16-bit number.
413 * @exception EOFException if this stream reaches the end before reading
414 * two bytes.
415 * @exception IOException if an I/O error occurs.
416 */
417 public final short readShort() throws IOException {
418 int ch1 = this.read();
419 int ch2 = this.read();
420 if ((ch1 | ch2) < 0)
421 throw new EOFException();
422 return (short)((ch1 << 8) + (ch2 << 0));
423 }
424
425 /**
426 * Reads a signed 16-bit number from this stream in little-endian order.
427 * The method reads two
428 * bytes from this stream, starting at the current stream pointer.
429 * If the two bytes read, in order, are
430 * <code>b1</code> and <code>b2</code>, where each of the two values is
431 * between <code>0</code> and <code>255</code>, inclusive, then the
432 * result is equal to:
433 * <blockquote><pre>
434 * (short)((b2 << 8) | b1)
435 * </pre></blockquote>
436 * <p>
437 * This method blocks until the two bytes are read, the end of the
438 * stream is detected, or an exception is thrown.
439 *
440 * @return the next two bytes of this stream, interpreted as a signed
441 * 16-bit number.
442 * @exception EOFException if this stream reaches the end before reading
443 * two bytes.
444 * @exception IOException if an I/O error occurs.
445 */
446 public final short readShortLE() throws IOException {
447 int ch1 = this.read();
448 int ch2 = this.read();
449 if ((ch1 | ch2) < 0)
450 throw new EOFException();
451 return (short)((ch2 << 8) + (ch1 << 0));
452 }
453
454 /**
455 * Reads an unsigned 16-bit number from this stream. This method reads
456 * two bytes from the stream, starting at the current stream pointer.
457 * If the bytes read, in order, are
458 * <code>b1</code> and <code>b2</code>, where
459 * <code>0 <= b1, b2 <= 255</code>,
460 * then the result is equal to:
461 * <blockquote><pre>
462 * (b1 << 8) | b2
463 * </pre></blockquote>
464 * <p>
465 * This method blocks until the two bytes are read, the end of the
466 * stream is detected, or an exception is thrown.
467 *
468 * @return the next two bytes of this stream, interpreted as an
469 * unsigned 16-bit integer.
470 * @exception EOFException if this stream reaches the end before reading
471 * two bytes.
472 * @exception IOException if an I/O error occurs.
473 */
474 public final int readUnsignedShort() throws IOException {
475 int ch1 = this.read();
476 int ch2 = this.read();
477 if ((ch1 | ch2) < 0)
478 throw new EOFException();
479 return (ch1 << 8) + (ch2 << 0);
480 }
481
482 /**
483 * Reads an unsigned 16-bit number from this stream in little-endian order.
484 * This method reads
485 * two bytes from the stream, starting at the current stream pointer.
486 * If the bytes read, in order, are
487 * <code>b1</code> and <code>b2</code>, where
488 * <code>0 <= b1, b2 <= 255</code>,
489 * then the result is equal to:
490 * <blockquote><pre>
491 * (b2 << 8) | b1
492 * </pre></blockquote>
493 * <p>
494 * This method blocks until the two bytes are read, the end of the
495 * stream is detected, or an exception is thrown.
496 *
497 * @return the next two bytes of this stream, interpreted as an
498 * unsigned 16-bit integer.
499 * @exception EOFException if this stream reaches the end before reading
500 * two bytes.
501 * @exception IOException if an I/O error occurs.
502 */
503 public final int readUnsignedShortLE() throws IOException {
504 int ch1 = this.read();
505 int ch2 = this.read();
506 if ((ch1 | ch2) < 0)
507 throw new EOFException();
508 return (ch2 << 8) + (ch1 << 0);
509 }
510
511 /**
512 * Reads a Unicode character from this stream. This method reads two
513 * bytes from the stream, starting at the current stream pointer.
514 * If the bytes read, in order, are
515 * <code>b1</code> and <code>b2</code>, where
516 * <code>0 <= b1, b2 <= 255</code>,
517 * then the result is equal to:
518 * <blockquote><pre>
519 * (char)((b1 << 8) | b2)
520 * </pre></blockquote>
521 * <p>
522 * This method blocks until the two bytes are read, the end of the
523 * stream is detected, or an exception is thrown.
524 *
525 * @return the next two bytes of this stream as a Unicode character.
526 * @exception EOFException if this stream reaches the end before reading
527 * two bytes.
528 * @exception IOException if an I/O error occurs.
529 */
530 public final char readChar() throws IOException {
531 int ch1 = this.read();
532 int ch2 = this.read();
533 if ((ch1 | ch2) < 0)
534 throw new EOFException();
535 return (char)((ch1 << 8) + (ch2 << 0));
536 }
537
538 /**
539 * Reads a Unicode character from this stream in little-endian order.
540 * This method reads two
541 * bytes from the stream, starting at the current stream pointer.
542 * If the bytes read, in order, are
543 * <code>b1</code> and <code>b2</code>, where
544 * <code>0 <= b1, b2 <= 255</code>,
545 * then the result is equal to:
546 * <blockquote><pre>
547 * (char)((b2 << 8) | b1)
548 * </pre></blockquote>
549 * <p>
550 * This method blocks until the two bytes are read, the end of the
551 * stream is detected, or an exception is thrown.
552 *
553 * @return the next two bytes of this stream as a Unicode character.
554 * @exception EOFException if this stream reaches the end before reading
555 * two bytes.
556 * @exception IOException if an I/O error occurs.
557 */
558 public final char readCharLE() throws IOException {
559 int ch1 = this.read();
560 int ch2 = this.read();
561 if ((ch1 | ch2) < 0)
562 throw new EOFException();
563 return (char)((ch2 << 8) + (ch1 << 0));
564 }
565
566 /**
567 * Reads a signed 32-bit integer from this stream. This method reads 4
568 * bytes from the stream, starting at the current stream pointer.
569 * If the bytes read, in order, are <code>b1</code>,
570 * <code>b2</code>, <code>b3</code>, and <code>b4</code>, where
571 * <code>0 <= b1, b2, b3, b4 <= 255</code>,
572 * then the result is equal to:
573 * <blockquote><pre>
574 * (b1 << 24) | (b2 << 16) + (b3 << 8) + b4
575 * </pre></blockquote>
576 * <p>
577 * This method blocks until the four bytes are read, the end of the
578 * stream is detected, or an exception is thrown.
579 *
580 * @return the next four bytes of this stream, interpreted as an
581 * <code>int</code>.
582 * @exception EOFException if this stream reaches the end before reading
583 * four bytes.
584 * @exception IOException if an I/O error occurs.
585 */
586 public final int readInt() throws IOException {
587 int ch1 = this.read();
588 int ch2 = this.read();
589 int ch3 = this.read();
590 int ch4 = this.read();
591 if ((ch1 | ch2 | ch3 | ch4) < 0)
592 throw new EOFException();
593 return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
594 }
595
596 /**
597 * Reads a signed 32-bit integer from this stream in little-endian order.
598 * This method reads 4
599 * bytes from the stream, starting at the current stream pointer.
600 * If the bytes read, in order, are <code>b1</code>,
601 * <code>b2</code>, <code>b3</code>, and <code>b4</code>, where
602 * <code>0 <= b1, b2, b3, b4 <= 255</code>,
603 * then the result is equal to:
604 * <blockquote><pre>
605 * (b4 << 24) | (b3 << 16) + (b2 << 8) + b1
606 * </pre></blockquote>
607 * <p>
608 * This method blocks until the four bytes are read, the end of the
609 * stream is detected, or an exception is thrown.
610 *
611 * @return the next four bytes of this stream, interpreted as an
612 * <code>int</code>.
613 * @exception EOFException if this stream reaches the end before reading
614 * four bytes.
615 * @exception IOException if an I/O error occurs.
616 */
617 public final int readIntLE() throws IOException {
618 int ch1 = this.read();
619 int ch2 = this.read();
620 int ch3 = this.read();
621 int ch4 = this.read();
622 if ((ch1 | ch2 | ch3 | ch4) < 0)
623 throw new EOFException();
624 return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0));
625 }
626
627 /**
628 * Reads an unsigned 32-bit integer from this stream. This method reads 4
629 * bytes from the stream, starting at the current stream pointer.
630 * If the bytes read, in order, are <code>b1</code>,
631 * <code>b2</code>, <code>b3</code>, and <code>b4</code>, where
632 * <code>0 <= b1, b2, b3, b4 <= 255</code>,
633 * then the result is equal to:
634 * <blockquote><pre>
635 * (b1 << 24) | (b2 << 16) + (b3 << 8) + b4
636 * </pre></blockquote>
637 * <p>
638 * This method blocks until the four bytes are read, the end of the
639 * stream is detected, or an exception is thrown.
640 *
641 * @return the next four bytes of this stream, interpreted as a
642 * <code>long</code>.
643 * @exception EOFException if this stream reaches the end before reading
644 * four bytes.
645 * @exception IOException if an I/O error occurs.
646 */
647 public final long readUnsignedInt() throws IOException {
648 long ch1 = this.read();
649 long ch2 = this.read();
650 long ch3 = this.read();
651 long ch4 = this.read();
652 if ((ch1 | ch2 | ch3 | ch4) < 0)
653 throw new EOFException();
654 return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
655 }
656
657 private byte[] ruileBuf = new byte[4];
658
659 /**
660 * Reads an unsigned 32-bit integer from this stream in little-endian
661 * order. This method reads 4
662 * bytes from the stream, starting at the current stream pointer.
663 * If the bytes read, in order, are <code>b1</code>,
664 * <code>b2</code>, <code>b3</code>, and <code>b4</code>, where
665 * <code>0 <= b1, b2, b3, b4 <= 255</code>,
666 * then the result is equal to:
667 * <blockquote><pre>
668 * (b4 << 24) | (b3 << 16) + (b2 << 8) + b1
669 * </pre></blockquote>
670 * <p>
671 * This method blocks until the four bytes are read, the end of the
672 * stream is detected, or an exception is thrown.
673 *
674 * @return the next four bytes of this stream, interpreted as a
675 * <code>long</code>.
676 * @exception EOFException if this stream reaches the end before reading
677 * four bytes.
678 * @exception IOException if an I/O error occurs.
679 */
680 public final long readUnsignedIntLE() throws IOException {
681 this.readFully(ruileBuf);
682 long ch1 = (ruileBuf[0] & 0xff);
683 long ch2 = (ruileBuf[1] & 0xff);
684 long ch3 = (ruileBuf[2] & 0xff);
685 long ch4 = (ruileBuf[3] & 0xff);
686
687 return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0));
688 }
689
690 /**
691 * Reads a signed 64-bit integer from this stream. This method reads eight
692 * bytes from the stream, starting at the current stream pointer.
693 * If the bytes read, in order, are
694 * <code>b1</code>, <code>b2</code>, <code>b3</code>,
695 * <code>b4</code>, <code>b5</code>, <code>b6</code>,
696 * <code>b7</code>, and <code>b8,</code> where:
697 * <blockquote><pre>
698 * 0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255,
699 * </pre></blockquote>
700 * <p>
701 * then the result is equal to:
702 * <p><blockquote><pre>
703 * ((long)b1 << 56) + ((long)b2 << 48)
704 * + ((long)b3 << 40) + ((long)b4 << 32)
705 * + ((long)b5 << 24) + ((long)b6 << 16)
706 * + ((long)b7 << 8) + b8
707 * </pre></blockquote>
708 * <p>
709 * This method blocks until the eight bytes are read, the end of the
710 * stream is detected, or an exception is thrown.
711 *
712 * @return the next eight bytes of this stream, interpreted as a
713 * <code>long</code>.
714 * @exception EOFException if this stream reaches the end before reading
715 * eight bytes.
716 * @exception IOException if an I/O error occurs.
717 */
718 public final long readLong() throws IOException {
719 return ((long)(readInt()) << 32) + (readInt() & 0xFFFFFFFFL);
720 }
721
722 /**
723 * Reads a signed 64-bit integer from this stream in little-endian
724 * order. This method reads eight
725 * bytes from the stream, starting at the current stream pointer.
726 * If the bytes read, in order, are
727 * <code>b1</code>, <code>b2</code>, <code>b3</code>,
728 * <code>b4</code>, <code>b5</code>, <code>b6</code>,
729 * <code>b7</code>, and <code>b8,</code> where:
730 * <blockquote><pre>
731 * 0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255,
732 * </pre></blockquote>
733 * <p>
734 * then the result is equal to:
735 * <p><blockquote><pre>
736 * ((long)b1 << 56) + ((long)b2 << 48)
737 * + ((long)b3 << 40) + ((long)b4 << 32)
738 * + ((long)b5 << 24) + ((long)b6 << 16)
739 * + ((long)b7 << 8) + b8
740 * </pre></blockquote>
741 * <p>
742 * This method blocks until the eight bytes are read, the end of the
743 * stream is detected, or an exception is thrown.
744 *
745 * @return the next eight bytes of this stream, interpreted as a
746 * <code>long</code>.
747 * @exception EOFException if this stream reaches the end before reading
748 * eight bytes.
749 * @exception IOException if an I/O error occurs.
750 */
751 public final long readLongLE() throws IOException {
752 int i1 = readIntLE();
753 int i2 = readIntLE();
754 return ((long)i2 << 32) + (i1 & 0xFFFFFFFFL);
755 }
756
757 /**
758 * Reads a <code>float</code> from this stream. This method reads an
759 * <code>int</code> value, starting at the current stream pointer,
760 * as if by the <code>readInt</code> method
761 * and then converts that <code>int</code> to a <code>float</code>
762 * using the <code>intBitsToFloat</code> method in class
763 * <code>Float</code>.
764 * <p>
765 * This method blocks until the four bytes are read, the end of the
766 * stream is detected, or an exception is thrown.
767 *
768 * @return the next four bytes of this stream, interpreted as a
769 * <code>float</code>.
770 * @exception EOFException if this stream reaches the end before reading
771 * four bytes.
772 * @exception IOException if an I/O error occurs.
773 */
774 public final float readFloat() throws IOException {
775 return Float.intBitsToFloat(readInt());
776 }
777
778 /**
779 * Reads a <code>float</code> from this stream in little-endian order.
780 * This method reads an
781 * <code>int</code> value, starting at the current stream pointer,
782 * as if by the <code>readInt</code> method
783 * and then converts that <code>int</code> to a <code>float</code>
784 * using the <code>intBitsToFloat</code> method in class
785 * <code>Float</code>.
786 * <p>
787 * This method blocks until the four bytes are read, the end of the
788 * stream is detected, or an exception is thrown.
789 *
790 * @return the next four bytes of this stream, interpreted as a
791 * <code>float</code>.
792 * @exception EOFException if this stream reaches the end before reading
793 * four bytes.
794 * @exception IOException if an I/O error occurs.
795 */
796 public final float readFloatLE() throws IOException {
797 return Float.intBitsToFloat(readIntLE());
798 }
799
800 /**
801 * Reads a <code>double</code> from this stream. This method reads a
802 * <code>long</code> value, starting at the current stream pointer,
803 * as if by the <code>readLong</code> method
804 * and then converts that <code>long</code> to a <code>double</code>
805 * using the <code>longBitsToDouble</code> method in
806 * class <code>Double</code>.
807 * <p>
808 * This method blocks until the eight bytes are read, the end of the
809 * stream is detected, or an exception is thrown.
810 *
811 * @return the next eight bytes of this stream, interpreted as a
812 * <code>double</code>.
813 * @exception EOFException if this stream reaches the end before reading
814 * eight bytes.
815 * @exception IOException if an I/O error occurs.
816 */
817 public final double readDouble() throws IOException {
818 return Double.longBitsToDouble(readLong());
819 }
820
821 /**
822 * Reads a <code>double</code> from this stream in little-endian order.
823 * This method reads a
824 * <code>long</code> value, starting at the current stream pointer,
825 * as if by the <code>readLong</code> method
826 * and then converts that <code>long</code> to a <code>double</code>
827 * using the <code>longBitsToDouble</code> method in
828 * class <code>Double</code>.
829 * <p>
830 * This method blocks until the eight bytes are read, the end of the
831 * stream is detected, or an exception is thrown.
832 *
833 * @return the next eight bytes of this stream, interpreted as a
834 * <code>double</code>.
835 * @exception EOFException if this stream reaches the end before reading
836 * eight bytes.
837 * @exception IOException if an I/O error occurs.
838 */
839 public final double readDoubleLE() throws IOException {
840 return Double.longBitsToDouble(readLongLE());
841 }
842
843 /**
844 * Reads the next line of text from this stream. This method successively
845 * reads bytes from the stream, starting at the current stream pointer,
846 * until it reaches a line terminator or the end
847 * of the stream. Each byte is converted into a character by taking the
848 * byte's value for the lower eight bits of the character and setting the
849 * high eight bits of the character to zero. This method does not,
850 * therefore, support the full Unicode character set.
851 *
852 * <p> A line of text is terminated by a carriage-return character
853 * (<code>'\r'</code>), a newline character (<code>'\n'</code>), a
854 * carriage-return character immediately followed by a newline character,
855 * or the end of the stream. Line-terminating characters are discarded and
856 * are not included as part of the string returned.
857 *
858 * <p> This method blocks until a newline character is read, a carriage
859 * return and the byte following it are read (to see if it is a newline),
860 * the end of the stream is reached, or an exception is thrown.
861 *
862 * @return the next line of text from this stream, or null if end
863 * of stream is encountered before even one byte is read.
864 * @exception IOException if an I/O error occurs.
865 */
866 public final String readLine() throws IOException {
867 StringBuffer input = new StringBuffer();
868 int c = -1;
869 boolean eol = false;
870
871 while (!eol) {
872 switch (c = read()) {
873 case -1:
874 case '\n':
875 eol = true;
876 break;
877 case '\r':
878 eol = true;
879 long cur = getFilePointer();
880 if ((read()) != '\n') {
881 seek(cur);
882 }
883 break;
884 default:
885 input.append((char)c);
886 break;
887 }
888 }
889
890 if ((c == -1) && (input.length() == 0)) {
891 return null;
892 }
893 return input.toString();
894 }
895
896 /**
897 * Reads in a string from this stream. The string has been encoded
898 * using a modified UTF-8 format.
899 * <p>
900 * The first two bytes are read, starting from the current stream
901 * pointer, as if by
902 * <code>readUnsignedShort</code>. This value gives the number of
903 * following bytes that are in the encoded string, not
904 * the length of the resulting string. The following bytes are then
905 * interpreted as bytes encoding characters in the UTF-8 format
906 * and are converted into characters.
907 * <p>
908 * This method blocks until all the bytes are read, the end of the
909 * stream is detected, or an exception is thrown.
910 *
911 * @return a Unicode string.
912 * @exception EOFException if this stream reaches the end before
913 * reading all the bytes.
914 * @exception IOException if an I/O error occurs.
915 * @exception UTFDataFormatException if the bytes do not represent
916 * valid UTF-8 encoding of a Unicode string.
917 */
918 public final String readUTF() throws IOException {
919 return DataInputStream.readUTF(this);
920 }
921
922 /**
923 * Releases any system resources associated with this stream
924 * by calling the <code>close()</code> method.
925 */
926 protected void finalize() throws Throwable {
927 super.finalize();
928 close();
929 }
930 }