1   /*
2    * Copyright 2005 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at 
7    * 
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software 
11   * distributed under the License is distributed on an "AS IS" BASIS, 
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
13   * See the License for the specific language governing permissions and 
14   * limitations under the License.
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      // JDO generated fields
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     // Generated methods in least-derived PersistenceCapable class
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     // Generated methods in PersistenceCapable root classes and all classes
254     // that declare objectid-class in xml metadata:
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     // Generated methods in all PersistenceCapable classes
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 }