/** * Writes buffered data to the target stream and calls the {@code flush} * method of the target stream. * * @throws IOException * if an error occurs while writing to or flushing the output * stream. */ @Override public void flush() throws IOException { drain(); output.flush(); }
/** * Resets the state of this stream. A marker is written to the stream, so * that the corresponding input stream will also perform a reset at the same * point. Objects previously written are no longer remembered, so they will * be written again (instead of a cyclical reference) if found in the object * graph. * * @throws IOException * if {@code reset()} is called during the serialization of an * object. */ public void reset() throws IOException { // First we flush what we have drain(); /* * And dump a reset marker, so that the ObjectInputStream can reset * itself at the same point */ output.writeByte(TC_RESET); // Now we reset ourselves resetState(); }
drain(); output.writeByte(TC_ENDBLOCKDATA); } else {
drain(); output.writeByte(TC_ENDBLOCKDATA);
drain(); // flush primitive types in the annotation output.writeByte(TC_ENDBLOCKDATA); writeClassDesc(classDesc.getSuperclass(), unshared);
drain(); // flush primitive types in the annotation output.writeByte(TC_ENDBLOCKDATA);
@Override public void drain() throws IOException { super.drain(); } }
@Override public void drain() throws IOException { super.drain(); }
/** * Writes buffered data to the target stream and calls the {@code flush} * method of the target stream. * * @throws IOException * if an error occurs while writing to or flushing the output * stream. */ @Override public void flush() throws IOException { drain(); output.flush(); }
/** * Writes buffered data to the target stream and calls the {@code flush} * method of the target stream. * * @throws IOException * if an error occurs while writing to or flushing the output * stream. */ @Override public void flush() throws IOException { drain(); output.flush(); }
/** * Writes buffered data to the target stream and calls the {@code flush} * method of the target stream. * * @throws IOException * if an error occurs while writing to or flushing the output * stream. */ @Override public void flush() throws IOException { drain(); output.flush(); }
/** * Writes buffered data to the target stream and calls the {@code flush} * method of the target stream. * * @throws IOException * if an error occurs while writing to or flushing the output * stream. */ @Override public void flush() throws IOException { drain(); output.flush(); }
/** * Writes buffered data to the target stream and calls the {@code flush} * method of the target stream. * * @throws IOException * if an error occurs while writing to or flushing the output * stream. */ @Override public void flush() throws IOException { drain(); output.flush(); }
/** * Writes buffered data to the target stream and calls the {@code flush} * method of the target stream. * * @throws IOException * if an error occurs while writing to or flushing the output * stream. */ @Override public void flush() throws IOException { drain(); output.flush(); }
/** * Writes buffered data to the target stream and calls the {@code flush} * method of the target stream. * * @throws IOException * if an error occurs while writing to or flushing the output * stream. */ @Override public void flush() throws IOException { drain(); output.flush(); }
/** * Resets the state of this stream. A marker is written to the stream, so * that the corresponding input stream will also perform a reset at the same * point. Objects previously written are no longer remembered, so they will * be written again (instead of a cyclical reference) if found in the object * graph. * * @throws IOException * if {@code reset()} is called during the serialization of an * object. */ public void reset() throws IOException { // First we flush what we have drain(); /* * And dump a reset marker, so that the ObjectInputStream can reset * itself at the same point */ output.writeByte(TC_RESET); // Now we reset ourselves resetState(); }
/** * Resets the state of this stream. A marker is written to the stream, so * that the corresponding input stream will also perform a reset at the same * point. Objects previously written are no longer remembered, so they will * be written again (instead of a cyclical reference) if found in the object * graph. * * @throws IOException * if {@code reset()} is called during the serialization of an * object. */ public void reset() throws IOException { // First we flush what we have drain(); /* * And dump a reset marker, so that the ObjectInputStream can reset * itself at the same point */ output.writeByte(TC_RESET); // Now we reset ourselves resetState(); }
/** * Resets the state of this stream. A marker is written to the stream, so * that the corresponding input stream will also perform a reset at the same * point. Objects previously written are no longer remembered, so they will * be written again (instead of a cyclical reference) if found in the object * graph. * * @throws IOException * if {@code reset()} is called during the serialization of an * object. */ public void reset() throws IOException { // First we flush what we have drain(); /* * And dump a reset marker, so that the ObjectInputStream can reset * itself at the same point */ output.writeByte(TC_RESET); // Now we reset ourselves resetState(); }
/** * Resets the state of this stream. A marker is written to the stream, so * that the corresponding input stream will also perform a reset at the same * point. Objects previously written are no longer remembered, so they will * be written again (instead of a cyclical reference) if found in the object * graph. * * @throws IOException * if {@code reset()} is called during the serialization of an * object. */ public void reset() throws IOException { // First we flush what we have drain(); /* * And dump a reset marker, so that the ObjectInputStream can reset * itself at the same point */ output.writeByte(TC_RESET); // Now we reset ourselves resetState(); }