@Override public void flush() throws IOException { super.flush(); }
/** * Flushes this stream to ensure all pending data is sent out to the target * stream. This implementation then also flushes the target stream. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public void flush() throws IOException { super.flush(); }
public void close() throws IOException { super.flush(); } };
public void close() throws IOException { super.flush(); } };
@Override public void flush() throws IOException { super.flush(); OutputStream os = this.branch; if (os != null) { os.flush(); } }
@Override public void flush() throws IOException { try { super.flush(); } catch (IOException e) { throw propagateIOException(e); } }
@Override public void flush() throws IOException { completeCrLf(); super.flush(); }
/** * To flush, we need to encrypt the data in the buffer and write to the * underlying stream, then do the flush. */ @Override public synchronized void flush() throws IOException { if (closed) { return; } encrypt(); super.flush(); }
/** * Closes this stream. This implementation closes the target stream. * * @throws IOException * if an error occurs attempting to close this stream. */ @Override public void close() throws IOException { Throwable thrown = null; try { flush(); } catch (Throwable e) { thrown = e; } try { out.close(); } catch (Throwable e) { if (thrown == null) { thrown = e; } } if (thrown != null) { SneakyThrow.sneakyThrow(thrown); } }
@Override public void close() throws IOException { try { super.flush(); lock.releaseLock(); super.close(); } catch(IOException iex) { if (lock.isValid()) { lock.releaseLock(); } throw iex; } } };
public void endWithCrLfAndFlush() throws IOException { completeCrLf(); if (lastByte != LF) { writeByte(CR); writeByte(LF); } super.flush(); }
@Override public void flush() throws IOException { // The last row is allowed to be incomplete, and should be completed with zeros. if (currentRowData > 0) { Arrays.fill(currentRow, currentRowData, rowLength, (byte)0); decodeAndWriteRow(); } super.flush(); }
/** * Flushes the stream (and the enclosing streams). * @throws java.io.IOException * @since 2.3 */ @Override public void flush() throws java.io.IOException { flushBase64(); super.flush(); }
public void flush() throws IOException { encodeBuffer(); super.flush(); }
lineBreak = maxline; flushed = true; super.flush();
/** * Flushes this stream to ensure all pending data is sent out to the target * stream. This implementation then also flushes the target stream. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public void flush() throws IOException { super.flush(); }
@Override public void close() throws IOException { super.flush(); } };
@Override public void close() throws IOException { //do not close the parent output stream! super.flush(); } });
@Override public void flush() throws IOException { final OutputStream out = getThreadLocalOutputStream(); if (out == null || out == this) { super.flush(); } else { out.flush(); } }
@Override public void flush() throws IOException { try { super.flush(); } catch (IOException e) { throw propagateIOException(e); } }