Thursday, March 12, 2015

NotActiveException

java.io.NotActiveException

NotActiveException is described in the javadoc comments as:

Thrown when serialization or deserialization is not active.
author: unascribed version: 1.15, 12/19/03 since: JDK1.1

Where is this exception thrown?

Following, is a list of exception messages cross-referenced to the source code responsible for throwing them. Click on the method link to view the code and see how the exception is thrown.

How is this exception thrown?

The following sub-sections identify where this exception is thrown, and how (or why) the code is throwing the exception.

Any source code quoted in this section is subject to the Java Research License unless stated otherwise.

com.sun.corba.se.impl.io.IIOPInputStream.defaultReadObjectDelegate()

/**
     * Override the actions of the final method 'defaultReadObject()'
     * in ObjectInputStream.
     * @since     JDK1.1.6
     * Read the non-static and non-transient fields of the current class
     * from this stream.  This may only be called from the readObject method
     * of the class being deserialized. It will throw the NotActiveException
     * if it is called otherwise.
     * @exception java.lang.ClassNotFoundException if the class of a serialized
     *              object could not be found.
     * @exception IOException        if an I/O error occurs.
     * @exception NotActiveException if the stream is not currently reading
     *              objects.
     * @since     JDK1.1
     */
public final void defaultReadObjectDelegate() {
    try {
        if (currentObject == null || currentClassDesc == null) throw new NotActiveException('defaultReadObjectDelegate');
        if (defaultReadObjectFVDMembers != null && defaultReadObjectFVDMembers.length > 0) {
            inputClassFields(currentObject, currentClass, currentClassDesc, defaultReadObjectFVDMembers, cbSender);
        } else {
            ObjectStreamField[] fields = currentClassDesc.getFieldsNoCopy();
            if (fields.length > 0) {
                inputClassFields(currentObject, currentClass, fields, cbSender);
            }
        }
    } catch (NotActiveException nae) {
        bridge.throwException(nae);
    } catch (IOException ioe) {
        bridge.throwException(ioe);
    } catch (ClassNotFoundException cnfe) {
        bridge.throwException(cnfe);
    }
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

com.sun.corba.se.impl.io.IIOPOutputStream.defaultWriteObjectDelegate()

/**
     * Override the actions of the final method 'defaultWriteObject()'
     * in ObjectOutputStream.
     * @since     JDK1.1.6
     */
public final void defaultWriteObjectDelegate() {
    try {
        if (currentObject == null || currentClassDesc == null) throw new NotActiveException('defaultWriteObjectDelegate');
        ObjectStreamField[] fields = currentClassDesc.getFieldsNoCopy();
        if (fields.length > 0) {
            outputClassFields(currentObject, currentClassDesc.forClass(), fields);
        }
    } catch (IOException ioe) {
        bridge.throwException(ioe);
    }
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.io.ObjectOutputStream.writeFields()

/**
     * Write the buffered fields to the stream.
     * @throws IOException if I/O errors occur while writing to the underlying
     *   stream
     * @throws NotActiveException Called when a classes writeObject method was
     *   not called to write the state of the object.
     * @since 1.2
     */
public void writeFields() throws IOException {
    if (curPut == null) {
        throw new NotActiveException('no current PutField object');
    }
    bout.setBlockDataMode(false);
    curPut.writeFields();
    bout.setBlockDataMode(true);
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.io.ObjectInputStream.defaultReadObject()

/**
     * Read the non-static and non-transient fields of the current class from
     * this stream.  This may only be called from the readObject method of the
     * class being deserialized. It will throw the NotActiveException if it is
     * called otherwise.
     * @throws ClassNotFoundException if the class of a serialized object
     *   could not be found.
     * @throws IOException if an I/O error occurs.
     * @throws NotActiveException if the stream is not currently reading
     *   objects.
     */
public void defaultReadObject() throws IOException, ClassNotFoundException {
    if (curContext == null) {
        throw new NotActiveException('not in call to readObject');
    }
    Object curObj = curContext.getObj();
    ObjectStreamClass curDesc = curContext.getDesc();
    bin.setBlockDataMode(false);
    defaultReadFields(curObj, curDesc);
    bin.setBlockDataMode(true);
    if (!curDesc.hasWriteObjectData()) {
        defaultDataEnd = true;
    }
    ClassNotFoundException ex = handles.lookupException(passHandle);
    if (ex != null) {
        throw ex;
    }
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.io.ObjectInputStream.readFields()

/**
     * Reads the persistent fields from the stream and makes them available by
     * name.
     * @return the <code>GetField</code> object representing the persistent
     *   fields of the object being deserialized
     * @throws ClassNotFoundException if the class of a serialized object
     *   could not be found.
     * @throws IOException if an I/O error occurs.
     * @throws NotActiveException if the stream is not currently reading
     *   objects.
     * @since 1.2
     */
public ObjectInputStream.GetField readFields() throws IOException, ClassNotFoundException {
    if (curContext == null) {
        throw new NotActiveException('not in call to readObject');
    }
    Object curObj = curContext.getObj();
    ObjectStreamClass curDesc = curContext.getDesc();
    bin.setBlockDataMode(false);
    GetFieldImpl getField = new GetFieldImpl(curDesc);
    getField.readFields();
    bin.setBlockDataMode(true);
    if (!curDesc.hasWriteObjectData()) {
        defaultDataEnd = true;
    }
    return getField;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.io.ObjectOutputStream.defaultWriteObject()

/**
     * Write the non-static and non-transient fields of the current class to
     * this stream.  This may only be called from the writeObject method of the
     * class being serialized. It will throw the NotActiveException if it is
     * called otherwise.
     * @throws IOException if I/O errors occur while writing to the underlying
     *   <code>OutputStream</code>
     */
public void defaultWriteObject() throws IOException {
    if (curObj == null || curDesc == null) {
        throw new NotActiveException('not in call to writeObject');
    }
    bout.setBlockDataMode(false);
    defaultWriteFields(curObj, curDesc);
    bout.setBlockDataMode(true);
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.io.ObjectOutputStream.putFields()

/**
     * Retrieve the object used to buffer persistent fields to be written to
     * the stream.  The fields will be written to the stream when writeFields
     * method is called.
     * @return an instance of the class Putfield that holds the serializable
     *   fields
     * @throws IOException if I/O errors occur
     * @since 1.2
     */
public ObjectOutputStream.PutField putFields() throws IOException {
    if (curPut == null) {
        if (curObj == null || curDesc == null) {
            throw new NotActiveException('not in call to writeObject');
        }
        curPut = new PutFieldImpl(curDesc);
    }
    return curPut;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.io.ObjectInputStream.registerValidation(ObjectInputValidation, int)

/**
     * Register an object to be validated before the graph is returned.  While
     * similar to resolveObject these validations are called after the entire
     * graph has been reconstituted.  Typically, a readObject method will
     * register the object with the stream so that when all of the objects are
     * restored a final set of validations can be performed.
     * @param obj the object to receive the validation callback.
     * @param prio controls the order of callbacks;zero is a good default.
     *   Use higher numbers to be called back earlier, lower numbers for
     *   later callbacks. Within a priority, callbacks are processed in
     *   no particular order.
     * @throws NotActiveException The stream is not currently reading objects
     *   so it is invalid to register a callback.
     * @throws InvalidObjectException The validation object is null.
     */
public void registerValidation(ObjectInputValidation obj, int prio) throws NotActiveException, InvalidObjectException {
    if (depth == 0) {
        throw new NotActiveException('stream inactive');
    }
    vlist.register(obj, prio);
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

No comments:

Post a Comment