public RandomAccessFileOrArray(String filename) throws IOException 
{
         
    	this(filename, false, Document.plainRandomAccess);
}

 public RandomAccessFileOrArray(URL url) throws IOException 
{
        InputStream is = url.openStream();
        try {
            this.arrayIn = InputStreamToArray(is);
        }
        finally {
            try {is.close();}catch(IOException ioe){}
        }
}

 public RandomAccessFileOrArray(InputStream is) throws IOException 
{
        this.arrayIn = InputStreamToArray(is);
}

 public RandomAccessFileOrArray(byte[] arrayIn) 
{
        this.arrayIn = arrayIn;
}

 public RandomAccessFileOrArray(RandomAccessFileOrArray file) 
{
        filename = file.filename;
        arrayIn = file.arrayIn;
        startOffset = file.startOffset;
        plainRandomAccess = file.plainRandomAccess;
}

 public RandomAccessFileOrArray(String filename,
    boolean forceRead,
    boolean plainRandomAccess) throws IOException 
{
        this.plainRandomAccess = plainRandomAccess;
        File file = new File(filename);
        if (!file.canRead()) {
            if (filename.startsWith("file:/") || filename.startsWith("http://") || filename.startsWith("https://") || filename.startsWith("jar:")) {
                InputStream is = new URL(filename).openStream();
                try {
                    this.arrayIn = InputStreamToArray(is);
                    return;
                }
                finally {
                    try {is.close();}catch(IOException ioe){}
                }
            }
            else {
                InputStream is = BaseFont.getResourceStream(filename);
                if (is == null)
                    throw new IOException(filename + " not found as file or resource.");
                try {
                    this.arrayIn = InputStreamToArray(is);
                    return;
                }
                finally {
                    try {is.close();}catch(IOException ioe){}
                }
            }
        }
        else if (forceRead) {
            InputStream s = null;
            try {
                s = new FileInputStream(file);
                this.arrayIn = InputStreamToArray(s);
            }
            finally {
                try {if (s != null) {s.close();}}catch(Exception e){}
            }
        	return;
        }
        this.filename = filename;
        if (plainRandomAccess)
            trf = new RandomAccessFile(filename, "r");
        else
            rf = new MappedRandomAccessFile(filename, "r");
}

 public static byte[] InputStreamToArray(InputStream is) throws IOException 
{
        byte b[] = new byte[8192];
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        while (true) {
            int read = is.read(b);
            if (read <  1)
                break;
            out.write(b, 0, read);
        }
        out.close();
        return out.toByteArray();
}

 public  void close() throws IOException 
{
        isBack = false;
        if (rf != null) {
            rf.close();
            rf = null;
            // it's very expensive to open a memory mapped file and for the usage pattern of this class
            // in iText it's faster the next re-openings to be done as a plain random access
            // file
            plainRandomAccess = true;
        }
        else if (trf != null) {
            trf.close();
            trf = null;
        }
}

 public int getFilePointer() throws IOException 
{
        insureOpen();
        int n = isBack ? 1 : 0;
        if (arrayIn == null) {
            return (int)(plainRandomAccess ? trf.getFilePointer() : rf.getFilePointer()) - n - startOffset;
        }
        else
            return arrayInPtr - n - startOffset;
}

 public ByteBuffer getNioByteBuffer() throws IOException 
{
    	if (filename != null) {
    		FileChannel channel;
            if (plainRandomAccess)
                channel = trf.getChannel();
            else
                channel = rf.getChannel();
            return channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
    	}
    	return java.nio.ByteBuffer.wrap(arrayIn);
}

 public int getStartOffset() 
{
        return this.startOffset;
}

Getter for property startOffset.

 protected  void insureOpen() throws IOException 
{
        if (filename != null && rf == null && trf == null) {
            reOpen();
        }
}

 public boolean isOpen() 
{
        return (filename == null || rf != null || trf != null);
}

 public int length() throws IOException 
{
        if (arrayIn == null) {
            insureOpen();
            return (int)(plainRandomAccess ? trf.length() : rf.length()) - startOffset;
        }
        else
            return arrayIn.length - startOffset;
}

 public  void pushBack(byte b) 
{
        back = b;
        isBack = true;
}

 public  void reOpen() throws IOException 
{
        if (filename != null && rf == null && trf == null) {
            if (plainRandomAccess)
                trf = new RandomAccessFile(filename, "r");
            else
                rf = new MappedRandomAccessFile(filename, "r");
        }
        seek(0);
}

 public int read() throws IOException 
{
        if(isBack) {
            isBack = false;
            return back & 0xff;
        }
        if (arrayIn == null)
            return plainRandomAccess ? trf.read() : rf.read();
        else {
            if (arrayInPtr  >= arrayIn.length)
                return -1;
            return arrayIn[arrayInPtr++] & 0xff;
        }
}

 public int read(byte[] b) throws IOException 
{
        return read(b, 0, b.length);
}

 public int read(byte[] b,
    int off,
    int len) throws IOException 
{
        if (len == 0)
            return 0;
        int n = 0;
        if (isBack) {
            isBack = false;
            if (len == 1) {
                b[off] = back;
                return 1;
            }
            else {
                n = 1;
                b[off++] = back;
                --len;
            }
        }
        if (arrayIn == null) {
            return (plainRandomAccess ? trf.read(b, off, len) : rf.read(b, off, len)) + n;
        }
        else {
            if (arrayInPtr  >= arrayIn.length)
                return -1;
            if (arrayInPtr + len  > arrayIn.length)
                len = arrayIn.length - arrayInPtr;
            System.arraycopy(arrayIn, arrayInPtr, b, off, len);
            arrayInPtr += len;
            return len + n;
        }
}

 public boolean readBoolean() throws IOException 
{
        int ch = this.read();
        if (ch <  0)
            throw new EOFException();
        return (ch != 0);
}

 public byte readByte() throws IOException 
{
        int ch = this.read();
        if (ch <  0)
            throw new EOFException();
        return (byte)(ch);
}

 public char readChar() throws IOException 
{
        int ch1 = this.read();
        int ch2 = this.read();
        if ((ch1 | ch2) <  0)
            throw new EOFException();
        return (char)((ch1 < <  8) + ch2);
}

 public final char readCharLE() throws IOException 
{
        int ch1 = this.read();
        int ch2 = this.read();
        if ((ch1 | ch2) <  0)
            throw new EOFException();
        return (char)((ch2 < <  8) + (ch1 < <  0));
}

Reads a Unicode character from this stream in little-endian order. This method reads two bytes from the stream, starting at the current stream pointer. If the bytes read, in order, are b1 and b2, where 0 <= b1, b2 <= 255, then the result is equal to:

(char)((b2 << 8) | b1)

This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown.

 public double readDouble() throws IOException 
{
        return Double.longBitsToDouble(readLong());
}

 public final double readDoubleLE() throws IOException 
{
        return Double.longBitsToDouble(readLongLE());
}

 public float readFloat() throws IOException 
{
        return Float.intBitsToFloat(readInt());
}

 public final float readFloatLE() throws IOException 
{
        return Float.intBitsToFloat(readIntLE());
}

 public  void readFully(byte[] b) throws IOException 
{
        readFully(b, 0, b.length);
}

 public  void readFully(byte[] b,
    int off,
    int len) throws IOException 
{
        int n = 0;
        do {
            int count = read(b, off + n, len - n);
            if (count <  0)
                throw new EOFException();
            n += count;
        } while (n <  len);
}

 public int readInt() throws IOException 
{
        int ch1 = this.read();
        int ch2 = this.read();
        int ch3 = this.read();
        int ch4 = this.read();
        if ((ch1 | ch2 | ch3 | ch4) <  0)
            throw new EOFException();
        return ((ch1 < <  24) + (ch2 < <  16) + (ch3 < <  8) + ch4);
}

 public final int readIntLE() throws IOException 
{
        int ch1 = this.read();
        int ch2 = this.read();
        int ch3 = this.read();
        int ch4 = this.read();
        if ((ch1 | ch2 | ch3 | ch4) <  0)
            throw new EOFException();
        return ((ch4 < <  24) + (ch3 < <  16) + (ch2 < <  8) + (ch1 < <  0));
}

Reads a signed 32-bit integer from this stream in little-endian order. This method reads 4 bytes from the stream, starting at the current stream pointer. If the bytes read, in order, are b1, b2, b3, and b4, where 0 <= b1, b2, b3, b4 <= 255, then the result is equal to:

(b4 << 24) | (b3 << 16) + (b2 << 8) + b1

This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown.

 public String readLine() throws IOException 
{
        StringBuffer input = new StringBuffer();
        int c = -1;
        boolean eol = false;
        while (!eol) {
            switch (c = read()) {
                case -1:
                case '\n":
                    eol = true;
                    break;
                case '\r":
                    eol = true;
                    int cur = getFilePointer();
                    if ((read()) != '\n") {
                        seek(cur);
                    }
                    break;
                default:
                    input.append((char)c);
                    break;
            }
        }
        if ((c == -1) && (input.length() == 0)) {
            return null;
        }
        return input.toString();
}

 public long readLong() throws IOException 
{
        return ((long)(readInt()) < <  32) + (readInt() & 0xFFFFFFFFL);
}

 public final long readLongLE() throws IOException 
{
        int i1 = readIntLE();
        int i2 = readIntLE();
        return ((long)i2 < <  32) + (i1 & 0xFFFFFFFFL);
}

 public short readShort() throws IOException 
{
        int ch1 = this.read();
        int ch2 = this.read();
        if ((ch1 | ch2) <  0)
            throw new EOFException();
        return (short)((ch1 < <  8) + ch2);
}

 public final short readShortLE() throws IOException 
{
        int ch1 = this.read();
        int ch2 = this.read();
        if ((ch1 | ch2) <  0)
            throw new EOFException();
        return (short)((ch2 < <  8) + (ch1 < <  0));
}

Reads a signed 16-bit number from this stream in little-endian order. The method reads two bytes from this stream, starting at the current stream pointer. If the two bytes read, in order, are b1 and b2, where each of the two values is between 0 and 255, inclusive, then the result is equal to:

(short)((b2 << 8) | b1)

This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown.

 public String readUTF() throws IOException 
{
        return DataInputStream.readUTF(this);
}

 public int readUnsignedByte() throws IOException 
{
        int ch = this.read();
        if (ch <  0)
            throw new EOFException();
        return ch;
}

 public final long readUnsignedInt() throws IOException 
{
        long ch1 = this.read();
        long ch2 = this.read();
        long ch3 = this.read();
        long ch4 = this.read();
        if ((ch1 | ch2 | ch3 | ch4) <  0)
            throw new EOFException();
        return ((ch1 < <  24) + (ch2 < <  16) + (ch3 < <  8) + (ch4 < <  0));
}

Reads an unsigned 32-bit integer from this stream. This method reads 4 bytes from the stream, starting at the current stream pointer. If the bytes read, in order, are b1, b2, b3, and b4, where 0 <= b1, b2, b3, b4 <= 255, then the result is equal to:

(b1 << 24) | (b2 << 16) + (b3 << 8) + b4

This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown.

 public final long readUnsignedIntLE() throws IOException 
{
        long ch1 = this.read();
        long ch2 = this.read();
        long ch3 = this.read();
        long ch4 = this.read();
        if ((ch1 | ch2 | ch3 | ch4) <  0)
            throw new EOFException();
        return ((ch4 < <  24) + (ch3 < <  16) + (ch2 < <  8) + (ch1 < <  0));
}

 public int readUnsignedShort() throws IOException 
{
        int ch1 = this.read();
        int ch2 = this.read();
        if ((ch1 | ch2) <  0)
            throw new EOFException();
        return (ch1 < <  8) + ch2;
}

 public final int readUnsignedShortLE() throws IOException 
{
        int ch1 = this.read();
        int ch2 = this.read();
        if ((ch1 | ch2) <  0)
            throw new EOFException();
        return (ch2 < <  8) + (ch1 < <  0);
}

Reads an unsigned 16-bit number from this stream in little-endian order. This method reads two bytes from the stream, starting at the current stream pointer. If the bytes read, in order, are b1 and b2, where 0 <= b1, b2 <= 255, then the result is equal to:

(b2 << 8) | b1

This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown.

 public  void seek(int pos) throws IOException 
{
        pos += startOffset;
        isBack = false;
        if (arrayIn == null) {
            insureOpen();
            if (plainRandomAccess)
                trf.seek(pos);
            else
                rf.seek(pos);
        }
        else
            arrayInPtr = pos;
}

 public  void seek(long pos) throws IOException 
{
        seek((int)pos);
}

 public  void setStartOffset(int startOffset) 
{
        this.startOffset = startOffset;
}

Setter for property startOffset.

 public long skip(long n) throws IOException 
{
        return skipBytes((int)n);
}

 public int skipBytes(int n) throws IOException 
{
        if (n < = 0) {
            return 0;
        }
        int adj = 0;
        if (isBack) {
            isBack = false;
            if (n == 1) {
                return 1;
            }
            else {
                --n;
                adj = 1;
            }
        }
        int pos;
        int len;
        int newpos;
        pos = getFilePointer();
        len = length();
        newpos = pos + n;
        if (newpos  > len) {
            newpos = len;
        }
        seek(newpos);
        /* return the actual number of bytes skipped */
        return newpos - pos + adj;
}