How to use

reset

method

in

java.io.BufferedReader

/**
 * Resets the stream to the most recent mark.
 */
@Override
public void reset() throws IOException {
  line = lineMark;
  column = columnMark;
  super.reset();
}

/**
 * Resets this reader to the last marked location. It also resets the line
 * count to what is was when this reader was marked. This implementation
 * resets the source reader.
 *
 * @throws IOException
 *             if this reader is already closed, no mark has been set or the
 *             mark is no longer valid because more than {@code readlimit}
 *             bytes have been read since setting the mark.
 * @see #mark(int)
 * @see #markSupported()
 */
@Override
public void reset() throws IOException {
  synchronized (lock) {
    super.reset();
    lineNumber = markedLineNumber;
    lastWasCR = markedLastWasCR;
  }
}

public void load (BufferedReader reader) throws IOException {
  super.load(reader);
  // For backwards compatibility, independent property may not be defined
  reader.mark(100);
  String line = reader.readLine();
  if (line == null) throw new IOException("Missing value: " + "independent");
  if (line.contains("independent"))
    independent = Boolean.parseBoolean(readString(line));
  else
    reader.reset();
}

public void load (BufferedReader reader) throws IOException {
  super.load(reader);
  // For backwards compatibility, independent property may not be defined
  reader.mark(100);
  String line = reader.readLine();
  if (line == null) throw new IOException("Missing value: " + "independent");
  if (line.contains("independent"))
    independent = Boolean.parseBoolean(readString(line));
  else
    reader.reset();
}

/**
 * Whether or not any more data can be read from this data source.
 * 
 * @return true if another call to getData() will return data, false otherwise.
 */
public boolean hasMoreData() {
  int c = -1;
  try {
    reader.mark(10);
    c = reader.read();
    reader.reset();
  } catch (IOException ioe) {
    ioe.printStackTrace();
  }
  return c != -1;
}

public static List<SemgrexPattern> compileStream(InputStream is, Env env) throws IOException {
 BufferedReader reader = new BufferedReader(new InputStreamReader(is));
 reader.mark(MAX_STREAM_SIZE);
 Map<String, String> macros = preprocess(reader);
 reader.reset();
 return parse(reader, macros, env);
}

/**
 * Whether or not any more data can be read from this data source.
 * 
 * @return true if another call to getData() will return data, false otherwise.
 */
public boolean hasMoreData() {
  int c = -1;
  try {
    reader.mark(10);
    c = reader.read();
    reader.reset();
  } catch (IOException ioe) {
    ioe.printStackTrace();
  }
  return c != -1;
}

public boolean readOptionalConstantLine(String constantRegex) throws IOException {
  bufferedReader.mark(1024);
  boolean valid = true;
  String line = bufferedReader.readLine();
  if (line == null) {
    valid = false;
  } else {
    String value = line.trim();
    if (!value.matches(constantRegex)) {
      valid = false;
    }
  }
  if (!valid) {
    bufferedReader.reset();
  }
  return valid;
}

/**
 * Determine if a given BufferedReader appears to be in ASCII format.
 *
 * @param buffer
 * @return
 * @throws IOException
 */
public static final boolean isASCII(BufferedReader buffer) throws IOException {
  final char[] readAhead = new char[300];
  buffer.mark(readAhead.length);
  buffer.read(readAhead, 0, readAhead.length);
  buffer.reset();
  final String readAheadString = new String(readAhead);
  // If the following text is present, then this is likely an ascii file
  return readAheadString.contains("facet normal") && readAheadString.contains("outer loop");
  // Likely a binary file
}

/** create a stack with the given initial lines, reading the rest from the Reader */
ThreadStack(String firstLine, String secondLine, String thirdLine, BufferedReader reader)
  throws IOException {
 lines.add(firstLine);
 lines.add(secondLine);
 runnable = secondLine.contains("RUNNABLE");
 lines.add(thirdLine);
 String line = null;
 do {
  reader.mark(100000);
  line = reader.readLine();
  if (line == null || line.trim().length() == 0) {
   break;
  }
  if (line.startsWith("\"")) {
   reader.reset();
   break;
  }
  lines.add(line);
 } while (true);
}

private void skipBom() {
  boolean skip = false;
  try {
    if (charset.equals(UTF_8)) {
      reader.mark(3);
      int firstChar = reader.read();
      if (firstChar == 0xFEFF) {
        // skip BOM bytes
        skip = true;
      }
    }
  } catch (IOException ex) {
    // Passing through intentionally.
  } finally {
    if (skip) {
      // firstChar is skipped
    } else {
      // rollback to the marked position
      try {
        reader.reset();
      } catch (IOException ex) {
        // unexpected
        throw new RuntimeException(ex);
      }
    }
  }
}

public String readOptionalStringValue(String prefixRegex, String suffixRegex, String defaultValue) throws IOException {
  bufferedReader.mark(1024);
  boolean valid = true;
  String value = bufferedReader.readLine();
  if (value == null) {
    valid = false;
  } else {
    value = value.trim();
    if (value.matches("^" + prefixRegex + ".*")) {
      value = value.replaceAll("^" + prefixRegex + "(.*)", "$1");
    } else {
      valid = false;
    }
    if (value.matches(".*" + suffixRegex + "$")) {
      value = value.replaceAll("(.*)" + suffixRegex + "$", "$1");
    } else {
      valid = false;
    }
  }
  if (!valid) {
    bufferedReader.reset();
    return defaultValue;
  }
  value = value.trim();
  return value;
}

input.reset();

reader.reset();

reader.reset();

reader.reset();

    return ValueLobDb.createSmallLob(Value.CLOB, small, len);
  reader.reset();
  return new ValueLobDb(handler, reader, remaining);
} catch (IOException e) {

  return ValueLob.createSmallLob(type, utf8);
b.reset();
reader = b;

input.reset();

@Test
public void testMarkResetWithLineEnding() throws Exception {
  SimpleBinaryBufferedReaderFactory factory = new SimpleBinaryBufferedReaderFactory();
  factory.setLineEnding("||");
  @SuppressWarnings("resource")
  BufferedReader reader = factory.create(new ByteArrayResource("a||b||c".getBytes()), "UTF-8");
  assertEquals("a", reader.readLine());
  reader.mark(1024);
  assertEquals("b", reader.readLine());
  reader.reset();
  assertEquals("b", reader.readLine());
  assertEquals("c", reader.readLine());
  assertEquals(null, reader.readLine());
}