By Russ Rew, based on 55 | * BufferedRandomAccessFile by Alex McManus, based on Sun's source code 56 | * for java.io.RandomAccessFile. For Alex McManus version from which 57 | * this derives, see his 58 | * Freeware Java Classes. 59 | *
60 | * 61 | * @author Alex McManus 62 | * @author Russ Rew 63 | * @author john caron 64 | * @see DataInput 65 | * @see DataOutput 66 | * @see java.io.RandomAccessFile 67 | */ 68 | 69 | public class RandomAccessFile implements DataInput, DataOutput { 70 | 71 | static public final int BIG_ENDIAN = 0; 72 | static public final int LITTLE_ENDIAN = 1; 73 | 74 | // debug leaks - keep track of open files 75 | 76 | 77 | static protected boolean debugLeaks = false; 78 | static protected boolean debugAccess = false; 79 | static protected SetbufferStart + dataSize, but it is cached to speed
184 | * up the read( ) method.
185 | */
186 | protected long dataEnd;
187 |
188 | /**
189 | * The size of the data stored in the buffer, in bytes. This may be
190 | * less than the size of the buffer.
191 | */
192 | protected int dataSize;
193 |
194 | /**
195 | * True if we are at the end of the file.
196 | */
197 | protected boolean endOfFile;
198 |
199 | /**
200 | * The access mode of the file.
201 | */
202 | protected boolean readonly;
203 |
204 | /**
205 | * The current endian (big or little) mode of the file.
206 | */
207 | protected boolean bigEndian;
208 |
209 | /**
210 | * True if the data in the buffer has been modified.
211 | */
212 | boolean bufferModified = false;
213 |
214 | /**
215 | * make sure file is this long when closed
216 | */
217 | private long minLength = 0;
218 |
219 | /**
220 | * stupid extendMode for truncated, yet valid files - old code allowed NOFILL to do this
221 | */
222 | boolean extendMode = false;
223 |
224 | /**
225 | * Constructor, for subclasses
226 | *
227 | * @param bufferSize size of read buffer
228 | */
229 | protected RandomAccessFile(int bufferSize) {
230 | file = null;
231 | readonly = true;
232 | init(bufferSize);
233 | }
234 |
235 | /**
236 | * Constructor, default buffer size.
237 | *
238 | * @param location location of the file
239 | * @param mode same as for java.io.RandomAccessFile
240 | * @throws IOException on open error
241 | */
242 | public RandomAccessFile(String location, String mode) throws IOException {
243 | this(location, mode, defaultBufferSize);
244 | this.location = location;
245 | }
246 |
247 | /**
248 | * Constructor.
249 | *
250 | * @param location location of the file
251 | * @param mode same as for java.io.RandomAccessFile
252 | * @param bufferSize size of buffer to use.
253 | * @throws IOException on open error
254 | */
255 | public RandomAccessFile(String location, String mode, int bufferSize) throws IOException {
256 | this.location = location;
257 | if (debugLeaks) {
258 | allFiles.add(location);
259 | if ((location.indexOf("01janN") >= 0) || (location.indexOf("02febN") >= 0))
260 | System.out.printf("HEY!%n");
261 | }
262 |
263 | this.file = new java.io.RandomAccessFile(location, mode);
264 | this.readonly = mode.equals("r");
265 | init(bufferSize);
266 |
267 | if (debugLeaks) {
268 | openFiles.add(location);
269 | if (showOpen) System.out.println(" open " + location);
270 | }
271 | }
272 |
273 | /**
274 | * Allow access to the underlying java.io.RandomAccessFile.
275 | * WARNING! BROKEN ENCAPSOLATION, DO NOT USE. May change implementation in the future.
276 | *
277 | * @return the underlying java.io.RandomAccessFile.
278 | */
279 | public java.io.RandomAccessFile getRandomAccessFile() {
280 | return this.file;
281 | }
282 |
283 | private void init(int bufferSize) {
284 | // Initialise the buffer
285 | bufferStart = 0;
286 | dataEnd = 0;
287 | dataSize = 0;
288 | filePosition = 0;
289 | buffer = new byte[bufferSize];
290 | endOfFile = false;
291 | }
292 |
293 | /**
294 | * Set the buffer size.
295 | * If writing, call flush() first.
296 | *
297 | * @param bufferSize length in bytes
298 | */
299 | public void setBufferSize(int bufferSize) {
300 | init(bufferSize);
301 | }
302 |
303 | /**
304 | * Get the buffer size
305 | *
306 | * @return bufferSize length in bytes
307 | */
308 | public int getBufferSize() {
309 | return buffer.length;
310 | }
311 |
312 | /**
313 | * Close the file, and release any associated system resources.
314 | *
315 | * @throws IOException if an I/O error occurrs.
316 | */
317 | public void close() throws IOException {
318 | if (debugLeaks) {
319 | openFiles.remove(location);
320 | if (showOpen) System.out.println(" close " + location);
321 | }
322 |
323 | if (file == null)
324 | return;
325 |
326 | // If we are writing and the buffer has been modified, flush the contents
327 | // of the buffer.
328 | flush();
329 |
330 | /*
331 | if (!readonly && bufferModified) {
332 | file.seek(bufferStart);
333 | file.write(buffer, 0, dataSize);
334 | } */
335 |
336 | // may need to extend file, in case no fill is being used
337 | // may need to truncate file in case overwriting a longer file
338 | // use only if minLength is set (by N3iosp)
339 | long fileSize = file.length();
340 | if (!readonly && (minLength != 0) && (minLength != fileSize)) {
341 | file.setLength(minLength);
342 | // System.out.println("TRUNCATE!!! minlength="+minLength);
343 | }
344 |
345 | // Close the underlying file object.
346 | file.close();
347 | //file = null; // help the gc => commented because of problems with nullpointerexceptions when trying to read after close
348 | }
349 |
350 | /**
351 | * Return true if file pointer is at end of file.
352 | *
353 | * @return true if file pointer is at end of file
354 | */
355 | public boolean isAtEndOfFile() {
356 | return endOfFile;
357 | }
358 |
359 | /**
360 | * Set the position in the file for the next read or write.
361 | *
362 | * @param pos the offset (in bytes) from the start of the file.
363 | * @throws IOException if an I/O error occurrs.
364 | */
365 | public void seek(long pos) throws IOException {
366 |
367 | // If the seek is into the buffer, just update the file pointer.
368 | if ((pos >= bufferStart) && (pos < dataEnd)) {
369 | filePosition = pos;
370 | return;
371 | }
372 |
373 | // need new buffer, starting at pos
374 | readBuffer(pos);
375 | }
376 |
377 | protected void readBuffer(long pos) throws IOException {
378 | // If the current buffer is modified, write it to disk.
379 | if (bufferModified) {
380 | flush();
381 | }
382 |
383 | bufferStart = pos;
384 | filePosition = pos;
385 |
386 | dataSize = read_(pos, buffer, 0, buffer.length);
387 |
388 | if (dataSize <= 0) {
389 | dataSize = 0;
390 | endOfFile = true;
391 | } else {
392 | endOfFile = false;
393 | }
394 |
395 | // Cache the position of the buffer end.
396 | dataEnd = bufferStart + dataSize;
397 | }
398 |
399 | /**
400 | * Returns the current position in the file, where the next read or
401 | * write will occur.
402 | *
403 | * @return the offset from the start of the file in bytes.
404 | * @throws IOException if an I/O error occurrs.
405 | */
406 | public long getFilePointer() throws IOException {
407 | return filePosition;
408 | }
409 |
410 | /**
411 | * Get the file location, or name.
412 | *
413 | * @return file location
414 | */
415 | public String getLocation() {
416 | return location;
417 | }
418 |
419 | /**
420 | * Get the length of the file. The data in the buffer (which may not
421 | * have been written the disk yet) is taken into account.
422 | *
423 | * @return the length of the file in bytes.
424 | * @throws IOException if an I/O error occurrs.
425 | */
426 | public long length() throws IOException {
427 | long fileLength = file.length();
428 | if (fileLength < dataEnd) {
429 | return dataEnd;
430 | } else {
431 | return fileLength;
432 | }
433 | }
434 |
435 | /**
436 | * Change the current endian mode. Subsequent reads of short, int, float, double, long, char will
437 | * use this. Does not currently affect writes.
438 | * Default values is BIG_ENDIAN.
439 | *
440 | * @param endian RandomAccessFile.BIG_ENDIAN or RandomAccessFile.LITTLE_ENDIAN
441 | */
442 | public void order(int endian) {
443 | if (endian < 0) return;
444 | this.bigEndian = (endian == BIG_ENDIAN);
445 | }
446 |
447 | /**
448 | * Returns the opaque file descriptor object associated with this file.
449 | *
450 | * @return the file descriptor object associated with this file.
451 | * @throws IOException if an I/O error occurs.
452 | */
453 | public FileDescriptor getFD() throws IOException {
454 | return (file == null) ? null : file.getFD();
455 | }
456 |
457 | public boolean isEmpty() throws IOException {
458 | return length() == 0;
459 | }
460 |
461 | /**
462 | * Copy the contents of the buffer to the disk.
463 | *
464 | * @throws IOException if an I/O error occurs.
465 | */
466 | public void flush() throws IOException {
467 | if (bufferModified) {
468 | file.seek(bufferStart);
469 | file.write(buffer, 0, dataSize);
470 | //System.out.println("--flush at "+bufferStart+" dataSize= "+dataSize+ " filePosition= "+filePosition);
471 | bufferModified = false;
472 | }
473 |
474 | /* check min length
475 | if (!readonly && (minLength != 0) && (minLength != file.length())) {
476 | file.setLength(minLength);
477 | } */
478 | }
479 |
480 | /**
481 | * Make sure file is at least this long when its closed.
482 | * needed when not using fill mode, and not all data is written.
483 | *
484 | * @param minLength minimum length of the file.
485 | */
486 | public void setMinLength(long minLength) {
487 | this.minLength = minLength;
488 | }
489 |
490 | /**
491 | * Set extendMode for truncated, yet valid files - old NetCDF code allowed this
492 | * when NOFILL on, and user doesnt write all variables.
493 | */
494 | public void setExtendMode() {
495 | this.extendMode = true;
496 | }
497 |
498 | //////////////////////////////////////////////////////////////////////////////////////////////
499 | // Read primitives.
500 | //
501 |
502 | /**
503 | * Read a byte of data from the file, blocking until data is
504 | * available.
505 | *
506 | * @return the next byte of data, or -1 if the end of the file is
507 | * reached.
508 | * @throws IOException if an I/O error occurrs.
509 | */
510 | public int read() throws IOException {
511 |
512 | // If the file position is within the data, return the byte...
513 | if (filePosition < dataEnd) {
514 | int pos = (int) (filePosition - bufferStart);
515 | filePosition++;
516 | return (buffer[pos] & 0xff);
517 |
518 | // ...or should we indicate EOF...
519 | } else if (endOfFile) {
520 | return -1;
521 |
522 | // ...or seek to fill the buffer, and try again.
523 | } else {
524 | seek(filePosition);
525 | return read();
526 | }
527 | }
528 |
529 | /**
530 | * Read up to len bytes into an array, at a specified
531 | * offset. This will block until at least one byte has been read.
532 | *
533 | * @param b the byte array to receive the bytes.
534 | * @param off the offset in the array where copying will start.
535 | * @param len the number of bytes to copy.
536 | * @return the actual number of bytes read, or -1 if there is not
537 | * more data due to the end of the file being reached.
538 | * @throws IOException if an I/O error occurrs.
539 | */
540 | protected int readBytes(byte b[], int off, int len) throws IOException {
541 |
542 | // Check for end of file.
543 | if (endOfFile) {
544 | return -1;
545 | }
546 |
547 | // See how many bytes are available in the buffer - if none,
548 | // seek to the file position to update the buffer and try again.
549 | int bytesAvailable = (int) (dataEnd - filePosition);
550 | if (bytesAvailable < 1) {
551 | seek(filePosition);
552 | return readBytes(b, off, len);
553 | }
554 |
555 | // Copy as much as we can.
556 | int copyLength = (bytesAvailable >= len)
557 | ? len
558 | : bytesAvailable;
559 | System.arraycopy(buffer, (int) (filePosition - bufferStart), b, off, copyLength);
560 | filePosition += copyLength;
561 |
562 | // If there is more to copy...
563 | if (copyLength < len) {
564 | int extraCopy = len - copyLength;
565 |
566 | // If the amount remaining is more than a buffer's length, read it
567 | // directly from the file.
568 | if (extraCopy > buffer.length) {
569 | extraCopy = read_(filePosition, b, off + copyLength, len - copyLength);
570 |
571 | // ...or read a new buffer full, and copy as much as possible...
572 | } else {
573 | seek(filePosition);
574 | if (!endOfFile) {
575 | extraCopy = (extraCopy > dataSize)
576 | ? dataSize
577 | : extraCopy;
578 | System.arraycopy(buffer, 0, b, off + copyLength, extraCopy);
579 | } else {
580 | extraCopy = -1;
581 | }
582 | }
583 |
584 | // If we did manage to copy any more, update the file position and
585 | // return the amount copied.
586 | if (extraCopy > 0) {
587 | filePosition += extraCopy;
588 | return copyLength + extraCopy;
589 | }
590 | }
591 |
592 | // Return the amount copied.
593 | return copyLength;
594 | }
595 |
596 | /**
597 | * Read nbytes bytes, at the specified file offset, send to a WritableByteChannel.
598 | * This will block until all bytes are read.
599 | * This uses the underlying file channel directly, bypassing all user buffers.
600 | *
601 | * @param dest write to this WritableByteChannel.
602 | * @param offset the offset in the file where copying will start.
603 | * @param nbytes the number of bytes to read.
604 | * @return the actual number of bytes read and transfered
605 | * @throws IOException if an I/O error occurs.
606 | */
607 | public long readToByteChannel(WritableByteChannel dest, long offset, long nbytes) throws IOException {
608 |
609 | if (fileChannel == null)
610 | fileChannel = file.getChannel();
611 |
612 | long need = nbytes;
613 | while (need > 0) {
614 | long count = fileChannel.transferTo(offset, need, dest);
615 | //if (count == 0) break; // LOOK not sure what the EOF condition is
616 | need -= count;
617 | offset += count;
618 | }
619 | return nbytes - need;
620 | }
621 |
622 |
623 | /**
624 | * Read directly from file, without going through the buffer.
625 | * All reading goes through here or readToByteChannel;
626 | *
627 | * @param pos start here in the file
628 | * @param b put data into this buffer
629 | * @param offset buffer offset
630 | * @param len this number of bytes
631 | * @return actual number of bytes read
632 | * @throws IOException on io error
633 | */
634 | protected int read_(long pos, byte[] b, int offset, int len) throws IOException {
635 | file.seek(pos);
636 | int n = file.read(b, offset, len);
637 | if (debugAccess) {
638 | if (showRead) System.out.println(" **read_ " + location + " = " + len + " bytes at " + pos + "; block = " + (pos / buffer.length));
639 | debug_nseeks.incrementAndGet();
640 | debug_nbytes.addAndGet(len);
641 | }
642 |
643 | if (extendMode && (n < len)) {
644 | //System.out.println(" read_ = "+len+" at "+pos+"; got = "+n);
645 | n = len;
646 | }
647 | return n;
648 | }
649 |
650 | /**
651 | * Read up to len bytes into an array, at a specified
652 | * offset. This will block until at least one byte has been read.
653 | *
654 | * @param b the byte array to receive the bytes.
655 | * @param off the offset in the array where copying will start.
656 | * @param len the number of bytes to copy.
657 | * @return the actual number of bytes read, or -1 if there is not
658 | * more data due to the end of the file being reached.
659 | * @throws IOException if an I/O error occurrs.
660 | */
661 | public int read(byte b[], int off, int len) throws IOException {
662 | return readBytes(b, off, len);
663 | }
664 |
665 | /**
666 | * Read up to b.length( ) bytes into an array. This
667 | * will block until at least one byte has been read.
668 | *
669 | * @param b the byte array to receive the bytes.
670 | * @return the actual number of bytes read, or -1 if there is not
671 | * more data due to the end of the file being reached.
672 | * @throws IOException if an I/O error occurrs.
673 | */
674 | public int read(byte b[]) throws IOException {
675 | return readBytes(b, 0, b.length);
676 | }
677 |
678 | /**
679 | * Read fully count number of bytes
680 | *
681 | * @param count how many bytes tp read
682 | * @return a byte array of length count, fully read in
683 | * @throws IOException if an I/O error occurrs.
684 | */
685 | public byte[] readBytes(int count) throws IOException {
686 | byte[] b = new byte[count];
687 | readFully(b);
688 | return b;
689 | }
690 |
691 | /**
692 | * Reads b.length bytes from this file into the byte
693 | * array. This method reads repeatedly from the file until all the
694 | * bytes are read. This method blocks until all the bytes are read,
695 | * the end of the stream is detected, or an exception is thrown.
696 | *
697 | * @param b the buffer into which the data is read.
698 | * @throws EOFException if this file reaches the end before reading
699 | * all the bytes.
700 | * @throws IOException if an I/O error occurs.
701 | */
702 | public final void readFully(byte b[]) throws IOException {
703 | readFully(b, 0, b.length);
704 | }
705 |
706 | /**
707 | * Reads exactly len bytes from this file into the byte
708 | * array. This method reads repeatedly from the file until all the
709 | * bytes are read. This method blocks until all the bytes are read,
710 | * the end of the stream is detected, or an exception is thrown.
711 | *
712 | * @param b the buffer into which the data is read.
713 | * @param off the start offset of the data.
714 | * @param len the number of bytes to read.
715 | * @throws EOFException if this file reaches the end before reading
716 | * all the bytes.
717 | * @throws IOException if an I/O error occurs.
718 | */
719 | public final void readFully(byte b[], int off, int len) throws IOException {
720 | int n = 0;
721 | while (n < len) {
722 | int count = this.read(b, off + n, len - n);
723 | if (count < 0) {
724 | throw new EOFException();
725 | }
726 | n += count;
727 | }
728 | }
729 |
730 | /**
731 | * Skips exactly n bytes of input.
732 | * This method blocks until all the bytes are skipped, the end of
733 | * the stream is detected, or an exception is thrown.
734 | *
735 | * @param n the number of bytes to be skipped.
736 | * @return the number of bytes skipped, which is always n.
737 | * @throws EOFException if this file reaches the end before skipping
738 | * all the bytes.
739 | * @throws IOException if an I/O error occurs.
740 | */
741 | public int skipBytes(int n) throws IOException {
742 | seek(getFilePointer() + n);
743 | return n;
744 | }
745 |
746 | /* public void skipToMultiple( int multipleOfBytes) throws IOException {
747 | long pos = getFilePointer();
748 | int pad = (int) (pos % multipleOfBytes);
749 | if (pad != 0) pad = multipleOfBytes - pad;
750 | if (pad > 0) skipBytes(pad);
751 | } */
752 |
753 | /**
754 | * Unread the last byte read.
755 | * This method should not be used more than once
756 | * between reading operations, or strange things might happen.
757 | */
758 | public void unread() {
759 | filePosition--;
760 | }
761 |
762 | //
763 | // Write primitives.
764 | //
765 |
766 | /**
767 | * Write a byte to the file. If the file has not been opened for
768 | * writing, an IOException will be raised only when an attempt is
769 | * made to write the buffer to the file.
770 | *
771 | * Caveat: the effects of seek( )ing beyond the end of the file are
772 | * undefined.
773 | *
774 | * @param b write this byte
775 | * @throws IOException if an I/O error occurrs.
776 | */
777 | public void write(int b) throws IOException {
778 |
779 | // If the file position is within the block of data...
780 | if (filePosition < dataEnd) {
781 | int pos = (int) (filePosition - bufferStart);
782 | buffer[pos] = (byte) b;
783 | bufferModified = true;
784 | filePosition++;
785 |
786 | // ...or (assuming that seek will not allow the file pointer
787 | // to move beyond the end of the file) get the correct block of
788 | // data...
789 | } else {
790 |
791 | // If there is room in the buffer, expand it...
792 | if (dataSize != buffer.length) {
793 | int pos = (int) (filePosition - bufferStart);
794 | buffer[pos] = (byte) b;
795 | bufferModified = true;
796 | filePosition++;
797 | dataSize++;
798 | dataEnd++;
799 |
800 | // ...or do another seek to get a new buffer, and start again...
801 | } else {
802 | seek(filePosition);
803 | write(b);
804 | }
805 | }
806 | }
807 |
808 | /**
809 | * Write len bytes from an array to the file.
810 | *
811 | * @param b the array containing the data.
812 | * @param off the offset in the array to the data.
813 | * @param len the length of the data.
814 | * @throws IOException if an I/O error occurrs.
815 | */
816 | public void writeBytes(byte b[], int off, int len) throws IOException {
817 | // If the amount of data is small (less than a full buffer)...
818 | if (len < buffer.length) {
819 |
820 | // If any of the data fits within the buffer...
821 | int spaceInBuffer = 0;
822 | int copyLength = 0;
823 | if (filePosition >= bufferStart) {
824 | spaceInBuffer = (int) ((bufferStart + buffer.length) - filePosition);
825 | }
826 |
827 | if (spaceInBuffer > 0) {
828 | // Copy as much as possible to the buffer.
829 | copyLength = (spaceInBuffer > len) ? len : spaceInBuffer;
830 | System.arraycopy(b, off, buffer, (int) (filePosition - bufferStart), copyLength);
831 | bufferModified = true;
832 | long myDataEnd = filePosition + copyLength;
833 | dataEnd = (myDataEnd > dataEnd) ? myDataEnd : dataEnd;
834 | dataSize = (int) (dataEnd - bufferStart);
835 | filePosition += copyLength;
836 | ///System.out.println("--copy to buffer "+copyLength+" "+len);
837 | }
838 |
839 | // If there is any data remaining, move to the new position and copy to
840 | // the new buffer.
841 | if (copyLength < len) {
842 | //System.out.println("--need more "+copyLength+" "+len+" space= "+spaceInBuffer);
843 | seek(filePosition); // triggers a flush
844 | System.arraycopy(b, off + copyLength, buffer, (int) (filePosition - bufferStart), len - copyLength);
845 | bufferModified = true;
846 | long myDataEnd = filePosition + (len - copyLength);
847 | dataEnd = (myDataEnd > dataEnd) ? myDataEnd : dataEnd;
848 | dataSize = (int) (dataEnd - bufferStart);
849 | filePosition += (len - copyLength);
850 | }
851 |
852 | // ...or write a lot of data...
853 | } else {
854 |
855 | // Flush the current buffer, and write this data to the file.
856 | if (bufferModified) {
857 | flush();
858 | }
859 | file.seek(filePosition); // moved per Steve Cerruti; Jan 14, 2005
860 | file.write(b, off, len);
861 | //System.out.println("--write at "+filePosition+" "+len);
862 |
863 | filePosition += len;
864 | bufferStart = filePosition; // an empty buffer
865 | dataSize = 0;
866 | dataEnd = bufferStart + dataSize;
867 | }
868 | }
869 |
870 | /**
871 | * Writes b.length bytes from the specified byte array
872 | * starting at offset off to this file.
873 | *
874 | * @param b the data.
875 | * @throws IOException if an I/O error occurs.
876 | */
877 | public void write(byte b[]) throws IOException {
878 | writeBytes(b, 0, b.length);
879 | }
880 |
881 | /**
882 | * Writes len bytes from the specified byte array
883 | * starting at offset off to this file.
884 | *
885 | * @param b the data.
886 | * @param off the start offset in the data.
887 | * @param len the number of bytes to write.
888 | * @throws IOException if an I/O error occurs.
889 | */
890 | public void write(byte b[], int off, int len) throws IOException {
891 | writeBytes(b, off, len);
892 | }
893 |
894 | //
895 | // DataInput methods.
896 | //
897 |
898 | /**
899 | * Reads a boolean from this file. This method reads a
900 | * single byte from the file. A value of 0 represents
901 | * false. Any other value represents true.
902 | * This method blocks until the byte is read, the end of the stream
903 | * is detected, or an exception is thrown.
904 | *
905 | * @return the boolean value read.
906 | * @throws EOFException if this file has reached the end.
907 | * @throws IOException if an I/O error occurs.
908 | */
909 | public final boolean readBoolean() throws IOException {
910 | int ch = this.read();
911 | if (ch < 0) {
912 | throw new EOFException();
913 | }
914 | return (ch != 0);
915 | }
916 |
917 | /**
918 | * Reads a signed 8-bit value from this file. This method reads a
919 | * byte from the file. If the byte read is b, where
920 | * 0 <= b <= 255,
921 | * then the result is:
922 | *
923 | * (byte)(b)
924 | * byte.
931 | * @throws EOFException if this file has reached the end.
932 | * @throws IOException if an I/O error occurs.
933 | */
934 | public final byte readByte() throws IOException {
935 | int ch = this.read();
936 | if (ch < 0) {
937 | throw new EOFException();
938 | }
939 | return (byte) (ch);
940 | }
941 |
942 | /**
943 | * Reads an unsigned 8-bit number from this file. This method reads
944 | * a byte from this file and returns that byte.
945 | *
946 | * This method blocks until the byte is read, the end of the stream
947 | * is detected, or an exception is thrown.
948 | *
949 | * @return the next byte of this file, interpreted as an unsigned
950 | * 8-bit number.
951 | * @throws EOFException if this file has reached the end.
952 | * @throws IOException if an I/O error occurs.
953 | */
954 | public final int readUnsignedByte() throws IOException {
955 | int ch = this.read();
956 | if (ch < 0) {
957 | throw new EOFException();
958 | }
959 | return ch;
960 | }
961 |
962 | /**
963 | * Reads a signed 16-bit number from this file. The method reads 2
964 | * bytes from this file. If the two bytes read, in order, are
965 | * b1 and b2, where each of the two values is
966 | * between 0 and 255, inclusive, then the
967 | * result is equal to:
968 | *
969 | * (short)((b1 << 8) | b2)
970 | * b1 and b2, where
1012 | * 0 <= b1, b2 <= 255,
1013 | * then the result is equal to:
1014 | *
1015 | * (b1 << 8) | b2
1016 | * b1,
1044 | * b2, and b3, where
1045 | * 0 <= b1, b2, b3 <= 255,
1046 | * then the result is equal to:
1047 | *
1048 | * (b1 << 16) | (b2 << 8) + (b3 << 0)
1049 | * b1 and b2, where
1059 | * 0 <= b1, b2 <= 255,
1060 | * then the result is equal to:
1061 | *
1062 | * (char)((b1 << 8) | b2)
1063 | * b1,
1089 | * b2, b3, and b4, where
1090 | * 0 <= b1, b2, b3, b4 <= 255,
1091 | * then the result is equal to:
1092 | *
1093 | * (b1 << 24) | (b2 << 16) + (b3 << 8) + b4
1094 | * int.
1101 | * @throws EOFException if this file reaches the end before reading
1102 | * four bytes.
1103 | * @throws IOException if an I/O error occurs.
1104 | */
1105 | public final int readInt() throws IOException {
1106 | int ch1 = this.read();
1107 | int ch2 = this.read();
1108 | int ch3 = this.read();
1109 | int ch4 = this.read();
1110 | if ((ch1 | ch2 | ch3 | ch4) < 0) {
1111 | throw new EOFException();
1112 | }
1113 |
1114 | if (bigEndian) {
1115 | return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4));
1116 | } else {
1117 | return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1));
1118 | }
1119 | }
1120 |
1121 | /**
1122 | * Read an integer at the given position, bypassing all buffering.
1123 | *
1124 | * @param pos read a byte at this position
1125 | * @return The int that was read
1126 | * @throws IOException if an I/O error occurs.
1127 | */
1128 | public final int readIntUnbuffered(long pos) throws IOException {
1129 | byte[] bb = new byte[4];
1130 | read_(pos, bb, 0, 4);
1131 | int ch1 = bb[0] & 0xff;
1132 | int ch2 = bb[1] & 0xff;
1133 | int ch3 = bb[2] & 0xff;
1134 | int ch4 = bb[3] & 0xff;
1135 | if ((ch1 | ch2 | ch3 | ch4) < 0) {
1136 | throw new EOFException();
1137 | }
1138 |
1139 | if (bigEndian) {
1140 | return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4));
1141 | } else {
1142 | return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1));
1143 | }
1144 | }
1145 |
1146 |
1147 | /**
1148 | * Read an array of ints
1149 | *
1150 | * @param pa read into this array
1151 | * @param start starting at pa[start]
1152 | * @param n read this many elements
1153 | * @throws IOException on read error
1154 | */
1155 | public final void readInt(int[] pa, int start, int n) throws IOException {
1156 | for (int i = 0; i < n; i++) {
1157 | pa[start + i] = readInt();
1158 | }
1159 | }
1160 |
1161 | /**
1162 | * Reads a signed 64-bit integer from this file. This method reads eight
1163 | * bytes from the file. If the bytes read, in order, are
1164 | * b1, b2, b3,
1165 | * b4, b5, b6,
1166 | * b7, and b8, where:
1167 | *
1168 | * 0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255,
1169 | * 1178 | * 1179 | * This method blocks until the eight bytes are read, the end of the 1180 | * stream is detected, or an exception is thrown. 1181 | * 1182 | * @return the next eight bytes of this file, interpreted as a 1183 | *1173 | * ((long)b1 << 56) + ((long)b2 << 48) 1174 | * + ((long)b3 << 40) + ((long)b4 << 32) 1175 | * + ((long)b5 << 24) + ((long)b6 << 16) 1176 | * + ((long)b7 << 8) + b8 1177 | *
long.
1184 | * @throws EOFException if this file reaches the end before reading
1185 | * eight bytes.
1186 | * @throws IOException if an I/O error occurs.
1187 | */
1188 | public final long readLong() throws IOException {
1189 | if (bigEndian) {
1190 | return ((long) (readInt()) << 32) + (readInt() & 0xFFFFFFFFL); // tested ok
1191 | } else {
1192 | return ((readInt() & 0xFFFFFFFFL) + ((long) readInt() << 32)); // not tested yet ??
1193 | }
1194 |
1195 | /* int ch1 = this.read();
1196 | int ch2 = this.read();
1197 | int ch3 = this.read();
1198 | int ch4 = this.read();
1199 | int ch5 = this.read();
1200 | int ch6 = this.read();
1201 | int ch7 = this.read();
1202 | int ch8 = this.read();
1203 | if ((ch1 | ch2 | ch3 | ch4 | ch5 | ch6 | ch7 | ch8) < 0)
1204 | throw new EOFException();
1205 |
1206 | if (bigEndian)
1207 | return ((long)(ch1 << 56)) + (ch2 << 48) + (ch3 << 40) + (ch4 << 32) + (ch5 << 24) + (ch6 << 16) + (ch7 << 8) + (ch8 << 0));
1208 | else
1209 | return ((long)(ch8 << 56) + (ch7 << 48) + (ch6 << 40) + (ch5 << 32) + (ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0));
1210 | */
1211 | }
1212 |
1213 | /**
1214 | * Read an array of longs
1215 | *
1216 | * @param pa read into this array
1217 | * @param start starting at pa[start]
1218 | * @param n read this many elements
1219 | * @throws IOException on read error
1220 | */
1221 | public final void readLong(long[] pa, int start, int n) throws IOException {
1222 | for (int i = 0; i < n; i++) {
1223 | pa[start + i] = readLong();
1224 | }
1225 | }
1226 |
1227 |
1228 | /**
1229 | * Reads a float from this file. This method reads an
1230 | * int value as if by the readInt method
1231 | * and then converts that int to a float
1232 | * using the intBitsToFloat method in class
1233 | * Float.
1234 | *
1235 | * This method blocks until the four bytes are read, the end of the
1236 | * stream is detected, or an exception is thrown.
1237 | *
1238 | * @return the next four bytes of this file, interpreted as a
1239 | * float.
1240 | * @throws EOFException if this file reaches the end before reading
1241 | * four bytes.
1242 | * @throws IOException if an I/O error occurs.
1243 | * @see java.io.RandomAccessFile#readInt()
1244 | * @see java.lang.Float#intBitsToFloat(int)
1245 | */
1246 | public final float readFloat() throws IOException {
1247 | return Float.intBitsToFloat(readInt());
1248 | }
1249 |
1250 | /**
1251 | * Read an array of floats
1252 | *
1253 | * @param pa read into this array
1254 | * @param start starting at pa[start]
1255 | * @param n read this many elements
1256 | * @throws IOException on read error
1257 | */
1258 | public final void readFloat(float[] pa, int start, int n) throws IOException {
1259 | for (int i = 0; i < n; i++) {
1260 | pa[start + i] = Float.intBitsToFloat(readInt());
1261 | }
1262 | }
1263 |
1264 |
1265 | /**
1266 | * Reads a double from this file. This method reads a
1267 | * long value as if by the readLong method
1268 | * and then converts that long to a double
1269 | * using the longBitsToDouble method in
1270 | * class Double.
1271 | *
1272 | * This method blocks until the eight bytes are read, the end of the
1273 | * stream is detected, or an exception is thrown.
1274 | *
1275 | * @return the next eight bytes of this file, interpreted as a
1276 | * double.
1277 | * @throws EOFException if this file reaches the end before reading
1278 | * eight bytes.
1279 | * @throws IOException if an I/O error occurs.
1280 | * @see java.io.RandomAccessFile#readLong()
1281 | * @see java.lang.Double#longBitsToDouble(long)
1282 | */
1283 | public final double readDouble() throws IOException {
1284 | return Double.longBitsToDouble(readLong());
1285 | }
1286 |
1287 | /**
1288 | * Read an array of doubles
1289 | *
1290 | * @param pa read into this array
1291 | * @param start starting at pa[start]
1292 | * @param n read this many elements
1293 | * @throws IOException on read error
1294 | */
1295 | public final void readDouble(double[] pa, int start, int n) throws IOException {
1296 | for (int i = 0; i < n; i++) {
1297 | pa[start + i] = Double.longBitsToDouble(readLong());
1298 | }
1299 | }
1300 |
1301 | /**
1302 | * Reads the next line of text from this file. This method
1303 | * successively reads bytes from the file until it reaches the end of
1304 | * a line of text.
1305 | *
1306 | *
1307 | * A line of text is terminated by a carriage-return character
1308 | * ('\r'), a newline character ('\n'), a
1309 | * carriage-return character immediately followed by a newline
1310 | * character, or the end of the input stream. The line-terminating
1311 | * character(s), if any, are included as part of the string returned.
1312 | *
1313 | *
1314 | * This method blocks until a newline character is read, a carriage
1315 | * return and the byte following it are read (to see if it is a
1316 | * newline), the end of the stream is detected, or an exception is thrown.
1317 | *
1318 | * @return the next line of text from this file.
1319 | * @throws IOException if an I/O error occurs.
1320 | */
1321 | public final String readLine() throws IOException {
1322 | StringBuilder input = new StringBuilder();
1323 | int c;
1324 |
1325 | while (((c = read()) != -1) && (c != '\n')) {
1326 | input.append((char) c);
1327 | }
1328 | if ((c == -1) && (input.length() == 0)) {
1329 | return null;
1330 | }
1331 | return input.toString();
1332 | }
1333 |
1334 | /**
1335 | * Reads in a string from this file. The string has been encoded
1336 | * using a modified UTF-8 format.
1337 | *
1338 | * The first two bytes are read as if by
1339 | * readUnsignedShort. This value gives the number of
1340 | * following bytes that are in the encoded string, not
1341 | * the length of the resulting string. The following bytes are then
1342 | * interpreted as bytes encoding characters in the UTF-8 format
1343 | * and are converted into characters.
1344 | *
1345 | * This method blocks until all the bytes are read, the end of the
1346 | * stream is detected, or an exception is thrown.
1347 | *
1348 | * @return a Unicode string.
1349 | * @throws EOFException if this file reaches the end before
1350 | * reading all the bytes.
1351 | * @throws IOException if an I/O error occurs.
1352 | * @throws UTFDataFormatException if the bytes do not represent
1353 | * valid UTF-8 encoding of a Unicode string.
1354 | * @see java.io.RandomAccessFile#readUnsignedShort()
1355 | */
1356 | public final String readUTF() throws IOException {
1357 | return DataInputStream.readUTF(this);
1358 | }
1359 |
1360 | /**
1361 | * Read a String of knoen length.
1362 | *
1363 | * @param nbytes number of bytes to read
1364 | * @return String wrapping the bytes.
1365 | * @throws IOException if an I/O error occurs.
1366 | */
1367 | public String readString(int nbytes) throws IOException {
1368 | byte[] data = new byte[nbytes];
1369 | readFully(data);
1370 | return new String(data);
1371 | }
1372 |
1373 | //
1374 | // DataOutput methods.
1375 | //
1376 |
1377 | /**
1378 | * Writes a boolean to the file as a 1-byte value. The
1379 | * value true is written out as the value
1380 | * (byte)1; the value false is written out
1381 | * as the value (byte)0.
1382 | *
1383 | * @param v a boolean value to be written.
1384 | * @throws IOException if an I/O error occurs.
1385 | */
1386 | public final void writeBoolean(boolean v) throws IOException {
1387 | write(v ? 1 : 0);
1388 | }
1389 |
1390 | /**
1391 | * Write an array of booleans
1392 | *
1393 | * @param pa write from this array
1394 | * @param start starting with this element in the array
1395 | * @param n write this number of elements
1396 | * @throws IOException on read error
1397 | */
1398 | public final void writeBoolean(boolean[] pa, int start, int n) throws IOException {
1399 | for (int i = 0; i < n; i++) {
1400 | writeBoolean(pa[start + i]);
1401 | }
1402 | }
1403 |
1404 | /**
1405 | * Writes a byte to the file as a 1-byte value.
1406 | *
1407 | * @param v a byte value to be written.
1408 | * @throws IOException if an I/O error occurs.
1409 | */
1410 | public final void writeByte(int v) throws IOException {
1411 | write(v);
1412 | }
1413 |
1414 | /**
1415 | * Writes a short to the file as two bytes, high byte first.
1416 | *
1417 | * @param v a short to be written.
1418 | * @throws IOException if an I/O error occurs.
1419 | */
1420 | public final void writeShort(int v) throws IOException {
1421 | write((v >>> 8) & 0xFF);
1422 | write((v) & 0xFF);
1423 | }
1424 |
1425 | /**
1426 | * Write an array of shorts
1427 | *
1428 | * @param pa write from this array
1429 | * @param start starting with this element in the array
1430 | * @param n this number of elements
1431 | * @throws IOException on read error
1432 | */
1433 | public final void writeShort(short[] pa, int start, int n) throws IOException {
1434 | for (int i = 0; i < n; i++) {
1435 | writeShort(pa[start + i]);
1436 | }
1437 | }
1438 |
1439 | /**
1440 | * Writes a char to the file as a 2-byte value, high
1441 | * byte first.
1442 | *
1443 | * @param v a char value to be written.
1444 | * @throws IOException if an I/O error occurs.
1445 | */
1446 | public final void writeChar(int v) throws IOException {
1447 | write((v >>> 8) & 0xFF);
1448 | write((v) & 0xFF);
1449 | }
1450 |
1451 | /**
1452 | * Write an array of chars
1453 | *
1454 | * @param pa write from this array
1455 | * @param start starting with this element in the array
1456 | * @param n this number of elements
1457 | * @throws IOException on read error
1458 | */
1459 | public final void writeChar(char[] pa, int start, int n) throws IOException {
1460 | for (int i = 0; i < n; i++) {
1461 | writeChar(pa[start + i]);
1462 | }
1463 | }
1464 |
1465 |
1466 | /**
1467 | * Writes an int to the file as four bytes, high byte first.
1468 | *
1469 | * @param v an int to be written.
1470 | * @throws IOException if an I/O error occurs.
1471 | */
1472 | public final void writeInt(int v) throws IOException {
1473 | write((v >>> 24) & 0xFF);
1474 | write((v >>> 16) & 0xFF);
1475 | write((v >>> 8) & 0xFF);
1476 | write((v) & 0xFF);
1477 | }
1478 |
1479 | /**
1480 | * Write an array of ints
1481 | *
1482 | * @param pa write from this array
1483 | * @param start starting with this element in the array
1484 | * @param n write this number of elements
1485 | * @throws IOException on read error
1486 | */
1487 | public final void writeInt(int[] pa, int start, int n) throws IOException {
1488 | for (int i = 0; i < n; i++) {
1489 | writeInt(pa[start + i]);
1490 | }
1491 | }
1492 |
1493 | /**
1494 | * Writes a long to the file as eight bytes, high byte first.
1495 | *
1496 | * @param v a long to be written.
1497 | * @throws IOException if an I/O error occurs.
1498 | */
1499 | public final void writeLong(long v) throws IOException {
1500 | write((int) (v >>> 56) & 0xFF);
1501 | write((int) (v >>> 48) & 0xFF);
1502 | write((int) (v >>> 40) & 0xFF);
1503 | write((int) (v >>> 32) & 0xFF);
1504 | write((int) (v >>> 24) & 0xFF);
1505 | write((int) (v >>> 16) & 0xFF);
1506 | write((int) (v >>> 8) & 0xFF);
1507 | write((int) (v) & 0xFF);
1508 | }
1509 |
1510 | /**
1511 | * Write an array of longs
1512 | *
1513 | * @param pa write from this array
1514 | * @param start starting with this element in the array
1515 | * @param n write this number of elements
1516 | * @throws IOException on read error
1517 | */
1518 | public final void writeLong(long[] pa, int start, int n) throws IOException {
1519 | for (int i = 0; i < n; i++) {
1520 | writeLong(pa[start + i]);
1521 | }
1522 | }
1523 |
1524 | /**
1525 | * Converts the float argument to an int using the
1526 | * floatToIntBits method in class Float,
1527 | * and then writes that int value to the file as a
1528 | * 4-byte quantity, high byte first.
1529 | *
1530 | * @param v a float value to be written.
1531 | * @throws IOException if an I/O error occurs.
1532 | * @see java.lang.Float#floatToIntBits(float)
1533 | */
1534 | public final void writeFloat(float v) throws IOException {
1535 | writeInt(Float.floatToIntBits(v));
1536 | }
1537 |
1538 | /**
1539 | * Write an array of floats
1540 | *
1541 | * @param pa write from this array
1542 | * @param start starting with this element in the array
1543 | * @param n write this number of elements
1544 | * @throws IOException on read error
1545 | */
1546 | public final void writeFloat(float[] pa, int start, int n) throws IOException {
1547 | for (int i = 0; i < n; i++) {
1548 | writeFloat(pa[start + i]);
1549 | }
1550 | }
1551 |
1552 |
1553 | /**
1554 | * Converts the double argument to a long using the
1555 | * doubleToLongBits method in class Double,
1556 | * and then writes that long value to the file as an
1557 | * 8-byte quantity, high byte first.
1558 | *
1559 | * @param v a double value to be written.
1560 | * @throws IOException if an I/O error occurs.
1561 | * @see java.lang.Double#doubleToLongBits(double)
1562 | */
1563 | public final void writeDouble(double v) throws IOException {
1564 | writeLong(Double.doubleToLongBits(v));
1565 | }
1566 |
1567 | /**
1568 | * Write an array of doubles
1569 | *
1570 | * @param pa write from this array
1571 | * @param start starting with this element in the array
1572 | * @param n write this number of elements
1573 | * @throws IOException on read error
1574 | */
1575 | public final void writeDouble(double[] pa, int start, int n) throws IOException {
1576 | for (int i = 0; i < n; i++) {
1577 | writeDouble(pa[start + i]);
1578 | }
1579 | }
1580 |
1581 | /**
1582 | * Writes the string to the file as a sequence of bytes. Each
1583 | * character in the string is written out, in sequence, by discarding
1584 | * its high eight bits.
1585 | *
1586 | * @param s a string of bytes to be written.
1587 | * @throws IOException if an I/O error occurs.
1588 | */
1589 | public final void writeBytes(String s) throws IOException {
1590 | int len = s.length();
1591 | for (int i = 0; i < len; i++) {
1592 | write((byte) s.charAt(i));
1593 | }
1594 | }
1595 |
1596 | /**
1597 | * Writes the character array to the file as a sequence of bytes. Each
1598 | * character in the string is written out, in sequence, by discarding
1599 | * its high eight bits.
1600 | *
1601 | * @param b a character array of bytes to be written.
1602 | * @param off the index of the first character to write.
1603 | * @param len the number of characters to write.
1604 | * @throws IOException if an I/O error occurs.
1605 | */
1606 | public final void writeBytes(char b[], int off, int len) throws IOException {
1607 | for (int i = off; i < len; i++) {
1608 | write((byte) b[i]);
1609 | }
1610 | }
1611 |
1612 | /**
1613 | * Writes a string to the file as a sequence of characters. Each
1614 | * character is written to the data output stream as if by the
1615 | * writeChar method.
1616 | *
1617 | * @param s a String value to be written.
1618 | * @throws IOException if an I/O error occurs.
1619 | * @see java.io.RandomAccessFile#writeChar(int)
1620 | */
1621 | public final void writeChars(String s) throws IOException {
1622 | int len = s.length();
1623 | for (int i = 0; i < len; i++) {
1624 | int v = s.charAt(i);
1625 | write((v >>> 8) & 0xFF);
1626 | write((v) & 0xFF);
1627 | }
1628 | }
1629 |
1630 | /**
1631 | * Writes a string to the file using UTF-8 encoding in a
1632 | * machine-independent manner.
1633 | *
1634 | * First, two bytes are written to the file as if by the
1635 | * writeShort method giving the number of bytes to
1636 | * follow. This value is the number of bytes actually written out,
1637 | * not the length of the string. Following the length, each character
1638 | * of the string is output, in sequence, using the UTF-8 encoding
1639 | * for each character.
1640 | *
1641 | * @param str a string to be written.
1642 | * @throws IOException if an I/O error occurs.
1643 | */
1644 | public final void writeUTF(String str) throws IOException {
1645 | int strlen = str.length();
1646 | int utflen = 0;
1647 |
1648 | for (int i = 0; i < strlen; i++) {
1649 | int c = str.charAt(i);
1650 | if ((c >= 0x0001) && (c <= 0x007F)) {
1651 | utflen++;
1652 | } else if (c > 0x07FF) {
1653 | utflen += 3;
1654 | } else {
1655 | utflen += 2;
1656 | }
1657 | }
1658 | if (utflen > 65535) {
1659 | throw new UTFDataFormatException();
1660 | }
1661 |
1662 | write((utflen >>> 8) & 0xFF);
1663 | write((utflen) & 0xFF);
1664 | for (int i = 0; i < strlen; i++) {
1665 | int c = str.charAt(i);
1666 | if ((c >= 0x0001) && (c <= 0x007F)) {
1667 | write(c);
1668 | } else if (c > 0x07FF) {
1669 | write(0xE0 | ((c >> 12) & 0x0F));
1670 | write(0x80 | ((c >> 6) & 0x3F));
1671 | write(0x80 | ((c) & 0x3F));
1672 | } else {
1673 | write(0xC0 | ((c >> 6) & 0x1F));
1674 | write(0x80 | ((c) & 0x3F));
1675 | }
1676 | }
1677 | }
1678 |
1679 | /**
1680 | * Create a string representation of this object.
1681 | *
1682 | * @return a string representation of the state of the object.
1683 | */
1684 | public String toString() {
1685 | return "fp=" + filePosition + ", bs=" + bufferStart + ", de="
1686 | + dataEnd + ", ds=" + dataSize + ", bl=" + buffer.length
1687 | + ", readonly=" + readonly + ", bm=" + bufferModified;
1688 | }
1689 |
1690 | /////////////////////////////////////////////////
1691 |
1692 | /**
1693 | * Search forward from the current pos, looking for a match.
1694 | *
1695 | * @param match the match to look for.
1696 | * @param maxBytes maximum number of bytes to search. use -1 for all
1697 | * @return true if found, file position will be at the start of the match.
1698 | * @throws IOException on read error
1699 | */
1700 | public boolean searchForward(KMPMatch match, int maxBytes) throws IOException {
1701 | long start = getFilePointer();
1702 | long last = (maxBytes < 0) ? length() : Math.min(length(), start + maxBytes);
1703 | long needToScan = last - start;
1704 |
1705 | // check what ever is now in the buffer
1706 | int bytesAvailable = (int) (dataEnd - filePosition);
1707 | if (bytesAvailable < 1) {
1708 | seek(filePosition); // read a new buffer
1709 | bytesAvailable = (int) (dataEnd - filePosition);
1710 | }
1711 | int bufStart = (int) (filePosition - bufferStart);
1712 | int scanBytes = (int) Math.min(bytesAvailable, needToScan);
1713 | int pos = match.indexOf(buffer, bufStart, scanBytes);
1714 | if (pos >= 0) {
1715 | seek(bufferStart + pos);
1716 | return true;
1717 | }
1718 |
1719 | int matchLen = match.getMatchLength();
1720 | needToScan -= scanBytes - matchLen;
1721 |
1722 | while (needToScan > matchLen) {
1723 | readBuffer(dataEnd - matchLen); // force new buffer
1724 |
1725 | scanBytes = (int) Math.min(buffer.length, needToScan);
1726 | pos = match.indexOf(buffer, 0, scanBytes);
1727 | if (pos > 0) {
1728 | seek(bufferStart + pos);
1729 | return true;
1730 | }
1731 |
1732 | needToScan -= scanBytes - matchLen;
1733 | }
1734 |
1735 | // failure
1736 | seek(last);
1737 | return false;
1738 | }
1739 |
1740 | }
1741 |
1742 |
1743 |
--------------------------------------------------------------------------------
/src/test/java/info/fetter/logstashforwarder/FileReaderTest.java:
--------------------------------------------------------------------------------
1 | package info.fetter.logstashforwarder;
2 |
3 | /*
4 | * Copyright 2015 Didier Fetter
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | *
18 | */
19 |
20 | import static org.apache.log4j.Level.*;
21 | import info.fetter.logstashforwarder.util.AdapterException;
22 |
23 | import java.io.File;
24 | import java.io.IOException;
25 | import java.util.ArrayList;
26 | import java.util.HashMap;
27 | import java.util.List;
28 | import java.util.Map;
29 |
30 | import org.apache.commons.io.FileUtils;
31 | import org.apache.log4j.BasicConfigurator;
32 | import org.apache.log4j.Logger;
33 | import org.apache.log4j.spi.RootLogger;
34 | import org.junit.AfterClass;
35 | import org.junit.BeforeClass;
36 | import org.junit.Test;
37 |
38 | public class FileReaderTest {
39 | Logger logger = Logger.getLogger(FileReaderTest.class);
40 |
41 | @BeforeClass
42 | public static void setUpBeforeClass() throws Exception {
43 | BasicConfigurator.configure();
44 | RootLogger.getRootLogger().setLevel(TRACE);
45 | }
46 |
47 | @AfterClass
48 | public static void tearDownAfterClass() throws Exception {
49 | BasicConfigurator.resetConfiguration();
50 | }
51 |
52 | @Test
53 | public void testFileReader1() throws IOException, InterruptedException, AdapterException {
54 | FileReader reader = new FileReader(2);
55 | reader.setAdapter(new MockProtocolAdapter());
56 | List