1 /* 2 * Copyright (c) 1996, 2022, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package java.io; 27 28 import java.lang.reflect.Field; 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, if given */ 49 private final String signature; 50 /** field type (Object.class if unknown non-primitive type) */ 51 private final Class<?> type; 52 /** lazily constructed signature for the type, if no explicit signature */ 53 private String typeSignature; 54 /** whether or not to (de)serialize field values as unshared */ 55 private final boolean unshared; 56 /** corresponding reflective field object, if any */ 57 private final Field field; 58 /** offset of field value in enclosing field group */ 59 private int offset; 60 61 /** 62 * Create a Serializable field with the specified type. This field should 63 * be documented with a {@code serialField} tag. 64 * 65 * @param name the name of the serializable field 66 * @param type the {@code Class} object of the serializable field 67 */ 68 public ObjectStreamField(String name, Class<?> type) { 69 this(name, type, false); 70 } 71 72 /** 73 * Creates an ObjectStreamField representing a serializable field with the 74 * given name and type. If unshared is false, values of the represented 75 * field are serialized and deserialized in the default manner--if the 76 * field is non-primitive, object values are serialized and deserialized as 77 * if they had been written and read by calls to writeObject and 78 * readObject. If unshared is true, values of the represented field are 79 * serialized and deserialized as if they had been written and read by 80 * calls to writeUnshared and readUnshared. 81 * 82 * @param name field name 83 * @param type field type 84 * @param unshared if false, write/read field values in the same manner 85 * as writeObject/readObject; if true, write/read in the same 86 * manner as writeUnshared/readUnshared 87 * @since 1.4 88 */ 89 public ObjectStreamField(String name, Class<?> type, boolean unshared) { 90 if (name == null) { 91 throw new NullPointerException(); 92 } 93 this.name = name; 94 this.type = type; 95 this.unshared = unshared; 96 this.field = null; 97 this.signature = null; 98 } 99 100 /** 101 * Creates an ObjectStreamField representing a field with the given name, 102 * signature and unshared setting. 103 */ 104 ObjectStreamField(String name, String signature, boolean unshared) { 105 if (name == null) { 106 throw new NullPointerException(); 107 } 108 this.name = name; 109 this.signature = signature.intern(); 110 this.unshared = unshared; 111 this.field = null; 112 113 type = switch (signature.charAt(0)) { 114 case 'Z' -> Boolean.TYPE; 115 case 'B' -> Byte.TYPE; 116 case 'C' -> Character.TYPE; 117 case 'S' -> Short.TYPE; 118 case 'I' -> Integer.TYPE; 119 case 'J' -> Long.TYPE; 120 case 'F' -> Float.TYPE; 121 case 'D' -> Double.TYPE; 122 case 'L', '[' -> Object.class; 123 default -> throw new IllegalArgumentException("illegal signature"); 124 }; 125 } 126 127 /** 128 * Creates an ObjectStreamField representing the given field with the 129 * specified unshared setting. For compatibility with the behavior of 130 * earlier serialization implementations, a "showType" parameter is 131 * necessary to govern whether or not a getType() call on this 132 * ObjectStreamField (if non-primitive) will return Object.class (as 133 * opposed to a more specific reference type). 134 */ 135 ObjectStreamField(Field field, boolean unshared, boolean showType) { 136 this.field = field; 137 this.unshared = unshared; 138 name = field.getName(); 139 Class<?> ftype = field.getType(); 140 type = (showType || ftype.isPrimitive()) ? ftype : Object.class; 141 signature = ftype.descriptorString().intern(); 142 } 143 144 /** 145 * Get the name of this field. 146 * 147 * @return a {@code String} representing the name of the serializable 148 * field 149 */ 150 public String getName() { 151 return name; 152 } 153 154 /** 155 * Get the type of the field. If the type is non-primitive and this 156 * {@code ObjectStreamField} was obtained from a deserialized {@link 157 * ObjectStreamClass} instance, then {@code Object.class} is returned. 158 * Otherwise, the {@code Class} object for the type of the field is 159 * returned. 160 * 161 * @return a {@code Class} object representing the type of the 162 * serializable field 163 */ 164 @SuppressWarnings("removal") 165 @CallerSensitive 166 public Class<?> getType() { 167 if (System.getSecurityManager() != null) { 168 Class<?> caller = Reflection.getCallerClass(); 169 if (ReflectUtil.needsPackageAccessCheck(caller.getClassLoader(), type.getClassLoader())) { 170 ReflectUtil.checkPackageAccess(type); 171 } 172 } 173 return type; 174 } 175 176 /** 177 * Returns character encoding of field type. The encoding is as follows: 178 * <blockquote><pre> 179 * B byte 180 * C char 181 * D double 182 * F float 183 * I int 184 * J long 185 * L class or interface 186 * S short 187 * Z boolean 188 * [ array 189 * </pre></blockquote> 190 * 191 * @return the typecode of the serializable field 192 */ 193 // REMIND: deprecate? 194 public char getTypeCode() { 195 return getSignature().charAt(0); 196 } 197 198 /** 199 * Return the JVM type signature. 200 * 201 * @return null if this field has a primitive type. 202 */ 203 // REMIND: deprecate? 204 public String getTypeString() { 205 return isPrimitive() ? null : getSignature(); 206 } 207 208 /** 209 * Offset of field within instance data. 210 * 211 * @return the offset of this field 212 * @see #setOffset 213 */ 214 // REMIND: deprecate? 215 public int getOffset() { 216 return offset; 217 } 218 219 /** 220 * Offset within instance data. 221 * 222 * @param offset the offset of the field 223 * @see #getOffset 224 */ 225 // REMIND: deprecate? 226 protected void setOffset(int offset) { 227 this.offset = offset; 228 } 229 230 /** 231 * Return true if this field has a primitive type. 232 * 233 * @return true if and only if this field corresponds to a primitive type 234 */ 235 // REMIND: deprecate? 236 public boolean isPrimitive() { 237 char tcode = getTypeCode(); 238 return ((tcode != 'L') && (tcode != '[')); 239 } 240 241 /** 242 * Returns boolean value indicating whether or not the serializable field 243 * represented by this ObjectStreamField instance is unshared. 244 * 245 * @return {@code true} if this field is unshared 246 * 247 * @since 1.4 248 */ 249 public boolean isUnshared() { 250 return unshared; 251 } 252 253 /** 254 * Compare this field with another {@code ObjectStreamField}. Return 255 * -1 if this is smaller, 0 if equal, 1 if greater. Types that are 256 * primitives are "smaller" than object types. If equal, the field names 257 * are compared. 258 */ 259 // REMIND: deprecate? 260 public int compareTo(Object obj) { 261 ObjectStreamField other = (ObjectStreamField) obj; 262 boolean isPrim = isPrimitive(); 263 if (isPrim != other.isPrimitive()) { 264 return isPrim ? -1 : 1; 265 } 266 return name.compareTo(other.name); 267 } 268 269 /** 270 * Return a string that describes this field. 271 */ 272 public String toString() { 273 return getSignature() + ' ' + name; 274 } 275 276 /** 277 * Returns field represented by this ObjectStreamField, or null if 278 * ObjectStreamField is not associated with an actual field. 279 */ 280 Field getField() { 281 return field; 282 } 283 284 /** 285 * Returns JVM type signature of field (similar to getTypeString, except 286 * that signature strings are returned for primitive fields as well). 287 */ 288 String getSignature() { 289 if (signature != null) { 290 return signature; 291 } 292 293 String sig = typeSignature; 294 // This lazy calculation is safe since signature can be null iff one 295 // of the public constructors are used, in which case type is always 296 // initialized to the exact type we want the signature to represent. 297 if (sig == null) { 298 typeSignature = sig = type.descriptorString().intern(); 299 } 300 return sig; 301 } 302 } --- EOF ---