/*

* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

package java.io;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.SoftReference;

import java.lang.ref.WeakReference;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.UndeclaredThrowableException;

import java.lang.reflect.Member;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.lang.reflect.Proxy;

import java.security.AccessControlContext;

import java.security.AccessController;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.security.PermissionCollection;

import java.security.Permissions;

import java.security.PrivilegedAction;

import java.security.ProtectionDomain;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashSet;

import java.util.Set;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

import sun.misc.JavaSecurityAccess;

import sun.misc.SharedSecrets;

import sun.misc.Unsafe;

import sun.reflect.CallerSensitive;

import sun.reflect.Reflection;

import sun.reflect.ReflectionFactory;

import sun.reflect.misc.ReflectUtil;

/**

* Serialization's descriptor for classes. It contains the name and

* serialVersionUID of the class. The ObjectStreamClass for a specific class

* loaded in this Java VM can be found/created using the lookup method.

*

* <p>The algorithm to compute the SerialVersionUID is described in

* <a href="../../../platform/serialization/spec/class.html#4100">Object

* Serialization Specification, Section 4.6, Stream Unique Identifiers</a>.

*

* @author Mike Warres

* @author Roger Riggs

* @see ObjectStreamField

* @see <a href="../../../platform/serialization/spec/class.html">Object Serialization Specification, Section 4, Class Descriptors</a>

* @since JDK1.1

*/

public class ObjectStreamClass implements Serializable {

/** serialPersistentFields value indicating no serializable fields */

public static final ObjectStreamField[] NO_FIELDS =

new ObjectStreamField[0];

private static final long serialVersionUID = -6120832682080437368L;

private static final ObjectStreamField[] serialPersistentFields =

NO_FIELDS;

/** reflection factory for obtaining serialization constructors */

private static final ReflectionFactory reflFactory =

AccessController.doPrivileged(

new ReflectionFactory.GetReflectionFactoryAction());

private static class Caches {

/** cache mapping local classes -> descriptors */

static final ConcurrentMap<WeakClassKey,Reference<?>> localDescs =

new ConcurrentHashMap<>();

/** cache mapping field group/local desc pairs -> field reflectors */

static final ConcurrentMap<FieldReflectorKey,Reference<?>> reflectors =

new ConcurrentHashMap<>();

/** queue for WeakReferences to local classes */

private static final ReferenceQueue<Class<?>> localDescsQueue =

new ReferenceQueue<>();

/** queue for WeakReferences to field reflectors keys */

private static final ReferenceQueue<Class<?>> reflectorsQueue =

new ReferenceQueue<>();

}

/** class associated with this descriptor (if any) */

private Class<?> cl;

/** name of class represented by this descriptor */

private String name;

/** serialVersionUID of represented class (null if not computed yet) */

private volatile Long suid;

/** true if represents dynamic proxy class */

private boolean isProxy;

/** true if represents enum type */

private boolean isEnum;

/** true if represented class implements Serializable */

private boolean serializable;

/** true if represented class implements Externalizable */

private boolean externalizable;

/** true if desc has data written by class-defined writeObject method */

private boolean hasWriteObjectData;

/**

* true if desc has externalizable data written in block data format; this

* must be true by default to accommodate ObjectInputStream subclasses which

* override readClassDescriptor() to return class descriptors obtained from

* ObjectStreamClass.lookup() (see 4461737)

*/

private boolean hasBlockExternalData = true;

/**

* Contains information about InvalidClassException instances to be thrown

* when attempting operations on an invalid class. Note that instances of

* this class are immutable and are potentially shared among

* ObjectStreamClass instances.

*/

private static class ExceptionInfo {

private final String className;

private final String message;

ExceptionInfo(String cn, String msg) {

className = cn;

message = msg;

}

/**

* Returns (does not throw) an InvalidClassException instance created

* from the information in this object, suitable for being thrown by

* the caller.

*/

InvalidClassException newInvalidClassException() {

return new InvalidClassException(className, message);

}

}

/** exception (if any) thrown while attempting to resolve class */

private ClassNotFoundException resolveEx;

/** exception (if any) to throw if non-enum deserialization attempted */

private ExceptionInfo deserializeEx;

/** exception (if any) to throw if non-enum serialization attempted */

private ExceptionInfo serializeEx;

/** exception (if any) to throw if default serialization attempted */

private ExceptionInfo defaultSerializeEx;

/** serializable fields */

private ObjectStreamField[] fields;

/** aggregate marshalled size of primitive fields */

private int primDataSize;

/** number of non-primitive fields */

private int numObjFields;

/** reflector for setting/getting serializable field values */

private FieldReflector fieldRefl;

/** data layout of serialized objects described by this class desc */

private volatile ClassDataSlot[] dataLayout;

/** serialization-appropriate constructor, or null if none */

private Constructor<?> cons;

/** protection domains that need to be checked when calling the constructor */

private ProtectionDomain[] domains;

/** class-defined writeObject method, or null if none */

private Method writeObjectMethod;

/** class-defined readObject method, or null if none */

private Method readObjectMethod;

/** class-defined readObjectNoData method, or null if none */

private Method readObjectNoDataMethod;

/** class-defined writeReplace method, or null if none */

private Method writeReplaceMethod;

/** class-defined readResolve method, or null if none */

private Method readResolveMethod;

/** local class descriptor for represented class (may point to self) */

private ObjectStreamClass localDesc;

/** superclass descriptor appearing in stream */

private ObjectStreamClass superDesc;

/** true if, and only if, the object has been correctly initialized */

private boolean initialized;

/**

* Initializes native code.

*/

private static native void initNative();

static {

initNative();

}

/**

* Find the descriptor for a class that can be serialized. Creates an

* ObjectStreamClass instance if one does not exist yet for class. Null is

* returned if the specified class does not implement java.io.Serializable

* or java.io.Externalizable.

*

* @param cl class for which to get the descriptor

* @return the class descriptor for the specified class

*/

public static ObjectStreamClass lookup(Class<?> cl) {

return lookup(cl, false);

}

/**

* Returns the descriptor for any class, regardless of whether it

* implements {@link Serializable}.

*

* @param cl class for which to get the descriptor

* @return the class descriptor for the specified class

* @since 1.6

*/

public static ObjectStreamClass lookupAny(Class<?> cl) {

return lookup(cl, true);

}

/**

* Returns the name of the class described by this descriptor.

* This method returns the name of the class in the format that

* is used by the {@link Class#getName} method.

*

* @return a string representing the name of the class

*/

public String getName() {

return name;

}

/**

* Return the serialVersionUID for this class. The serialVersionUID

* defines a set of classes all with the same name that have evolved from a

* common root class and agree to be serialized and deserialized using a

* common format. NonSerializable classes have a serialVersionUID of 0L.

*

* @return the SUID of the class described by this descriptor

*/

public long getSerialVersionUID() {

// REMIND: synchronize instead of relying on volatile?

if (suid == null) {

suid = AccessController.doPrivileged(

new PrivilegedAction<Long>() {

public Long run() {

return computeDefaultSUID(cl);

}

}

);

}

return suid.longValue();

}

/**

* Return the class in the local VM that this version is mapped to. Null

* is returned if there is no corresponding local class.

*

* @return the <code>Class</code> instance that this descriptor represents

*/

@CallerSensitive

public Class<?> forClass() {

if (cl == null) {

return null;

}

requireInitialized();

if (System.getSecurityManager() != null) {

Class<?> caller = Reflection.getCallerClass();

if (ReflectUtil.needsPackageAccessCheck(caller.getClassLoader(), cl.getClassLoader())) {

ReflectUtil.checkPackageAccess(cl);

}

}

return cl;

}

/**

* Return an array of the fields of this serializable class.

*

* @return an array containing an element for each persistent field of

* this class. Returns an array of length zero if there are no

* fields.

* @since 1.2

*/

public ObjectStreamField[] getFields() {

return getFields(true);

}

/**

* Get the field of this class by name.

*

* @param name the name of the data field to look for

* @return The ObjectStreamField object of the named field or null if

* there is no such named field.

*/

public ObjectStreamField getField(String name) {

return getField(name, null);

}

/**

* Return a string describing this ObjectStreamClass.

*/

public String toString() {

return name + ": static final long serialVersionUID = " +

getSerialVersionUID() + "L;";

}

/**

* Looks up and returns class descriptor for given class, or null if class

* is non-serializable and "all" is set to false.

*

* @param cl class to look up

* @param all if true, return descriptors for all classes; if false, only

* return descriptors for serializable classes

*/

static ObjectStreamClass lookup(Class<?> cl, boolean all) {

if (!(all || Serializable.class.isAssignableFrom(cl))) {

return null;

}

processQueue(Caches.localDescsQueue, Caches.localDescs);

WeakClassKey key = new WeakClassKey(cl, Caches.localDescsQueue);

Reference<?> ref = Caches.localDescs.get(key);

Object entry = null;

if (ref != null) {

entry = ref.get();

}

EntryFuture future = null;

if (entry == null) {

EntryFuture newEntry = new EntryFuture();

Reference<?> newRef = new SoftReference<>(newEntry);

do {

if (ref != null) {

Caches.localDescs.remove(key, ref);

}

ref = Caches.localDescs.putIfAbsent(key, newRef);

if (ref != null) {

entry = ref.get();

}

} while (ref != null && entry == null);

if (entry == null) {

future = newEntry;

}

}

if (entry instanceof ObjectStreamClass) { // check common case first

return (ObjectStreamClass) entry;

}

if (entry instanceof EntryFuture) {

future = (EntryFuture) entry;

if (future.getOwner() == Thread.currentThread()) {

/*

* Handle nested call situation described by 4803747: waiting

* for future value to be set by a lookup() call further up the

* stack will result in deadlock, so calculate and set the

* future value here instead.

*/

entry = null;

} else {

entry = future.get();

}

}

if (entry == null) {

try {

entry = new ObjectStreamClass(cl);

} catch (Throwable th) {

entry = th;

}

if (future.set(entry)) {

Caches.localDescs.put(key, new SoftReference<Object>(entry));

} else {

// nested lookup call already set future

entry = future.get();

}

}

if (entry instanceof ObjectStreamClass) {

return (ObjectStreamClass) entry;

} else if (entry instanceof RuntimeException) {

throw (RuntimeException) entry;

} else if (entry instanceof Error) {

throw (Error) entry;

} else {

throw new InternalError("unexpected entry: " + entry);

}

}

/**

* Placeholder used in class descriptor and field reflector lookup tables

* for an entry in the process of being initialized. (Internal) callers

* which receive an EntryFuture belonging to another thread as the result

* of a lookup should call the get() method of the EntryFuture; this will

* return the actual entry once it is ready for use and has been set(). To

* conserve objects, EntryFutures synchronize on themselves.

*/

private static class EntryFuture {

private static final Object unset = new Object();

private final Thread owner = Thread.currentThread();

private Object entry = unset;

/**

* Attempts to set the value contained by this EntryFuture. If the

* EntryFuture's value has not been set already, then the value is

* saved, any callers blocked in the get() method are notified, and

* true is returned. If the value has already been set, then no saving

* or notification occurs, and false is returned.

*/

synchronized boolean set(Object entry) {

if (this.entry != unset) {

return false;

}

this.entry = entry;

notifyAll();

return true;

}

/**

* Returns the value contained by this EntryFuture, blocking if

* necessary until a value is set.

*/

synchronized Object get() {

boolean interrupted = false;

while (entry == unset) {

try {

wait();

} catch (InterruptedException ex) {

interrupted = true;

}

}

if (interrupted) {

AccessController.doPrivileged(

new PrivilegedAction<Void>() {

public Void run() {

Thread.currentThread().interrupt();

return null;

}

}

);

}

return entry;

}

/**

* Returns the thread that created this EntryFuture.

*/

Thread getOwner() {

return owner;

}

}

/**

* Creates local class descriptor representing given class.

*/

private ObjectStreamClass(final Class<?> cl) {

this.cl = cl;

name = cl.getName();

isProxy = Proxy.isProxyClass(cl);

isEnum = Enum.class.isAssignableFrom(cl);

serializable = Serializable.class.isAssignableFrom(cl);

externalizable = Externalizable.class.isAssignableFrom(cl);

Class<?> superCl = cl.getSuperclass();

superDesc = (superCl != null) ? lookup(superCl, false) : null;

localDesc = this;

if (serializable) {

AccessController.doPrivileged(new PrivilegedAction<Void>() {

public Void run() {

if (isEnum) {

suid = Long.valueOf(0);

fields = NO_FIELDS;

return null;

}

if (cl.isArray()) {

fields = NO_FIELDS;

return null;

}

suid = getDeclaredSUID(cl);

try {

fields = getSerialFields(cl);

computeFieldOffsets();

} catch (InvalidClassException e) {

serializeEx = deserializeEx =

new ExceptionInfo(e.classname, e.getMessage());

fields = NO_FIELDS;

}

if (externalizable) {

cons = getExternalizableConstructor(cl);

} else {

cons = getSerializableConstructor(cl);

writeObjectMethod = getPrivateMethod(cl, "writeObject",

new Class<?>[] { ObjectOutputStream.class },

Void.TYPE);

readObjectMethod = getPrivateMethod(cl, "readObject",

new Class<?>[] { ObjectInputStream.class },

Void.TYPE);

readObjectNoDataMethod = getPrivateMethod(

cl, "readObjectNoData", null, Void.TYPE);

hasWriteObjectData = (writeObjectMethod != null);

}

domains = getProtectionDomains(cons, cl);

writeReplaceMethod = getInheritableMethod(

cl, "writeReplace", null, Object.class);

readResolveMethod = getInheritableMethod(

cl, "readResolve", null, Object.class);

return null;

}

});

} else {

suid = Long.valueOf(0);

fields = NO_FIELDS;

}

try {

fieldRefl = getReflector(fields, this);

} catch (InvalidClassException ex) {

// field mismatches impossible when matching local fields vs. self

throw new InternalError(ex);

}

if (deserializeEx == null) {

if (isEnum) {

deserializeEx = new ExceptionInfo(name, "enum type");

} else if (cons == null) {

deserializeEx = new ExceptionInfo(name, "no valid constructor");

}

}

for (int i = 0; i < fields.length; i++) {

if (fields[i].getField() == null) {

defaultSerializeEx = new ExceptionInfo(

name, "unmatched serializable field(s) declared");

}

}

initialized = true;

}

/**

* Creates blank class descriptor which should be initialized via a

* subsequent call to initProxy(), initNonProxy() or readNonProxy().

*/

ObjectStreamClass() {

}

/**

* Creates a PermissionDomain that grants no permission.

*/

private ProtectionDomain noPermissionsDomain() {

PermissionCollection perms = new Permissions();

perms.setReadOnly();

return new ProtectionDomain(null, perms);

}

/**

* Aggregate the ProtectionDomains of all the classes that separate

* a concrete class {@code cl} from its ancestor's class declaring

* a constructor {@code cons}.

*

* If {@code cl} is defined by the boot loader, or the constructor

* {@code cons} is declared by {@code cl}, or if there is no security

* manager, then this method does nothing and {@code null} is returned.

*

* @param cons A constructor declared by {@code cl} or one of its

* ancestors.

* @param cl A concrete class, which is either the class declaring

* the constructor {@code cons}, or a serializable subclass

* of that class.

* @return An array of ProtectionDomain representing the set of

* ProtectionDomain that separate the concrete class {@code cl}

* from its ancestor's declaring {@code cons}, or {@code null}.

*/

private ProtectionDomain[] getProtectionDomains(Constructor<?> cons,

Class<?> cl) {

ProtectionDomain[] domains = null;

if (cons != null && cl.getClassLoader() != null

&& System.getSecurityManager() != null) {

Class<?> cls = cl;

Class<?> fnscl = cons.getDeclaringClass();

Set<ProtectionDomain> pds = null;

while (cls != fnscl) {

ProtectionDomain pd = cls.getProtectionDomain();

if (pd != null) {

if (pds == null) pds = new HashSet<>();

pds.add(pd);

}

cls = cls.getSuperclass();

if (cls == null) {

// that's not supposed to happen

// make a ProtectionDomain with no permission.

// should we throw instead?

if (pds == null) pds = new HashSet<>();

else pds.clear();

pds.add(noPermissionsDomain());

break;

}

}

if (pds != null) {

domains = pds.toArray(new ProtectionDomain[0]);

}

}

return domains;

}

/**

* Initializes class descriptor representing a proxy class.

*/

void initProxy(Class<?> cl,

ClassNotFoundException resolveEx,

ObjectStreamClass superDesc)

throws InvalidClassException

{

ObjectStreamClass osc = null;

if (cl != null) {

osc = lookup(cl, true);

if (!osc.isProxy) {

throw new InvalidClassException(

"cannot bind proxy descriptor to a non-proxy class");

}

}

this.cl = cl;

this.resolveEx = resolveEx;

this.superDesc = superDesc;

isProxy = true;

serializable = true;

suid = Long.valueOf(0);

fields = NO_FIELDS;

if (osc != null) {

localDesc = osc;

name = localDesc.name;

externalizable = localDesc.externalizable;

writeReplaceMethod = localDesc.writeReplaceMethod;

readResolveMethod = localDesc.readResolveMethod;

deserializeEx = localDesc.deserializeEx;

domains = localDesc.domains;

cons = localDesc.cons;

}

fieldRefl = getReflector(fields, localDesc);

initialized = true;

}

/**

* Initializes class descriptor representing a non-proxy class.

*/

void initNonProxy(ObjectStreamClass model,

Class<?> cl,

ClassNotFoundException resolveEx,

ObjectStreamClass superDesc)

throws InvalidClassException

{

long suid = Long.valueOf(model.getSerialVersionUID());

ObjectStreamClass osc = null;

if (cl != null) {

osc = lookup(cl, true);

if (osc.isProxy) {

throw new InvalidClassException(

"cannot bind non-proxy descriptor to a proxy class");

}

if (model.isEnum != osc.isEnum) {

throw new InvalidClassException(model.isEnum ?

"cannot bind enum descriptor to a non-enum class" :

"cannot bind non-enum descriptor to an enum class");

}

if (model.serializable == osc.serializable &&

!cl.isArray() &&

suid != osc.getSerialVersionUID()) {

throw new InvalidClassException(osc.name,

"local class incompatible: " +

"stream classdesc serialVersionUID = " + suid +

", local class serialVersionUID = " +

osc.getSerialVersionUID());

}

if (!classNamesEqual(model.name, osc.name)) {

throw new InvalidClassException(osc.name,

"local class name incompatible with stream class " +

"name \"" + model.name + "\"");

}

if (!model.isEnum) {

if ((model.serializable == osc.serializable) &&

(model.externalizable != osc.externalizable)) {

throw new InvalidClassException(osc.name,

"Serializable incompatible with Externalizable");

}

if ((model.serializable != osc.serializable) ||

(model.externalizable != osc.externalizable) ||

!(model.serializable || model.externalizable)) {

deserializeEx = new ExceptionInfo(

osc.name, "class invalid for deserialization");

}

}

}

this.cl = cl;

this.resolveEx = resolveEx;

this.superDesc = superDesc;

name = model.name;

this.suid = suid;

isProxy = false;

isEnum = model.isEnum;

serializable = model.serializable;

externalizable = model.externalizable;

hasBlockExternalData = model.hasBlockExternalData;

hasWriteObjectData = model.hasWriteObjectData;

fields = model.fields;

primDataSize = model.primDataSize;

numObjFields = model.numObjFields;

if (osc != null) {

localDesc = osc;

writeObjectMethod = localDesc.writeObjectMethod;

readObjectMethod = localDesc.readObjectMethod;

readObjectNoDataMethod = localDesc.readObjectNoDataMethod;

writeReplaceMethod = localDesc.writeReplaceMethod;

readResolveMethod = localDesc.readResolveMethod;

if (deserializeEx == null) {

deserializeEx = localDesc.deserializeEx;

}

domains = localDesc.domains;

cons = localDesc.cons;

}

fieldRefl = getReflector(fields, localDesc);

// reassign to matched fields so as to reflect local unshared settings

fields = fieldRefl.getFields();

initialized = true;

}

/**

* Reads non-proxy class descriptor information from given input stream.

* The resulting class descriptor is not fully functional; it can only be

* used as input to the ObjectInputStream.resolveClass() and

* ObjectStreamClass.initNonProxy() methods.

*/

void readNonProxy(ObjectInputStream in)

throws IOException, ClassNotFoundException

{

name = in.readUTF();

suid = Long.valueOf(in.readLong());

isProxy = false;

byte flags = in.readByte();

hasWriteObjectData =

((flags & ObjectStreamConstants.SC_WRITE_METHOD) != 0);

hasBlockExternalData =

((flags & ObjectStreamConstants.SC_BLOCK_DATA) != 0);

externalizable =

((flags & ObjectStreamConstants.SC_EXTERNALIZABLE) != 0);

boolean sflag =

((flags & ObjectStreamConstants.SC_SERIALIZABLE) != 0);

if (externalizable && sflag) {

throw new InvalidClassException(

name, "serializable and externalizable flags conflict");

}

serializable = externalizable || sflag;

isEnum = ((flags & ObjectStreamConstants.SC_ENUM) != 0);

if (isEnum && suid.longValue() != 0L) {

throw new InvalidClassException(name,

"enum descriptor has non-zero serialVersionUID: " + suid);

}

int numFields = in.readShort();

if (isEnum && numFields != 0) {

throw new InvalidClassException(name,

"enum descriptor has non-zero field count: " + numFields);

}

fields = (numFields > 0) ?

new ObjectStreamField[numFields] : NO_FIELDS;

for (int i = 0; i < numFields; i++) {

char tcode = (char) in.readByte();

String fname = in.readUTF();

String signature = ((tcode == 'L') || (tcode == '[')) ?

in.readTypeString() : new String(new char[] { tcode });

try {

fields[i] = new ObjectStreamField(fname, signature, false);

} catch (RuntimeException e) {

throw (IOException) new InvalidClassException(name,

"invalid descriptor for field " + fname).initCause(e);

}

}

computeFieldOffsets();

}

/**

* Writes non-proxy class descriptor information to given output stream.

*/

void writeNonProxy(ObjectOutputStream out) throws IOException {

out.writeUTF(name);

out.writeLong(getSerialVersionUID());

byte flags = 0;

if (externalizable) {

flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;

int protocol = out.getProtocolVersion();

if (protocol != ObjectStreamConstants.PROTOCOL_VERSION_1) {

flags |= ObjectStreamConstants.SC_BLOCK_DATA;

}

} else if (serializable) {

flags |= ObjectStreamConstants.SC_SERIALIZABLE;

}

if (hasWriteObjectData) {

flags |= ObjectStreamConstants.SC_WRITE_METHOD;

}

if (isEnum) {

flags |= ObjectStreamConstants.SC_ENUM;

}

out.writeByte(flags);

out.writeShort(fields.length);

for (int i = 0; i < fields.length; i++) {

ObjectStreamField f = fields[i];

out.writeByte(f.getTypeCode());

out.writeUTF(f.getName());

if (!f.isPrimitive()) {

out.writeTypeString(f.getTypeString());

}

}

}

/**

* Returns ClassNotFoundException (if any) thrown while attempting to

* resolve local class corresponding to this class descriptor.

*/

ClassNotFoundException getResolveException() {

return resolveEx;

}

/**

* Throws InternalError if not initialized.

*/

private final void requireInitialized() {

if (!initialized)

throw new InternalError("Unexpected call when not initialized");

}

/**

* Throws an InvalidClassException if object instances referencing this

* class descriptor should not be allowed to deserialize. This method does

* not apply to deserialization of enum constants.

*/

void checkDeserialize() throws InvalidClassException {

requireInitialized();

if (deserializeEx != null) {

throw deserializeEx.newInvalidClassException();

}

}

/**

* Throws an InvalidClassException if objects whose class is represented by

* this descriptor should not be allowed to serialize. This method does

* not apply to serialization of enum constants.

*/

void checkSerialize() throws InvalidClassException {

requireInitialized();

if (serializeEx != null) {

throw serializeEx.newInvalidClassException();

}

}

/**

* Throws an InvalidClassException if objects whose class is represented by

* this descriptor should not be permitted to use default serialization

* (e.g., if the class declares serializable fields that do not correspond

* to actual fields, and hence must use the GetField API). This method

* does not apply to deserialization of enum constants.

*/

void checkDefaultSerialize() throws InvalidClassException {

requireInitialized();

if (defaultSerializeEx != null) {

throw defaultSerializeEx.newInvalidClassException();

}

}

/**

* Returns superclass descriptor. Note that on the receiving side, the

* superclass descriptor may be bound to a class that is not a superclass

* of the subclass descriptor's bound class.

*/

ObjectStreamClass getSuperDesc() {

requireInitialized();

return superDesc;

}

/**

* Returns the "local" class descriptor for the class associated with this

* class descriptor (i.e., the result of

* ObjectStreamClass.lookup(this.forClass())) or null if there is no class

* associated with this descriptor.

*/

ObjectStreamClass getLocalDesc() {

requireInitialized();

return localDesc;

}

/**

* Returns arrays of ObjectStreamFields representing the serializable

* fields of the represented class. If copy is true, a clone of this class

* descriptor's field array is returned, otherwise the array itself is

* returned.

*/

ObjectStreamField[] getFields(boolean copy) {

return copy ? fields.clone() : fields;

}

/**

* Looks up a serializable field of the represented class by name and type.

* A specified type of null matches all types, Object.class matches all

* non-primitive types, and any other non-null type matches assignable

* types only. Returns matching field, or null if no match found.

*/

ObjectStreamField getField(String name, Class<?> type) {

for (int i = 0; i < fields.length; i++) {

ObjectStreamField f = fields[i];

if (f.getName().equals(name)) {

if (type == null ||

(type == Object.class && !f.isPrimitive()))

{

return f;

}

Class<?> ftype = f.getType();

if (ftype != null && type.isAssignableFrom(ftype)) {

return f;

}

}

}

return null;

}

/**

* Returns true if class descriptor represents a dynamic proxy class, false

* otherwise.

*/

boolean isProxy() {

requireInitialized();

return isProxy;

}

/**

* Returns true if class descriptor represents an enum type, false

* otherwise.

*/

boolean isEnum() {

requireInitialized();

return isEnum;

}

/**

* Returns true if represented class implements Externalizable, false

* otherwise.

*/

boolean isExternalizable() {

requireInitialized();

return externalizable;

}

/**

* Returns true if represented class implements Serializable, false

* otherwise.

*/

boolean isSerializable() {

requireInitialized();

return serializable;

}

/**

* Returns true if class descriptor represents externalizable class that

* has written its data in 1.2 (block data) format, false otherwise.

*/

boolean hasBlockExternalData() {

requireInitialized();

return hasBlockExternalData;

}

/**

* Returns true if class descriptor represents serializable (but not

* externalizable) class which has written its data via a custom

* writeObject() method, false otherwise.

*/

boolean hasWriteObjectData() {

requireInitialized();

return hasWriteObjectData;

}