API Overview API Index Package Overview Direct link to this page
JDK 1.6
  java.io. ObjectStreamField View Javadoc
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;
    }
}

Generated By: JavaOnTracks Doclet 0.1.4     ©Thibaut Colar