1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
/* * @(#)ObjectStreamField.java 1.47 06/04/07 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.io; import java.lang.reflect.Field; /** * A description of a Serializable field from a Serializable class. An array * of ObjectStreamFields is used to declare the Serializable fields of a class. * * @author Mike Warres * @author Roger Riggs * @version 1.47, 06/04/07 * @see ObjectStreamClass * @since 1.2 */ public class ObjectStreamField implements Comparable<Object> { /** field name */ private final String name; /** canonical JVM signature of field type */ private final String signature; /** field type (Object.class if unknown non-primitive type) */ private final Class type; /** whether or not to (de)serialize field values as unshared */ private final boolean unshared; /** corresponding reflective field object, if any */ private final Field field; /** offset of field value in enclosing field group */ private int offset = 0; /** * Create a Serializable field with the specified type. This field should * be documented with a <code>serialField</code> tag. * * @param name the name of the serializable field * @param type the <code>Class</code> object of the serializable field */ public ObjectStreamField(String name, Class<?> type) { this(name, type, false); } /** * Creates an ObjectStreamField representing a serializable field with the * given name and type. If unshared is false, values of the represented * field are serialized and deserialized in the default manner--if the * field is non-primitive, object values are serialized and deserialized as * if they had been written and read by calls to writeObject and * readObject. If unshared is true, values of the represented field are * serialized and deserialized as if they had been written and read by * calls to writeUnshared and readUnshared. * * @param name field name * @param type field type * @param unshared if false, write/read field values in the same manner * as writeObject/readObject; if true, write/read in the same * manner as writeUnshared/readUnshared * @since 1.4 */ public ObjectStreamField(String name, Class<?> type, boolean unshared) { if (name == null) { throw new NullPointerException(); } this.name = name; this.type = type; this.unshared = unshared; signature = ObjectStreamClass.getClassSignature(type).intern(); field = null; } /** * Creates an ObjectStreamField representing a field with the given name, * signature and unshared setting. */ ObjectStreamField(String name, String signature, boolean unshared) { if (name == null) { throw new NullPointerException(); } this.name = name; this.signature = signature.intern(); this.unshared = unshared; field = null; switch (signature.charAt(0)) { case 'Z': type = Boolean.TYPE; break; case 'B': type = Byte.TYPE; break; case 'C': type = Character.TYPE; break; case 'S': type = Short.TYPE; break; case 'I': type = Integer.TYPE; break; case 'J': type = Long.TYPE; break; case 'F': type = Float.TYPE; break; case 'D': type = Double.TYPE; break; case 'L': case '[': type = Object.class; break; default: throw new IllegalArgumentException("illegal signature"); } } /** * Creates an ObjectStreamField representing the given field with the * specified unshared setting. For compatibility with the behavior of * earlier serialization implementations, a "showType" parameter is * necessary to govern whether or not a getType() call on this * ObjectStreamField (if non-primitive) will return Object.class (as * opposed to a more specific reference type). */ ObjectStreamField(Field field, boolean unshared, boolean showType) { this.field = field; this.unshared = unshared; name = field.getName(); Class ftype = field.getType(); type = (showType || ftype.isPrimitive()) ? ftype : Object.class; signature = ObjectStreamClass.getClassSignature(ftype).intern(); } /** * Get the name of this field. * * @return a <code>String</code> representing the name of the serializable * field */ public String getName() { return name; } /** * Get the type of the field. If the type is non-primitive and this * <code>ObjectStreamField</code> was obtained from a deserialized {@link * ObjectStreamClass} instance, then <code>Object.class</code> is returned. * Otherwise, the <code>Class</code> object for the type of the field is * returned. * * @return a <code>Class</code> object representing the type of the * serializable field */ public Class<?> getType() { return type; } /** * Returns character encoding of field type. The encoding is as follows: * <blockquote><pre> * B byte * C char * D double * F float * I int * J long * L class or interface * S short * Z boolean * [ array * </pre></blockquote> * * @return the typecode of the serializable field */ // REMIND: deprecate? public char getTypeCode() { return signature.charAt(0); } /** * Return the JVM type signature. * * @return null if this field has a primitive type. */ // REMIND: deprecate? public String getTypeString() { return isPrimitive() ? null : signature; } /** * Offset of field within instance data. * * @return the offset of this field * @see #setOffset */ // REMIND: deprecate? public int getOffset() { return offset; } /** * Offset within instance data. * * @param offset the offset of the field * @see #getOffset */ // REMIND: deprecate? protected void setOffset(int offset) { this.offset = offset; } /** * Return true if this field has a primitive type. * * @return true if and only if this field corresponds to a primitive type */ // REMIND: deprecate? public boolean isPrimitive() { char tcode = signature.charAt(0); return ((tcode != 'L') && (tcode != '[')); } /** * Returns boolean value indicating whether or not the serializable field * represented by this ObjectStreamField instance is unshared. * * @since 1.4 */ public boolean isUnshared() { return unshared; } /** * Compare this field with another <code>ObjectStreamField</code>. Return * -1 if this is smaller, 0 if equal, 1 if greater. Types that are * primitives are "smaller" than object types. If equal, the field names * are compared. */ // REMIND: deprecate? public int compareTo(Object obj) { ObjectStreamField other = (ObjectStreamField) obj; boolean isPrim = isPrimitive(); if (isPrim != other.isPrimitive()) { return isPrim ? -1 : 1; } return name.compareTo(other.name); } /** * Return a string that describes this field. */ public String toString() { return signature + ' ' + name; } /** * Returns field represented by this ObjectStreamField, or null if * ObjectStreamField is not associated with an actual field. */ Field getField() { return field; } /** * Returns JVM type signature of field (similar to getTypeString, except * that signature strings are returned for primitive fields as well). */ String getSignature() { return signature; } }