/** * 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. */ @Override public void mark(int readAheadLimit) throws IOException { lineMark = line; columnMark = column; super.mark(readAheadLimit); }
/** * Sets a mark position in this reader. The parameter {@code readlimit} * indicates how many characters can be read before the mark is invalidated. * Sending {@code reset()} will reposition this reader back to the marked * position, provided that {@code readlimit} has not been surpassed. The * line number associated with this marked position is also stored so that * it can be restored when {@code reset()} is called. * * @param readlimit * the number of characters that can be read from this stream * before the mark is invalidated. * @throws IOException * if an error occurs while setting the mark in this reader. * @see #markSupported() * @see #reset() */ @Override public void mark(int readlimit) throws IOException { synchronized (lock) { super.mark(readlimit); markedLineNumber = lineNumber; markedLastWasCR = lastWasCR; } }
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; }
BufferedReader reader = new BufferedReader(new InputStreamReader(in, charset)); reader.mark(1); if (reader.read() != UTF8_BOM) { reader.reset();
BufferedReader reader = new BufferedReader(new InputStreamReader(in, charset)); reader.mark(1); if (reader.read() != UTF8_BOM) { reader.reset();
} else { buff = new char[len]; reader.mark(len); len = IOUtils.readFully(reader, buff, len);
} else { buff = new char[len]; reader.mark(len); len = IOUtils.readFully(reader, buff, len);
public void testParseXML() throws Exception { URL url = getClass().getResource("applicationContext.xml"); FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext(url.toString()); Dispatcher dispatcher = (Dispatcher) context.getBean("dispatcher"); String body = "<Hello service=\"hello\" message=\"Hello world!\"/>"; File file = File.createTempFile("geoserver", "req"); try { FileOutputStream output = new FileOutputStream(file); output.write(body.getBytes()); output.flush(); output.close(); BufferedReader input = new BufferedReader(new InputStreamReader(new FileInputStream(file))); input.mark(8192); Request req = new Request(); req.setInput(input); Object object = dispatcher.parseRequestXML(null, input, req); assertEquals(new Message("Hello world!"), object); } finally { file.delete(); } }
if (max != 0 && max < Integer.MAX_VALUE) { BufferedReader b = new BufferedReader(reader, max); b.mark(max); char[] small = new char[max]; int len = IOUtils.readFully(b, small, max);
public void testReadOpPost() throws Exception { MockHttpServletRequest request = new MockHttpServletRequest(); request.setContextPath("/geoserver"); request.setRequestURI("/geoserver/hello"); request.setMethod("post"); String body = "<Hello service=\"hello\"/>"; DelegatingServletInputStream input = new DelegatingServletInputStream(new ByteArrayInputStream(body.getBytes())); Dispatcher dispatcher = new Dispatcher(); BufferedReader buffered = new BufferedReader(new InputStreamReader(input)); buffered.mark(2048); Map map = dispatcher.readOpPost(buffered); assertNotNull(map); assertEquals("Hello", map.get("request")); assertEquals("hello", map.get("service")); }
@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()); }