< prev index next >

src/java.base/share/classes/java/io/ObjectStreamField.java

Print this page
rev 17455 : 8184603: Create ObjectStreamField signature lazily when possible
Reviewed-by: rriggs, chegar, alanb, shade


  29 import jdk.internal.reflect.CallerSensitive;
  30 import jdk.internal.reflect.Reflection;
  31 import sun.reflect.misc.ReflectUtil;
  32 
  33 /**
  34  * A description of a Serializable field from a Serializable class.  An array
  35  * of ObjectStreamFields is used to declare the Serializable fields of a class.
  36  *
  37  * @author      Mike Warres
  38  * @author      Roger Riggs
  39  * @see ObjectStreamClass
  40  * @since 1.2
  41  */
  42 public class ObjectStreamField
  43     implements Comparable<Object>
  44 {
  45 
  46     /** field name */
  47     private final String name;
  48     /** canonical JVM signature of field type */
  49     private final String signature;
  50     /** field type (Object.class if unknown non-primitive type) */
  51     private final Class<?> type;
  52     /** whether or not to (de)serialize field values as unshared */
  53     private final boolean unshared;
  54     /** corresponding reflective field object, if any */
  55     private final Field field;
  56     /** offset of field value in enclosing field group */
  57     private int offset = 0;
  58 
  59     /**
  60      * Create a Serializable field with the specified type.  This field should
  61      * be documented with a <code>serialField</code> tag.
  62      *
  63      * @param   name the name of the serializable field
  64      * @param   type the <code>Class</code> object of the serializable field
  65      */
  66     public ObjectStreamField(String name, Class<?> type) {
  67         this(name, type, false);
  68     }
  69 
  70     /**
  71      * Creates an ObjectStreamField representing a serializable field with the
  72      * given name and type.  If unshared is false, values of the represented
  73      * field are serialized and deserialized in the default manner--if the
  74      * field is non-primitive, object values are serialized and deserialized as
  75      * if they had been written and read by calls to writeObject and
  76      * readObject.  If unshared is true, values of the represented field are
  77      * serialized and deserialized as if they had been written and read by
  78      * calls to writeUnshared and readUnshared.
  79      *
  80      * @param   name field name
  81      * @param   type field type
  82      * @param   unshared if false, write/read field values in the same manner
  83      *          as writeObject/readObject; if true, write/read in the same
  84      *          manner as writeUnshared/readUnshared
  85      * @since   1.4
  86      */
  87     public ObjectStreamField(String name, Class<?> type, boolean unshared) {
  88         if (name == null) {
  89             throw new NullPointerException();
  90         }
  91         this.name = name;
  92         this.type = type;
  93         this.unshared = unshared;
  94         signature = getClassSignature(type).intern();
  95         field = null;
  96     }
  97 
  98     /**
  99      * Creates an ObjectStreamField representing a field with the given name,
 100      * signature and unshared setting.
 101      */
 102     ObjectStreamField(String name, String signature, boolean unshared) {
 103         if (name == null) {
 104             throw new NullPointerException();
 105         }
 106         this.name = name;
 107         this.signature = signature.intern();
 108         this.unshared = unshared;
 109         field = null;
 110 
 111         switch (signature.charAt(0)) {
 112             case 'Z': type = Boolean.TYPE; break;
 113             case 'B': type = Byte.TYPE; break;
 114             case 'C': type = Character.TYPE; break;
 115             case 'S': type = Short.TYPE; break;
 116             case 'I': type = Integer.TYPE; break;
 117             case 'J': type = Long.TYPE; break;
 118             case 'F': type = Float.TYPE; break;
 119             case 'D': type = Double.TYPE; break;
 120             case 'L':
 121             case '[': type = Object.class; break;
 122             default: throw new IllegalArgumentException("illegal signature");
 123         }
 124     }
 125 
 126     /**
 127      * Returns JVM type signature for given primitive.
 128      */
 129     private static String getPrimitiveSignature(Class<?> cl) {


 225 
 226     /**
 227      * Returns character encoding of field type.  The encoding is as follows:
 228      * <blockquote><pre>
 229      * B            byte
 230      * C            char
 231      * D            double
 232      * F            float
 233      * I            int
 234      * J            long
 235      * L            class or interface
 236      * S            short
 237      * Z            boolean
 238      * [            array
 239      * </pre></blockquote>
 240      *
 241      * @return  the typecode of the serializable field
 242      */
 243     // REMIND: deprecate?
 244     public char getTypeCode() {
 245         return signature.charAt(0);
 246     }
 247 
 248     /**
 249      * Return the JVM type signature.
 250      *
 251      * @return  null if this field has a primitive type.
 252      */
 253     // REMIND: deprecate?
 254     public String getTypeString() {
 255         return isPrimitive() ? null : signature;
 256     }
 257 
 258     /**
 259      * Offset of field within instance data.
 260      *
 261      * @return  the offset of this field
 262      * @see #setOffset
 263      */
 264     // REMIND: deprecate?
 265     public int getOffset() {
 266         return offset;
 267     }
 268 
 269     /**
 270      * Offset within instance data.
 271      *
 272      * @param   offset the offset of the field
 273      * @see #getOffset
 274      */
 275     // REMIND: deprecate?
 276     protected void setOffset(int offset) {
 277         this.offset = offset;
 278     }
 279 
 280     /**
 281      * Return true if this field has a primitive type.
 282      *
 283      * @return  true if and only if this field corresponds to a primitive type
 284      */
 285     // REMIND: deprecate?
 286     public boolean isPrimitive() {
 287         char tcode = signature.charAt(0);
 288         return ((tcode != 'L') && (tcode != '['));
 289     }
 290 
 291     /**
 292      * Returns boolean value indicating whether or not the serializable field
 293      * represented by this ObjectStreamField instance is unshared.
 294      *
 295      * @return {@code true} if this field is unshared
 296      *
 297      * @since 1.4
 298      */
 299     public boolean isUnshared() {
 300         return unshared;
 301     }
 302 
 303     /**
 304      * Compare this field with another <code>ObjectStreamField</code>.  Return
 305      * -1 if this is smaller, 0 if equal, 1 if greater.  Types that are
 306      * primitives are "smaller" than object types.  If equal, the field names
 307      * are compared.
 308      */
 309     // REMIND: deprecate?
 310     public int compareTo(Object obj) {
 311         ObjectStreamField other = (ObjectStreamField) obj;
 312         boolean isPrim = isPrimitive();
 313         if (isPrim != other.isPrimitive()) {
 314             return isPrim ? -1 : 1;
 315         }
 316         return name.compareTo(other.name);
 317     }
 318 
 319     /**
 320      * Return a string that describes this field.
 321      */
 322     public String toString() {
 323         return signature + ' ' + name;
 324     }
 325 
 326     /**
 327      * Returns field represented by this ObjectStreamField, or null if
 328      * ObjectStreamField is not associated with an actual field.
 329      */
 330     Field getField() {
 331         return field;
 332     }
 333 
 334     /**
 335      * Returns JVM type signature of field (similar to getTypeString, except
 336      * that signature strings are returned for primitive fields as well).
 337      */
 338     String getSignature() {
 339         return signature;








 340     }
 341 }


  29 import jdk.internal.reflect.CallerSensitive;
  30 import jdk.internal.reflect.Reflection;
  31 import sun.reflect.misc.ReflectUtil;
  32 
  33 /**
  34  * A description of a Serializable field from a Serializable class.  An array
  35  * of ObjectStreamFields is used to declare the Serializable fields of a class.
  36  *
  37  * @author      Mike Warres
  38  * @author      Roger Riggs
  39  * @see ObjectStreamClass
  40  * @since 1.2
  41  */
  42 public class ObjectStreamField
  43     implements Comparable<Object>
  44 {
  45 
  46     /** field name */
  47     private final String name;
  48     /** canonical JVM signature of field type */
  49     private volatile String signature;
  50     /** field type (Object.class if unknown non-primitive type) */
  51     private final Class<?> type;
  52     /** whether or not to (de)serialize field values as unshared */
  53     private final boolean unshared;
  54     /** corresponding reflective field object, if any */
  55     private final Field field;
  56     /** offset of field value in enclosing field group */
  57     private int offset;
  58 
  59     /**
  60      * Create a Serializable field with the specified type.  This field should
  61      * be documented with a <code>serialField</code> tag.
  62      *
  63      * @param   name the name of the serializable field
  64      * @param   type the <code>Class</code> object of the serializable field
  65      */
  66     public ObjectStreamField(String name, Class<?> type) {
  67         this(name, type, false);
  68     }
  69 
  70     /**
  71      * Creates an ObjectStreamField representing a serializable field with the
  72      * given name and type.  If unshared is false, values of the represented
  73      * field are serialized and deserialized in the default manner--if the
  74      * field is non-primitive, object values are serialized and deserialized as
  75      * if they had been written and read by calls to writeObject and
  76      * readObject.  If unshared is true, values of the represented field are
  77      * serialized and deserialized as if they had been written and read by
  78      * calls to writeUnshared and readUnshared.
  79      *
  80      * @param   name field name
  81      * @param   type field type
  82      * @param   unshared if false, write/read field values in the same manner
  83      *          as writeObject/readObject; if true, write/read in the same
  84      *          manner as writeUnshared/readUnshared
  85      * @since   1.4
  86      */
  87     public ObjectStreamField(String name, Class<?> type, boolean unshared) {
  88         if (name == null) {
  89             throw new NullPointerException();
  90         }
  91         this.name = name;
  92         this.type = type;
  93         this.unshared = unshared;
  94         this.field = null;

  95     }
  96 
  97     /**
  98      * Creates an ObjectStreamField representing a field with the given name,
  99      * signature and unshared setting.
 100      */
 101     ObjectStreamField(String name, String signature, boolean unshared) {
 102         if (name == null) {
 103             throw new NullPointerException();
 104         }
 105         this.name = name;
 106         this.signature = signature.intern();
 107         this.unshared = unshared;
 108         this.field = null;
 109 
 110         switch (signature.charAt(0)) {
 111             case 'Z': type = Boolean.TYPE; break;
 112             case 'B': type = Byte.TYPE; break;
 113             case 'C': type = Character.TYPE; break;
 114             case 'S': type = Short.TYPE; break;
 115             case 'I': type = Integer.TYPE; break;
 116             case 'J': type = Long.TYPE; break;
 117             case 'F': type = Float.TYPE; break;
 118             case 'D': type = Double.TYPE; break;
 119             case 'L':
 120             case '[': type = Object.class; break;
 121             default: throw new IllegalArgumentException("illegal signature");
 122         }
 123     }
 124 
 125     /**
 126      * Returns JVM type signature for given primitive.
 127      */
 128     private static String getPrimitiveSignature(Class<?> cl) {


 224 
 225     /**
 226      * Returns character encoding of field type.  The encoding is as follows:
 227      * <blockquote><pre>
 228      * B            byte
 229      * C            char
 230      * D            double
 231      * F            float
 232      * I            int
 233      * J            long
 234      * L            class or interface
 235      * S            short
 236      * Z            boolean
 237      * [            array
 238      * </pre></blockquote>
 239      *
 240      * @return  the typecode of the serializable field
 241      */
 242     // REMIND: deprecate?
 243     public char getTypeCode() {
 244         return getSignature().charAt(0);
 245     }
 246 
 247     /**
 248      * Return the JVM type signature.
 249      *
 250      * @return  null if this field has a primitive type.
 251      */
 252     // REMIND: deprecate?
 253     public String getTypeString() {
 254         return isPrimitive() ? null : getSignature();
 255     }
 256 
 257     /**
 258      * Offset of field within instance data.
 259      *
 260      * @return  the offset of this field
 261      * @see #setOffset
 262      */
 263     // REMIND: deprecate?
 264     public int getOffset() {
 265         return offset;
 266     }
 267 
 268     /**
 269      * Offset within instance data.
 270      *
 271      * @param   offset the offset of the field
 272      * @see #getOffset
 273      */
 274     // REMIND: deprecate?
 275     protected void setOffset(int offset) {
 276         this.offset = offset;
 277     }
 278 
 279     /**
 280      * Return true if this field has a primitive type.
 281      *
 282      * @return  true if and only if this field corresponds to a primitive type
 283      */
 284     // REMIND: deprecate?
 285     public boolean isPrimitive() {
 286         char tcode = getTypeCode();
 287         return ((tcode != 'L') && (tcode != '['));
 288     }
 289 
 290     /**
 291      * Returns boolean value indicating whether or not the serializable field
 292      * represented by this ObjectStreamField instance is unshared.
 293      *
 294      * @return {@code true} if this field is unshared
 295      *
 296      * @since 1.4
 297      */
 298     public boolean isUnshared() {
 299         return unshared;
 300     }
 301 
 302     /**
 303      * Compare this field with another <code>ObjectStreamField</code>.  Return
 304      * -1 if this is smaller, 0 if equal, 1 if greater.  Types that are
 305      * primitives are "smaller" than object types.  If equal, the field names
 306      * are compared.
 307      */
 308     // REMIND: deprecate?
 309     public int compareTo(Object obj) {
 310         ObjectStreamField other = (ObjectStreamField) obj;
 311         boolean isPrim = isPrimitive();
 312         if (isPrim != other.isPrimitive()) {
 313             return isPrim ? -1 : 1;
 314         }
 315         return name.compareTo(other.name);
 316     }
 317 
 318     /**
 319      * Return a string that describes this field.
 320      */
 321     public String toString() {
 322         return getSignature() + ' ' + name;
 323     }
 324 
 325     /**
 326      * Returns field represented by this ObjectStreamField, or null if
 327      * ObjectStreamField is not associated with an actual field.
 328      */
 329     Field getField() {
 330         return field;
 331     }
 332 
 333     /**
 334      * Returns JVM type signature of field (similar to getTypeString, except
 335      * that signature strings are returned for primitive fields as well).
 336      */
 337     String getSignature() {
 338         String sig = signature;
 339 
 340         // This lazy calculation is safe since sig can be null iff one of the
 341         // public constructors are used, in which case type is always
 342         // initialized to the exact type we want the signature to represent.
 343         if (sig == null) {
 344             signature = sig = getClassSignature(type).intern();
 345         }
 346         return sig;
 347     }
 348 }
< prev index next >