/** * Writes one byte to this stream. Only the low order byte of the integer * {@code oneByte} is written. If there is room in the buffer, the byte is * copied into the buffer and the count incremented. Otherwise, the buffer * plus {@code oneByte} are written to the target stream, the target is * flushed, and the buffer is reset. * * @param oneByte * the byte to be written. * @throws IOException * if an error occurs attempting to write to this stream. */ @Override public synchronized void write(int oneByte) throws IOException { checkNotClosed(); if (count == buf.length) { out.write(buf, 0, count); count = 0; } buf[count++] = (byte) oneByte; }
/** * Flushes this stream to ensure all pending data is written out to the * target stream. In addition, the target stream is flushed. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public synchronized void flush() throws IOException { checkNotClosed(); flushInternal(); out.flush(); }
/** * Writes one byte to this stream. Only the low order byte of the integer * {@code oneByte} is written. If there is room in the buffer, the byte is * copied into the buffer and the count incremented. Otherwise, the buffer * plus {@code oneByte} are written to the target stream, the target is * flushed, and the buffer is reset. * * @param oneByte * the byte to be written. * @throws IOException * if an error occurs attempting to write to this stream. */ @Override public synchronized void write(int oneByte) throws IOException { checkNotClosed(); if (count == buf.length) { out.write(buf, 0, count); count = 0; } buf[count++] = (byte) oneByte; }
/** * Writes one byte to this stream. Only the low order byte of the integer * {@code oneByte} is written. If there is room in the buffer, the byte is * copied into the buffer and the count incremented. Otherwise, the buffer * plus {@code oneByte} are written to the target stream, the target is * flushed, and the buffer is reset. * * @param oneByte * the byte to be written. * @throws IOException * if an error occurs attempting to write to this stream. */ @Override public synchronized void write(int oneByte) throws IOException { checkNotClosed(); if (count == buf.length) { out.write(buf, 0, count); count = 0; } buf[count++] = (byte) oneByte; }
/** * Writes one byte to this stream. Only the low order byte of the integer * {@code oneByte} is written. If there is room in the buffer, the byte is * copied into the buffer and the count incremented. Otherwise, the buffer * plus {@code oneByte} are written to the target stream, the target is * flushed, and the buffer is reset. * * @param oneByte * the byte to be written. * @throws IOException * if an error occurs attempting to write to this stream. */ @Override public synchronized void write(int oneByte) throws IOException { checkNotClosed(); if (count == buf.length) { out.write(buf, 0, count); count = 0; } buf[count++] = (byte) oneByte; }
/** * Writes one byte to this stream. Only the low order byte of the integer * {@code oneByte} is written. If there is room in the buffer, the byte is * copied into the buffer and the count incremented. Otherwise, the buffer * plus {@code oneByte} are written to the target stream, the target is * flushed, and the buffer is reset. * * @param oneByte * the byte to be written. * @throws IOException * if an error occurs attempting to write to this stream. */ @Override public synchronized void write(int oneByte) throws IOException { checkNotClosed(); if (count == buf.length) { out.write(buf, 0, count); count = 0; } buf[count++] = (byte) oneByte; }
/** * Writes one byte to this stream. Only the low order byte of the integer * {@code oneByte} is written. If there is room in the buffer, the byte is * copied into the buffer and the count incremented. Otherwise, the buffer * plus {@code oneByte} are written to the target stream, the target is * flushed, and the buffer is reset. * * @param oneByte * the byte to be written. * @throws IOException * if an error occurs attempting to write to this stream. */ @Override public synchronized void write(int oneByte) throws IOException { checkNotClosed(); if (count == buf.length) { out.write(buf, 0, count); count = 0; } buf[count++] = (byte) oneByte; }
/** * Writes one byte to this stream. Only the low order byte of the integer * {@code oneByte} is written. If there is room in the buffer, the byte is * copied into the buffer and the count incremented. Otherwise, the buffer * plus {@code oneByte} are written to the target stream, the target is * flushed, and the buffer is reset. * * @param oneByte * the byte to be written. * @throws IOException * if an error occurs attempting to write to this stream. */ @Override public synchronized void write(int oneByte) throws IOException { checkNotClosed(); if (count == buf.length) { out.write(buf, 0, count); count = 0; } buf[count++] = (byte) oneByte; }
/** * Writes one byte to this stream. Only the low order byte of the integer * {@code oneByte} is written. If there is room in the buffer, the byte is * copied into the buffer and the count incremented. Otherwise, the buffer * plus {@code oneByte} are written to the target stream, the target is * flushed, and the buffer is reset. * * @param oneByte * the byte to be written. * @throws IOException * if an error occurs attempting to write to this stream. */ @Override public synchronized void write(int oneByte) throws IOException { checkNotClosed(); if (count == buf.length) { out.write(buf, 0, count); count = 0; } buf[count++] = (byte) oneByte; }
/** * Flushes this stream to ensure all pending data is written out to the * target stream. In addition, the target stream is flushed. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public synchronized void flush() throws IOException { checkNotClosed(); flushInternal(); out.flush(); }
/** * Flushes this stream to ensure all pending data is written out to the * target stream. In addition, the target stream is flushed. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public synchronized void flush() throws IOException { checkNotClosed(); flushInternal(); out.flush(); }
/** * Flushes this stream to ensure all pending data is written out to the * target stream. In addition, the target stream is flushed. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public synchronized void flush() throws IOException { checkNotClosed(); flushInternal(); out.flush(); }
/** * Flushes this stream to ensure all pending data is written out to the * target stream. In addition, the target stream is flushed. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public synchronized void flush() throws IOException { checkNotClosed(); flushInternal(); out.flush(); }
/** * Flushes this stream to ensure all pending data is written out to the * target stream. In addition, the target stream is flushed. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public synchronized void flush() throws IOException { checkNotClosed(); flushInternal(); out.flush(); }
/** * Flushes this stream to ensure all pending data is written out to the * target stream. In addition, the target stream is flushed. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public synchronized void flush() throws IOException { checkNotClosed(); flushInternal(); out.flush(); }
/** * Flushes this stream to ensure all pending data is written out to the * target stream. In addition, the target stream is flushed. * * @throws IOException * if an error occurs attempting to flush this stream. */ @Override public synchronized void flush() throws IOException { checkNotClosed(); flushInternal(); out.flush(); }