/** * 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(); }
/** * Constructs a new ObjectOutputStream that writes to the OutputStream * {@code output}. * * @param output * the non-null OutputStream to filter writes on. * * @throws IOException * if an error occurs while writing the object stream * header */ public ObjectOutputStream(OutputStream output) throws IOException { this.output = (output instanceof DataOutputStream) ? (DataOutputStream) output : new DataOutputStream(output); this.enableReplace = false; this.protocolVersion = PROTOCOL_VERSION_2; this.subclassOverridingImplementation = false; resetState(); this.nestedException = new StreamCorruptedException(); // So write...() methods can be used by // subclasses during writeStreamHeader() primitiveTypes = this.output; // Has to be done here according to the specification writeStreamHeader(); primitiveTypes = null; }
/** * 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(); }
/** * 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(); }
/** * Constructs a new ObjectOutputStream that writes to the OutputStream * {@code output}. * * @param output * the non-null OutputStream to filter writes on. * * @throws IOException * if an error occurs while writing the object stream * header */ public ObjectOutputStream(OutputStream output) throws IOException { this.output = (output instanceof DataOutputStream) ? (DataOutputStream) output : new DataOutputStream(output); this.enableReplace = false; this.protocolVersion = PROTOCOL_VERSION_2; this.subclassOverridingImplementation = false; resetState(); this.nestedException = new StreamCorruptedException(); // So write...() methods can be used by // subclasses during writeStreamHeader() primitiveTypes = this.output; // Has to be done here according to the specification writeStreamHeader(); primitiveTypes = null; }
/** * 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(); }
/** * Constructs a new ObjectOutputStream that writes to the OutputStream * {@code output}. * * @param output * the non-null OutputStream to filter writes on. * * @throws IOException * if an error occurs while writing the object stream * header */ public ObjectOutputStream(OutputStream output) throws IOException { this.output = (output instanceof DataOutputStream) ? (DataOutputStream) output : new DataOutputStream(output); this.enableReplace = false; this.protocolVersion = PROTOCOL_VERSION_2; this.subclassOverridingImplementation = false; resetState(); this.nestedException = new StreamCorruptedException(); // So write...() methods can be used by // subclasses during writeStreamHeader() primitiveTypes = this.output; // Has to be done here according to the specification writeStreamHeader(); primitiveTypes = null; }
/** * Constructs a new ObjectOutputStream that writes to the OutputStream * {@code output}. * * @param output * the non-null OutputStream to filter writes on. * * @throws IOException * if an error occurs while writing the object stream * header */ public ObjectOutputStream(OutputStream output) throws IOException { this.output = (output instanceof DataOutputStream) ? (DataOutputStream) output : new DataOutputStream(output); this.enableReplace = false; this.protocolVersion = PROTOCOL_VERSION_2; this.subclassOverridingImplementation = false; resetState(); this.nestedException = new StreamCorruptedException(); // So write...() methods can be used by // subclasses during writeStreamHeader() primitiveTypes = this.output; // Has to be done here according to the specification writeStreamHeader(); primitiveTypes = null; }
/** * Constructs a new ObjectOutputStream that writes to the OutputStream * {@code output}. * * @param output * the non-null OutputStream to filter writes on. * * @throws IOException * if an error occurs while writing the object stream * header */ public ObjectOutputStream(OutputStream output) throws IOException { this.output = (output instanceof DataOutputStream) ? (DataOutputStream) output : new DataOutputStream(output); this.enableReplace = false; this.protocolVersion = PROTOCOL_VERSION_2; this.subclassOverridingImplementation = false; resetState(); this.nestedException = new StreamCorruptedException(); // So write...() methods can be used by // subclasses during writeStreamHeader() primitiveTypes = this.output; // Has to be done here according to the specification writeStreamHeader(); primitiveTypes = null; }
/** * 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(); }
/** * Constructs a new ObjectOutputStream that writes to the OutputStream * {@code output}. * * @param output * the non-null OutputStream to filter writes on. * * @throws IOException * if an error occurs while writing the object stream * header */ public ObjectOutputStream(OutputStream output) throws IOException { this.output = (output instanceof DataOutputStream) ? (DataOutputStream) output : new DataOutputStream(output); this.enableReplace = false; this.protocolVersion = PROTOCOL_VERSION_2; this.subclassOverridingImplementation = false; resetState(); this.nestedException = new StreamCorruptedException(); // So write...() methods can be used by // subclasses during writeStreamHeader() primitiveTypes = this.output; // Has to be done here according to the specification writeStreamHeader(); primitiveTypes = null; }
/** * Constructs a new ObjectOutputStream that writes to the OutputStream * {@code output}. * * @param output * the non-null OutputStream to filter writes on. * * @throws IOException * if an error occurs while writing the object stream * header */ public ObjectOutputStream(OutputStream output) throws IOException { this.output = (output instanceof DataOutputStream) ? (DataOutputStream) output : new DataOutputStream(output); this.enableReplace = false; this.protocolVersion = PROTOCOL_VERSION_2; this.subclassOverridingImplementation = false; resetState(); this.nestedException = new StreamCorruptedException(); // So write...() methods can be used by // subclasses during writeStreamHeader() primitiveTypes = this.output; // Has to be done here according to the specification writeStreamHeader(); primitiveTypes = null; }
/** * Constructs a new ObjectOutputStream that writes to the OutputStream * {@code output}. * * @param output * the non-null OutputStream to filter writes on. * * @throws IOException * if an error occurs while writing the object stream * header */ public ObjectOutputStream(OutputStream output) throws IOException { this.output = (output instanceof DataOutputStream) ? (DataOutputStream) output : new DataOutputStream(output); this.enableReplace = false; this.protocolVersion = PROTOCOL_VERSION_2; this.subclassOverridingImplementation = false; resetState(); this.nestedException = new StreamCorruptedException(); // So write...() methods can be used by // subclasses during writeStreamHeader() primitiveTypes = this.output; // Has to be done here according to the specification writeStreamHeader(); primitiveTypes = null; }