1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package javax.jdo.pc;
18
19 import java.io.*;
20 import java.util.*;
21 import javax.jdo.PersistenceManager;
22 import javax.jdo.spi.*;
23
24 import javax.jdo.spi.PersistenceCapable;
25
26 /***
27 * This is a hand-enhanced version of a simple class with two fields. The
28 * enhanced code assumes datastore identity.
29 *
30 * @version 2.0
31 */
32 public class PCPoint
33 implements PersistenceCapable
34 {
35 public int x;
36 public Integer y;
37
38
39 protected transient StateManager jdoStateManager;
40 protected transient byte jdoFlags;
41 private static final int jdoInheritedFieldCount = 0;
42 private static final String jdoFieldNames[] = { "x", "y" };
43 private static final Class jdoFieldTypes[];
44 private static final byte jdoFieldFlags[] = {
45 (byte)(PersistenceCapable.CHECK_READ + PersistenceCapable.CHECK_WRITE +
46 PersistenceCapable.SERIALIZABLE),
47 (byte)(PersistenceCapable.CHECK_READ + PersistenceCapable.CHECK_WRITE +
48 PersistenceCapable.SERIALIZABLE),
49 };
50 private static final Class jdoPersistenceCapableSuperclass;
51
52 static
53 {
54 jdoFieldTypes = (new Class[] {
55 Integer.TYPE, sunjdo$classForName$("java.lang.Integer")
56 });
57 jdoPersistenceCapableSuperclass = null;
58 JDOImplHelper.registerClass(
59 sunjdo$classForName$("javax.jdo.pc.PCPoint"),
60 jdoFieldNames, jdoFieldTypes, jdoFieldFlags,
61 jdoPersistenceCapableSuperclass, new PCPoint());
62 }
63
64 /*** JDO required no-args constructor. */
65 public PCPoint() { }
66
67 /*** Constructor. */
68 public PCPoint(int x, Integer y) {
69 jdoSetx(this, x);
70 jdoSety(this, y);
71 }
72
73 /*** */
74 public void setX(int x) {
75 jdoSetx(this, x);
76 }
77
78 /*** */
79 public int getX() {
80 return jdoGetx(this);
81 }
82
83 /*** */
84 public void setY(Integer y) {
85 jdoSety(this, y);
86 }
87
88 /*** */
89 public Integer getY() {
90 return jdoGety(this);
91 }
92
93 /*** */
94 public boolean equals(Object o) {
95 if (o == null || !(o instanceof PCPoint))
96 return false;
97 PCPoint other = (PCPoint)o;
98 if (jdoGetx(this) != jdoGetx(other))
99 return false;
100 if (jdoGety(this) == null)
101 return jdoGety(other) == null;
102 if (jdoGety(other) == null)
103 return jdoGety(this) == null;
104 else
105 return jdoGety(this).intValue() == jdoGety(other).intValue();
106 }
107
108 /*** */
109 public int hashCode() {
110 int code = getX();
111 if (getY() != null) {
112 code += getY().intValue();
113 }
114 return code;
115 }
116
117 /*** */
118 public String toString() {
119 return "PCPoint(x: " + getX() + ", y: " + getY() + ")";
120 }
121
122
123
124
125 public final boolean jdoIsPersistent() {
126 StateManager statemanager = jdoStateManager;
127 if (statemanager != null)
128 return statemanager.isPersistent(this);
129 else
130 return false;
131 }
132
133 public final boolean jdoIsTransactional() {
134 StateManager statemanager = jdoStateManager;
135 if (statemanager != null)
136 return statemanager.isTransactional(this);
137 else
138 return false;
139 }
140
141 public final boolean jdoIsNew() {
142 StateManager statemanager = jdoStateManager;
143 if (statemanager != null)
144 return statemanager.isNew(this);
145 else
146 return false;
147 }
148
149 public final boolean jdoIsDirty() {
150 StateManager statemanager = jdoStateManager;
151 if (statemanager != null)
152 return statemanager.isDirty(this);
153 else
154 return false;
155 }
156
157 public final boolean jdoIsDeleted() {
158 StateManager statemanager = jdoStateManager;
159 if (statemanager != null)
160 return statemanager.isDeleted(this);
161 else
162 return false;
163 }
164
165 public final boolean jdoIsDetached() {
166 return false;
167 }
168
169 public final void jdoMakeDirty(String s) {
170 StateManager statemanager = jdoStateManager;
171 if (statemanager != null)
172 statemanager.makeDirty(this, s);
173 }
174
175 public final PersistenceManager jdoGetPersistenceManager() {
176 StateManager statemanager = jdoStateManager;
177 if (statemanager != null)
178 return statemanager.getPersistenceManager(this);
179 else
180 return null;
181 }
182
183 public final Object jdoGetObjectId() {
184 StateManager statemanager = jdoStateManager;
185 if (statemanager != null)
186 return statemanager.getObjectId(this);
187 else
188 return null;
189 }
190
191 public final Object jdoGetTransactionalObjectId() {
192 StateManager statemanager = jdoStateManager;
193 if (statemanager != null)
194 return statemanager.getTransactionalObjectId(this);
195 else
196 return null;
197 }
198
199 public final Object jdoGetVersion() {
200 StateManager statemanager = jdoStateManager;
201 if (statemanager != null)
202 return statemanager.getVersion(this);
203 else
204 return null;
205 }
206
207 public final synchronized void jdoReplaceStateManager(
208 StateManager statemanager) {
209 StateManager statemanager1 = jdoStateManager;
210 if (statemanager1 != null) {
211 jdoStateManager = statemanager1.replacingStateManager(
212 this, statemanager);
213 return;
214 }
215 else {
216 JDOImplHelper.checkAuthorizedStateManager(statemanager);
217 jdoStateManager = statemanager;
218 jdoFlags = PersistenceCapable.LOAD_REQUIRED;
219 return;
220 }
221 }
222
223 public final void jdoReplaceFlags() {
224 StateManager statemanager = jdoStateManager;
225 if (statemanager != null)
226 jdoFlags = statemanager.replacingFlags(this);
227 }
228
229 public final void jdoReplaceFields(int fields[]) {
230 if (fields == null)
231 throw new IllegalArgumentException("fields is null");
232 int i = fields.length;
233 for(int j = 0; j < i; j++)
234 jdoReplaceField(fields[j]);
235
236 }
237
238 public final void jdoProvideFields(int fields[]) {
239 if (fields == null)
240 throw new IllegalArgumentException("fields is null");
241 int i = fields.length;
242 for(int j = 0; j < i; j++)
243 jdoProvideField(fields[j]);
244
245 }
246
247 protected final void jdoPreSerialize() {
248 StateManager statemanager = jdoStateManager;
249 if (statemanager != null)
250 statemanager.preSerialize(this);
251 }
252
253
254
255
256 public void jdoCopyKeyFieldsToObjectId(
257 PersistenceCapable.ObjectIdFieldSupplier objectidfieldsupplier,
258 Object obj) { }
259
260 public void jdoCopyKeyFieldsToObjectId(Object obj) {
261 }
262
263 public void jdoCopyKeyFieldsFromObjectId(
264 PersistenceCapable.ObjectIdFieldConsumer objectidfieldconsumer,
265 Object obj) { }
266
267 protected void jdoCopyKeyFieldsFromObjectId(Object obj) {
268 }
269
270 public Object jdoNewObjectIdInstance() {
271 return null;
272 }
273
274 public Object jdoNewObjectIdInstance(Object o) {
275 return null;
276 }
277
278
279
280 public PersistenceCapable jdoNewInstance(StateManager statemanager) {
281 PCPoint pcpoint = new PCPoint();
282 pcpoint.jdoFlags = PersistenceCapable.LOAD_REQUIRED;
283 pcpoint.jdoStateManager = statemanager;
284 return pcpoint;
285 }
286
287 public PersistenceCapable jdoNewInstance(
288 StateManager statemanager, Object obj) {
289 PCPoint pcpoint = new PCPoint();
290 pcpoint.jdoCopyKeyFieldsFromObjectId(obj);
291 pcpoint.jdoFlags = PersistenceCapable.LOAD_REQUIRED;
292 pcpoint.jdoStateManager = statemanager;
293 return pcpoint;
294 }
295
296 protected static int jdoGetManagedFieldCount() {
297 return 2;
298 }
299
300 public static final int jdoGetx(PCPoint pcpoint) {
301 if (pcpoint.jdoFlags <= PersistenceCapable.READ_WRITE_OK)
302 return pcpoint.x;
303 StateManager statemanager = pcpoint.jdoStateManager;
304 if (statemanager == null)
305 return pcpoint.x;
306 if (statemanager.isLoaded(pcpoint, jdoInheritedFieldCount + 0))
307 return pcpoint.x;
308 else
309 return statemanager.getIntField(
310 pcpoint, jdoInheritedFieldCount + 0, pcpoint.x);
311 }
312
313 public static final Integer jdoGety(PCPoint pcpoint) {
314 if (pcpoint.jdoFlags <= PersistenceCapable.READ_WRITE_OK)
315 return pcpoint.y;
316 StateManager statemanager = pcpoint.jdoStateManager;
317 if (statemanager == null)
318 return pcpoint.y;
319 if (statemanager.isLoaded(pcpoint, jdoInheritedFieldCount + 1))
320 return pcpoint.y;
321 else
322 return (Integer)statemanager.getObjectField(
323 pcpoint, jdoInheritedFieldCount + 1, pcpoint.y);
324 }
325
326 public static final void jdoSetx(PCPoint pcpoint, int i) {
327 if (pcpoint.jdoFlags == PersistenceCapable.READ_WRITE_OK) {
328 pcpoint.x = i;
329 return;
330 }
331 StateManager statemanager = pcpoint.jdoStateManager;
332 if (statemanager == null) {
333 pcpoint.x = i;
334 return;
335 }
336 else {
337 statemanager.setIntField(
338 pcpoint, jdoInheritedFieldCount + 0, pcpoint.x, i);
339 return;
340 }
341 }
342
343 public static final void jdoSety(PCPoint pcpoint, Integer integer) {
344 if (pcpoint.jdoFlags == PersistenceCapable.READ_WRITE_OK) {
345 pcpoint.y = integer;
346 return;
347 }
348 StateManager statemanager = pcpoint.jdoStateManager;
349 if (statemanager == null) {
350 pcpoint.y = integer;
351 return;
352 }
353 else {
354 statemanager.setObjectField(pcpoint, jdoInheritedFieldCount + 1, pcpoint.y, integer);
355 return;
356 }
357 }
358
359 public void jdoReplaceField(int field) {
360 StateManager statemanager = jdoStateManager;
361 switch(field - jdoInheritedFieldCount) {
362 case 0:
363 if (statemanager == null) {
364 throw new IllegalStateException("jdoStateManager is null");
365 }
366 else {
367 x = statemanager.replacingIntField(this, field);
368 return;
369 }
370 case 1:
371 if (statemanager == null) {
372 throw new IllegalStateException("jdoStateManager is null");
373 }
374 else {
375 y = (Integer)statemanager.replacingObjectField(this, field);
376 return;
377 }
378 }
379 throw new IllegalArgumentException("field number out of range");
380 }
381
382 public void jdoProvideField(int field) {
383 StateManager statemanager = jdoStateManager;
384 switch(field - jdoInheritedFieldCount) {
385 case 0:
386 if (statemanager == null) {
387 throw new IllegalStateException("jdoStateManager is null");
388 }
389 else {
390 statemanager.providedIntField(this, field, x);
391 return;
392 }
393 case 1:
394 if (statemanager == null) {
395 throw new IllegalStateException("jdoStateManager is null");
396 }
397 else {
398 statemanager.providedObjectField(this, field, y);
399 return;
400 }
401 }
402 throw new IllegalArgumentException("field number out of range");
403 }
404
405 public void jdoCopyFields(Object obj, int fieldNumbers[]) {
406 if (jdoStateManager == null)
407 throw new IllegalStateException("jdoStateManager is null");
408 if (!(obj instanceof PCPoint))
409 throw new ClassCastException(obj.getClass().getName());
410 if (fieldNumbers == null)
411 throw new IllegalArgumentException("fieldNumber is null");
412 PCPoint pcpoint = (PCPoint)obj;
413 if (pcpoint.jdoStateManager != jdoStateManager)
414 throw new IllegalArgumentException("wrong jdoStateManager");
415 int i = fieldNumbers.length;
416 for(int j = 0; j < i; j++)
417 jdoCopyField(pcpoint, fieldNumbers[j]);
418 }
419
420 protected final void jdoCopyField(PCPoint pcpoint, int fieldNumber)
421 {
422 switch(fieldNumber - jdoInheritedFieldCount) {
423 case 0:
424 if (pcpoint == null) {
425 throw new IllegalArgumentException("pcpoint is null");
426 }
427 else {
428 x = pcpoint.x;
429 return;
430 }
431 case 1:
432 if (pcpoint == null) {
433 throw new IllegalArgumentException("pcpoint is null");
434 }
435 else {
436 y = pcpoint.y;
437 return;
438 }
439 }
440 throw new IllegalArgumentException("field number out of range");
441 }
442
443 private void writeObject(java.io.ObjectOutputStream out)
444 throws java.io.IOException {
445 jdoPreSerialize();
446 out.defaultWriteObject();
447 }
448
449 protected static final Class sunjdo$classForName$(String s) {
450 try {
451 return Class.forName(s);
452 }
453 catch(ClassNotFoundException ex) {
454 throw new NoClassDefFoundError(ex.getMessage());
455 }
456 }
457
458
459
460 }