BaseIssueVote


1   package org.tigris.scarab.om;
2   
3   
4   import java.math.BigDecimal  ;
5   import java.sql.Connection  ;
6   import java.util.ArrayList  ;
7   import java.util.Collections  ;
8   import java.util.Date  ;
9   import java.util.List  ;
10  
11  import org.apache.commons.lang.ObjectUtils;
12  import org.apache.fulcrum.intake.Retrievable;
13  import org.apache.torque.TorqueException;
14  import org.apache.torque.om.BaseObject;
15  import org.apache.torque.om.ComboKey;
16  import org.apache.torque.om.DateKey;
17  import org.apache.torque.om.NumberKey;
18  import org.apache.torque.om.ObjectKey;
19  import org.apache.torque.om.SimpleKey;
20  import org.apache.torque.om.StringKey;
21  import org.apache.torque.om.Persistent;
22  import org.apache.torque.util.Criteria;
23  import org.apache.torque.util.Transaction;
24  
25    
26        
27    
28  /**
29   * You should not use this class directly.  It should not even be
30   * extended all references should be to IssueVote
31   */
32  public abstract class BaseIssueVote extends BaseObject
33      implements org.apache.fulcrum.intake.Retrievable
34  {
35      /** The Peer class */
36      private static final IssueVotePeer peer =
37          new IssueVotePeer();
38  
39          
40      /** The value for the issueId field */
41      private Long   issueId;
42        
43      /** The value for the userId field */
44      private Integer   userId;
45                                            
46      /** The value for the votes field */
47      private int votes = 0;
48    
49      
50      /**
51       * Get the IssueId
52       *
53       * @return Long
54       */
55      public Long   getIssueId()
56      {
57          return issueId;
58      }
59  
60                                
61      /**
62       * Set the value of IssueId
63       *
64       * @param v new value
65       */
66      public void setIssueId(Long   v) throws TorqueException
67      {
68      
69                    if (!ObjectUtils.equals(this.issueId, v))
70                {
71              this.issueId = v;
72              setModified(true);
73          }
74      
75                                    
76                  if (aIssue != null && !ObjectUtils.equals(aIssue.getIssueId(), v))
77                  {
78              aIssue = null;
79          }
80        
81                }
82    
83      /**
84       * Get the UserId
85       *
86       * @return Integer
87       */
88      public Integer   getUserId()
89      {
90          return userId;
91      }
92  
93                                
94      /**
95       * Set the value of UserId
96       *
97       * @param v new value
98       */
99      public void setUserId(Integer   v) throws TorqueException
100     {
101     
102                   if (!ObjectUtils.equals(this.userId, v))
103               {
104             this.userId = v;
105             setModified(true);
106         }
107     
108                                           
109                 if (aScarabUser != null && !ObjectUtils.equals(aScarabUser.getUserId(), v))
110                 {
111             aScarabUser = null;
112         }
113       
114               }
115   
116     /**
117      * Get the Votes
118      *
119      * @return int
120      */
121     public int getVotes()
122     {
123         return votes;
124     }
125 
126                         
127     /**
128      * Set the value of Votes
129      *
130      * @param v new value
131      */
132     public void setVotes(int v) 
133     {
134     
135                   if (this.votes != v)
136               {
137             this.votes = v;
138             setModified(true);
139         }
140     
141           
142               }
143   
144       
145         
146                   
147         private Issue aIssue;
148 
149     /**
150      * Declares an association between this object and a Issue object
151      *
152      * @param v Issue
153      * @throws TorqueException
154      */
155     public void setIssue(Issue v) throws TorqueException
156     {
157             if (v == null)
158         {
159                   setIssueId((Long  ) null);
160               }
161         else
162         {
163             setIssueId(v.getIssueId());
164         }
165             aIssue = v;
166     }
167 
168                         
169     /**
170      * Get the associated Issue object
171      *
172      * @return the associated Issue object
173      * @throws TorqueException
174      */
175     public Issue getIssue() throws TorqueException
176     {
177         if ( !ObjectUtils.equals(getIssueId(), null) )
178         {
179                 return IssueManager.getInstance(SimpleKey.keyFor(getIssueId()));
180             }
181         return aIssue;
182     }
183 
184     /**
185      * Provides convenient way to set a relationship based on a
186      * ObjectKey, for example
187      * <code>bar.setFooKey(foo.getPrimaryKey())</code>
188      *
189          */
190     public void setIssueKey(ObjectKey key) throws TorqueException
191     {
192     
193                     setIssueId(new Long  (((NumberKey) key).longValue()));
194               }
195   
196             
197                   
198         private ScarabUser aScarabUser;
199 
200     /**
201      * Declares an association between this object and a ScarabUser object
202      *
203      * @param v ScarabUser
204      * @throws TorqueException
205      */
206     public void setScarabUser(ScarabUser v) throws TorqueException
207     {
208             if (v == null)
209         {
210                   setUserId((Integer  ) null);
211               }
212         else
213         {
214             setUserId(v.getUserId());
215         }
216             aScarabUser = v;
217     }
218 
219                         
220     /**
221      * Get the associated ScarabUser object
222      *
223      * @return the associated ScarabUser object
224      * @throws TorqueException
225      */
226     public ScarabUser getScarabUser() throws TorqueException
227     {
228         if ( !ObjectUtils.equals(getUserId(), null) )
229         {
230                 return ScarabUserManager.getInstance(SimpleKey.keyFor(getUserId()));
231             }
232         return aScarabUser;
233     }
234 
235     /**
236      * Provides convenient way to set a relationship based on a
237      * ObjectKey, for example
238      * <code>bar.setFooKey(foo.getPrimaryKey())</code>
239      *
240          */
241     public void setScarabUserKey(ObjectKey key) throws TorqueException
242     {
243     
244                     setUserId(new Integer  (((NumberKey) key).intValue()));
245               }
246      
247                 
248     private static List   fieldNames = null;
249 
250     /**
251      * Generate a list of field names.
252      *
253      * @return a list of field names
254      */
255     public static synchronized List   getFieldNames()
256     {
257         if (fieldNames == null)
258         {
259             fieldNames = new ArrayList  ();
260               fieldNames.add("IssueId");
261               fieldNames.add("UserId");
262               fieldNames.add("Votes");
263               fieldNames = Collections.unmodifiableList(fieldNames);
264         }
265         return fieldNames;
266     }
267 
268     /**
269      * Retrieves a field from the object by name passed in as a String.
270      *
271      * @param name field name
272      * @return value
273      */
274     public Object   getByName(String   name)
275     {
276           if (name.equals("IssueId"))
277         {
278                 return getIssueId();
279             }
280           if (name.equals("UserId"))
281         {
282                 return getUserId();
283             }
284           if (name.equals("Votes"))
285         {
286                 return new Integer  (getVotes());
287             }
288           return null;
289     }
290     
291     /**
292      * Retrieves a field from the object by name passed in
293      * as a String.  The String must be one of the static
294      * Strings defined in this Class' Peer.
295      *
296      * @param name peer name
297      * @return value
298      */
299     public Object   getByPeerName(String   name)
300     {
301           if (name.equals(IssueVotePeer.ISSUE_ID))
302         {
303                 return getIssueId();
304             }
305           if (name.equals(IssueVotePeer.USER_ID))
306         {
307                 return getUserId();
308             }
309           if (name.equals(IssueVotePeer.VOTES))
310         {
311                 return new Integer  (getVotes());
312             }
313           return null;
314     }
315 
316     /**
317      * Retrieves a field from the object by Position as specified
318      * in the xml schema.  Zero-based.
319      *
320      * @param pos position in xml schema
321      * @return value
322      */
323     public Object   getByPosition(int pos)
324     {
325             if (pos == 0)
326         {
327                 return getIssueId();
328             }
329               if (pos == 1)
330         {
331                 return getUserId();
332             }
333               if (pos == 2)
334         {
335                 return new Integer  (getVotes());
336             }
337               return null;
338     }
339      
340     /**
341      * Stores the object in the database.  If the object is new,
342      * it inserts it; otherwise an update is performed.
343      *
344      * @throws Exception
345      */
346     public void save() throws Exception  
347     {
348           save(IssueVotePeer.getMapBuilder()
349                 .getDatabaseMap().getName());
350       }
351 
352     /**
353      * Stores the object in the database.  If the object is new,
354      * it inserts it; otherwise an update is performed.
355        * Note: this code is here because the method body is
356      * auto-generated conditionally and therefore needs to be
357      * in this file instead of in the super class, BaseObject.
358        *
359      * @param dbName
360      * @throws TorqueException
361      */
362     public void save(String   dbName) throws TorqueException
363     {
364         Connection   con = null;
365           try
366         {
367             con = Transaction.begin(dbName);
368             save(con);
369             Transaction.commit(con);
370         }
371         catch(TorqueException e)
372         {
373             Transaction.safeRollback(con);
374             throw e;
375         }
376       }
377 
378       /** flag to prevent endless save loop, if this object is referenced
379         by another object which falls in this transaction. */
380     private boolean alreadyInSave = false;
381       /**
382      * Stores the object in the database.  If the object is new,
383      * it inserts it; otherwise an update is performed.  This method
384      * is meant to be used as part of a transaction, otherwise use
385      * the save() method and the connection details will be handled
386      * internally
387      *
388      * @param con
389      * @throws TorqueException
390      */
391     public void save(Connection   con) throws TorqueException
392     {
393           if (!alreadyInSave)
394         {
395             alreadyInSave = true;
396 
397 
398   
399             // If this object has been modified, then save it to the database.
400             if (isModified())
401             {
402                 if (isNew())
403                 {
404                     IssueVotePeer.doInsert((IssueVote)this, con);
405                     setNew(false);
406                 }
407                 else
408                 {
409                     IssueVotePeer.doUpdate((IssueVote)this, con);
410                 }
411 
412                       if (isCacheOnSave())
413                 {
414                     IssueVoteManager.putInstance(this);
415                 }
416               }
417 
418                       alreadyInSave = false;
419         }
420       }
421 
422     /**
423      * Specify whether to cache the object after saving to the db.
424      * This method returns false
425      */
426     protected boolean isCacheOnSave()
427     {
428         return true;
429     }
430 
431                                               
432   
433     private final SimpleKey[] pks = new SimpleKey[2];
434     private final ComboKey comboPK = new ComboKey(pks);
435 
436     /**
437      * Set the PrimaryKey with an ObjectKey
438      *
439      * @param key
440      */
441     public void setPrimaryKey(ObjectKey key) throws TorqueException
442     {
443         SimpleKey[] keys = (SimpleKey[]) key.getValue();
444         SimpleKey tmpKey = null;
445                       setIssueId(new Long  (((NumberKey)keys[0]).longValue()));
446                         setUserId(new Integer  (((NumberKey)keys[1]).intValue()));
447               }
448 
449     /**
450      * Set the PrimaryKey using SimpleKeys.
451      *
452          * @param issueId Long
453          * @param userId Integer
454          */
455     public void setPrimaryKey( Long   issueId, Integer   userId)
456         throws TorqueException 
457     {
458             setIssueId(issueId);
459             setUserId(userId);
460         }
461 
462     /**
463      * Set the PrimaryKey using a String.
464      */
465     public void setPrimaryKey(String   key) throws TorqueException
466     {
467         setPrimaryKey(new ComboKey(key));
468     }
469   
470     /**
471      * returns an id that differentiates this object from others
472      * of its class.
473      */
474     public ObjectKey getPrimaryKey()
475     {
476               pks[0] = SimpleKey.keyFor(getIssueId());
477                   pks[1] = SimpleKey.keyFor(getUserId());
478                   return comboPK;
479       }
480  
481     /**
482      * get an id that differentiates this object from others
483      * of its class.
484      */
485     public String   getQueryKey()
486     {
487         if (getPrimaryKey() == null)
488         {
489             return "";
490         }
491         else
492         {
493             return getPrimaryKey().toString();
494         }
495     }
496 
497     /**
498      * set an id that differentiates this object from others
499      * of its class.
500      */
501     public void setQueryKey(String   key)
502         throws TorqueException
503     {
504         setPrimaryKey(key);
505     }
506 
507     /**
508      * Makes a copy of this object.
509      * It creates a new object filling in the simple attributes.
510        * It then fills all the association collections and sets the
511      * related objects to isNew=true.
512        */
513       public IssueVote copy() throws TorqueException
514     {
515         IssueVote copyObj = new IssueVote();
516             copyObj.setIssueId(issueId);
517           copyObj.setUserId(userId);
518           copyObj.setVotes(votes);
519   
520                       copyObj.setIssueId((Long  )null);
521                                 copyObj.setUserId((Integer  )null);
522                   
523                 return copyObj;
524     }
525 
526     /**
527      * returns a peer instance associated with this om.  Since Peer classes
528      * are not to have any instance attributes, this method returns the
529      * same instance for all member of this class. The method could therefore
530      * be static, but this would prevent one from overriding the behavior.
531      */
532     public IssueVotePeer getPeer()
533     {
534         return peer;
535     }
536 
537     public String   toString()
538     {
539         StringBuffer   str = new StringBuffer  ();
540         str.append("IssueVote:\n");
541         str.append("IssueId = ")
542                .append(getIssueId())
543              .append("\n");
544         str.append("UserId = ")
545                .append(getUserId())
546              .append("\n");
547         str.append("Votes = ")
548                .append(getVotes())
549              .append("\n");
550         return(str.toString());
551     }
552 }
553
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags