How to use

ensureOpen

method

in

java.io.BufferedReader

/**
 * Resets the stream to the most recent mark.
 *
 * @exception  IOException  If the stream has never been marked,
 *                          or if the mark has been invalidated
 */
public void reset() throws IOException {
  synchronized (lock) {
    ensureOpen();
    if (markedChar < 0)
      throw new IOException((markedChar == INVALIDATED)
                 ? "Mark invalid"
                 : "Stream not marked");
    nextChar = markedChar;
    skipLF = markedSkipLF;
  }
}

/**
 * Resets the stream to the most recent mark.
 *
 * @exception  IOException  If the stream has never been marked,
 *                          or if the mark has been invalidated
 */
public void reset() throws IOException {
  synchronized (lock) {
    ensureOpen();
    if (markedChar < 0)
      throw new IOException((markedChar == INVALIDATED)
                 ? "Mark invalid"
                 : "Stream not marked");
    nextChar = markedChar;
    skipLF = markedSkipLF;
  }
}

/**
 * Marks the present position in the stream.  Subsequent calls to reset()
 * will attempt to reposition the stream to this point.
 *
 * @param readAheadLimit   Limit on the number of characters that may be
 *                         read while still preserving the mark. An attempt
 *                         to reset the stream after reading characters
 *                         up to this limit or beyond may fail.
 *                         A limit value larger than the size of the input
 *                         buffer will cause a new buffer to be allocated
 *                         whose size is no smaller than limit.
 *                         Therefore large values should be used with care.
 *
 * @exception  IllegalArgumentException  If readAheadLimit is < 0
 * @exception  IOException  If an I/O error occurs
 */
public void mark(int readAheadLimit) throws IOException {
  if (readAheadLimit < 0) {
    throw new IllegalArgumentException("Read-ahead limit < 0");
  }
  synchronized (lock) {
    ensureOpen();
    this.readAheadLimit = readAheadLimit;
    markedChar = nextChar;
    markedSkipLF = skipLF;
  }
}

/**
 * Marks the present position in the stream.  Subsequent calls to reset()
 * will attempt to reposition the stream to this point.
 *
 * @param readAheadLimit   Limit on the number of characters that may be
 *                         read while still preserving the mark. An attempt
 *                         to reset the stream after reading characters
 *                         up to this limit or beyond may fail.
 *                         A limit value larger than the size of the input
 *                         buffer will cause a new buffer to be allocated
 *                         whose size is no smaller than limit.
 *                         Therefore large values should be used with care.
 *
 * @exception  IllegalArgumentException  If readAheadLimit is < 0
 * @exception  IOException  If an I/O error occurs
 */
public void mark(int readAheadLimit) throws IOException {
  if (readAheadLimit < 0) {
    throw new IllegalArgumentException("Read-ahead limit < 0");
  }
  synchronized (lock) {
    ensureOpen();
    this.readAheadLimit = readAheadLimit;
    markedChar = nextChar;
    markedSkipLF = skipLF;
  }
}

/**
 * Reads a single character.
 *
 * @return The character read, as an integer in the range
 *         0 to 65535 (<tt>0x00-0xffff</tt>), or -1 if the
 *         end of the stream has been reached
 * @exception  IOException  If an I/O error occurs
 */
public int read() throws IOException {
  synchronized (lock) {
    ensureOpen();
    for (;;) {
      if (nextChar >= nChars) {
        fill();
        if (nextChar >= nChars)
          return -1;
      }
      if (skipLF) {
        skipLF = false;
        if (cb[nextChar] == '\n') {
          nextChar++;
          continue;
        }
      }
      return cb[nextChar++];
    }
  }
}

/**
 * Tells whether this stream is ready to be read.  A buffered character
 * stream is ready if the buffer is not empty, or if the underlying
 * character stream is ready.
 *
 * @exception  IOException  If an I/O error occurs
 */
public boolean ready() throws IOException {
  synchronized (lock) {
    ensureOpen();
    /*
     * If newline needs to be skipped and the next char to be read
     * is a newline character, then just skip it right away.
     */
    if (skipLF) {
      /* Note that in.ready() will return true if and only if the next
       * read on the stream will not block.
       */
      if (nextChar >= nChars && in.ready()) {
        fill();
      }
      if (nextChar < nChars) {
        if (cb[nextChar] == '\n')
          nextChar++;
        skipLF = false;
      }
    }
    return (nextChar < nChars) || in.ready();
  }
}

/**
 * Reads a single character.
 *
 * @return The character read, as an integer in the range
 *         0 to 65535 (<tt>0x00-0xffff</tt>), or -1 if the
 *         end of the stream has been reached
 * @exception  IOException  If an I/O error occurs
 */
public int read() throws IOException {
  synchronized (lock) {
    ensureOpen();
    for (;;) {
      if (nextChar >= nChars) {
        fill();
        if (nextChar >= nChars)
          return -1;
      }
      if (skipLF) {
        skipLF = false;
        if (cb[nextChar] == '\n') {
          nextChar++;
          continue;
        }
      }
      return cb[nextChar++];
    }
  }
}

/**
 * Tells whether this stream is ready to be read.  A buffered character
 * stream is ready if the buffer is not empty, or if the underlying
 * character stream is ready.
 *
 * @exception  IOException  If an I/O error occurs
 */
public boolean ready() throws IOException {
  synchronized (lock) {
    ensureOpen();
    /*
     * If newline needs to be skipped and the next char to be read
     * is a newline character, then just skip it right away.
     */
    if (skipLF) {
      /* Note that in.ready() will return true if and only if the next
       * read on the stream will not block.
       */
      if (nextChar >= nChars && in.ready()) {
        fill();
      }
      if (nextChar < nChars) {
        if (cb[nextChar] == '\n')
          nextChar++;
        skipLF = false;
      }
    }
    return (nextChar < nChars) || in.ready();
  }
}

ensureOpen();
long r = n;
while (r > 0) {

ensureOpen();
long r = n;
while (r > 0) {

ensureOpen();
boolean omitLF = ignoreLF || skipLF;

ensureOpen();
boolean omitLF = ignoreLF || skipLF;

ensureOpen();
boolean omitLF = ignoreLF || skipLF;

ensureOpen();
if ((off < 0) || (off > cbuf.length) || (len < 0) ||
  ((off + len) > cbuf.length) || ((off + len) < 0)) {

ensureOpen();
if ((off < 0) || (off > cbuf.length) || (len < 0) ||
  ((off + len) > cbuf.length) || ((off + len) < 0)) {