protected Reader() 
{
        super();
        lock = this;
}

Constructs a new {@code Reader} with {@code this} as the object used to synchronize critical sections.

 protected Reader(Object lock) 
{
        if (lock == null) {
            throw new NullPointerException();
        }
        this.lock = lock;
}

Constructs a new {@code Reader} with {@code lock} used to synchronize critical sections.

Parameters:

lock - the {@code Object} used to synchronize critical sections.

Throws:

NullPointerException - if {@code lock} is {@code null}.

 abstract public  void close() throws IOException
Closes this reader. Implementations of this method should free any
resources associated with the reader.

 public  void mark(int readLimit) throws IOException 
{
        throw new IOException();
}

Sets a mark position in this reader. The parameter {@code readLimit} indicates how many characters can be read before the mark is invalidated. Calling {@code reset()} will reposition the reader back to the marked position if {@code readLimit} has not been surpassed.

This default implementation simply throws an {@code IOException}; subclasses must provide their own implementation.

 public boolean markSupported() 
{
        return false;
}

Indicates whether this reader supports the {@code mark()} and {@code reset()} methods. This default implementation returns {@code false}.

 public int read() throws IOException 
{
        synchronized (lock) {
            char charArray[] = new char[1];
            if (read(charArray, 0, 1) != -1) {
                return charArray[0];
            }
            return -1;
        }
}

Reads a single character from this reader and returns it as an integer with the two higher-order bytes set to 0. Returns -1 if the end of the reader has been reached.

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

Reads characters from this reader and stores them in the character array {@code buf} starting at offset 0. Returns the number of characters actually read or -1 if the end of the reader has been reached.

 public int read(CharBuffer target) throws IOException 
{
        if (null == target) {
            throw new NullPointerException();
        }
        int length = target.length();
        char[] buf = new char[length];
        length = Math.min(length, read(buf));
        if (length  > 0) {
            target.put(buf, 0, length);
        }
        return length;
}

Reads characters and puts them into the {@code target} character buffer.

 abstract public int read(char[] buf,
    int offset,
    int count) throws IOException
Reads at most {@code count} characters from this reader and stores them
at {@code offset} in the character array {@code buf}. Returns the number
of characters actually read or -1 if the end of the reader has been
reached.

 public boolean ready() throws IOException 
{
        return false;
}

Indicates whether this reader is ready to be read without blocking. Returns {@code true} if this reader will not block when {@code read} is called, {@code false} if unknown or blocking will occur. This default implementation always returns {@code false}.

 public  void reset() throws IOException 
{
        throw new IOException();
}

Resets this reader's position to the last {@code mark()} location. Invocations of {@code read()} and {@code skip()} will occur from this new location. If this reader has not been marked, the behavior of {@code reset()} is implementation specific. This default implementation throws an {@code IOException}.

 public long skip(long count) throws IOException 
{
        if (count <  0) {
            throw new IllegalArgumentException();
        }
        synchronized (lock) {
            long skipped = 0;
            int toRead = count <  512 ? (int) count : 512;
            char charsSkipped[] = new char[toRead];
            while (skipped <  count) {
                int read = read(charsSkipped, 0, toRead);
                if (read == -1) {
                    return skipped;
                }
                skipped += read;
                if (read <  toRead) {
                    return skipped;
                }
                if (count - skipped <  toRead) {
                    toRead = (int) (count - skipped);
                }
            }
            return skipped;
        }
}

Skips {@code amount} characters in this reader. Subsequent calls of {@code read} methods will not return these characters unless {@code reset()} is used. This method may perform multiple reads to read {@code count} characters.