BaseScarabUserImpl


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   * You should not use this class directly.  It should not even be
28   * extended all references should be to ScarabUserImpl
29   */
30  public abstract class BaseScarabUserImpl extends org.apache.fulcrum.security.impl.db.entity.TurbineUser
31      implements org.apache.fulcrum.intake.Retrievable
32  {
33      /** The Peer class */
34      private static final ScarabUserImplPeer peer =
35          new ScarabUserImplPeer();
36  
37  
38           
39                                          
40              
41      /**
42       * Collection to store aggregation of collActivitysRelatedByOldUserId
43       */
44      protected List   collActivitysRelatedByOldUserId;
45  
46      /**
47       * Temporary storage of collActivitysRelatedByOldUserId to save a possible db hit in
48       * the event objects are add to the collection, but the
49       * complete collection is never requested.
50       */
51      protected void initActivitysRelatedByOldUserId()
52      {
53          if (collActivitysRelatedByOldUserId == null)
54          {
55              collActivitysRelatedByOldUserId = new ArrayList  ();
56          }
57      }
58  
59                    
60      /**
61       * Method called to associate a Activity object to this object
62       * through the Activity foreign key attribute
63       *
64       * @param l Activity
65       * @throws TorqueException
66       */
67      public void addActivityRelatedByOldUserId(Activity l) throws TorqueException
68      {
69          getActivitysRelatedByOldUserId().add(l);
70          l.setScarabUserRelatedByOldUserId((ScarabUserImpl)this);
71      }
72  
73      /**
74       * The criteria used to select the current contents of collActivitysRelatedByOldUserId
75       */
76      private Criteria lastActivitysRelatedByOldUserIdCriteria = null;
77  
78      /**
79       * If this collection has already been initialized, returns
80       * the collection. Otherwise returns the results of
81       * getActivitysRelatedByOldUserId(new Criteria())
82       *
83       * @throws TorqueException
84       */
85      public List   getActivitysRelatedByOldUserId() throws TorqueException
86      {
87          if (collActivitysRelatedByOldUserId == null)
88          {
89              collActivitysRelatedByOldUserId = getActivitysRelatedByOldUserId(new Criteria(10));
90          }
91          return collActivitysRelatedByOldUserId;
92      }
93  
94      /**
95       * If this collection has already been initialized with
96       * an identical criteria, it returns the collection.
97       * Otherwise if this ScarabUserImpl has previously
98       * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
99       * If this ScarabUserImpl is new, it will return
100      * an empty collection or the current collection, the criteria
101      * is ignored on a new object.
102      *
103      * @throws TorqueException
104      */
105     public List   getActivitysRelatedByOldUserId(Criteria criteria) throws TorqueException
106     {
107         if (collActivitysRelatedByOldUserId == null)
108         {
109             if (isNew())
110             {
111                collActivitysRelatedByOldUserId = new ArrayList  ();
112             }
113             else
114             {
115                       criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
116                       collActivitysRelatedByOldUserId = ActivityPeer.doSelect(criteria);
117             }
118         }
119         else
120         {
121             // criteria has no effect for a new object
122             if (!isNew())
123             {
124                 // the following code is to determine if a new query is
125                 // called for.  If the criteria is the same as the last
126                 // one, just return the collection.
127                       criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
128                       if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
129                 {
130                     collActivitysRelatedByOldUserId = ActivityPeer.doSelect(criteria);
131                 }
132             }
133         }
134         lastActivitysRelatedByOldUserIdCriteria = criteria;
135 
136         return collActivitysRelatedByOldUserId;
137     }
138 
139     /**
140      * If this collection has already been initialized, returns
141      * the collection. Otherwise returns the results of
142      * getActivitysRelatedByOldUserId(new Criteria(),Connection)
143      * This method takes in the Connection also as input so that
144      * referenced objects can also be obtained using a Connection
145      * that is taken as input
146      */
147     public List   getActivitysRelatedByOldUserId(Connection   con) throws TorqueException
148     {
149         if (collActivitysRelatedByOldUserId == null)
150         {
151             collActivitysRelatedByOldUserId = getActivitysRelatedByOldUserId(new Criteria(10),con);
152         }
153         return collActivitysRelatedByOldUserId;
154     }
155 
156     /**
157      * If this collection has already been initialized with
158      * an identical criteria, it returns the collection.
159      * Otherwise if this ScarabUserImpl has previously
160      * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
161      * If this ScarabUserImpl is new, it will return
162      * an empty collection or the current collection, the criteria
163      * is ignored on a new object.
164      * This method takes in the Connection also as input so that
165      * referenced objects can also be obtained using a Connection
166      * that is taken as input
167      */
168     public List   getActivitysRelatedByOldUserId(Criteria criteria,Connection   con) throws TorqueException
169     {
170         if (collActivitysRelatedByOldUserId == null)
171         {
172             if (isNew())
173             {
174                collActivitysRelatedByOldUserId = new ArrayList  ();
175             }
176             else
177             {
178                        criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
179                        collActivitysRelatedByOldUserId = ActivityPeer.doSelect(criteria,con);
180              }
181          }
182          else
183          {
184              // criteria has no effect for a new object
185              if (!isNew())
186              {
187                  // the following code is to determine if a new query is
188                  // called for.  If the criteria is the same as the last
189                  // one, just return the collection.
190                      criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
191                      if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
192                  {
193                      collActivitysRelatedByOldUserId = ActivityPeer.doSelect(criteria,con);
194                  }
195              }
196          }
197          lastActivitysRelatedByOldUserIdCriteria = criteria;
198 
199          return collActivitysRelatedByOldUserId;
200      }
201 
202                                                                   
203               
204                     
205                     
206                                 
207                                                               
208                                         
209                     
210                                 
211           
212     /**
213      * If this collection has already been initialized with
214      * an identical criteria, it returns the collection.
215      * Otherwise if this ScarabUserImpl is new, it will return
216      * an empty collection; or if this ScarabUserImpl has previously
217      * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
218      *
219      * This method is protected by default in order to keep the public
220      * api reasonable.  You can provide public methods for those you
221      * actually need in ScarabUserImpl.
222      */
223     protected List   getActivitysRelatedByOldUserIdJoinIssue(Criteria criteria)
224         throws TorqueException
225     {
226         if (collActivitysRelatedByOldUserId == null)
227         {
228             if (isNew())
229             {
230                collActivitysRelatedByOldUserId = new ArrayList  ();
231             }
232             else
233             {
234                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
235                             collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinIssue(criteria);
236             }
237         }
238         else
239         {
240             // the following code is to determine if a new query is
241             // called for.  If the criteria is the same as the last
242             // one, just return the collection.
243 
244                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
245                         if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
246             {
247                 collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinIssue(criteria);
248             }
249         }
250         lastActivitysRelatedByOldUserIdCriteria = criteria;
251 
252         return collActivitysRelatedByOldUserId;
253     }
254                   
255                     
256                     
257                                 
258                                                               
259                                         
260                     
261                                 
262           
263     /**
264      * If this collection has already been initialized with
265      * an identical criteria, it returns the collection.
266      * Otherwise if this ScarabUserImpl is new, it will return
267      * an empty collection; or if this ScarabUserImpl has previously
268      * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
269      *
270      * This method is protected by default in order to keep the public
271      * api reasonable.  You can provide public methods for those you
272      * actually need in ScarabUserImpl.
273      */
274     protected List   getActivitysRelatedByOldUserIdJoinAttribute(Criteria criteria)
275         throws TorqueException
276     {
277         if (collActivitysRelatedByOldUserId == null)
278         {
279             if (isNew())
280             {
281                collActivitysRelatedByOldUserId = new ArrayList  ();
282             }
283             else
284             {
285                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
286                             collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinAttribute(criteria);
287             }
288         }
289         else
290         {
291             // the following code is to determine if a new query is
292             // called for.  If the criteria is the same as the last
293             // one, just return the collection.
294 
295                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
296                         if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
297             {
298                 collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinAttribute(criteria);
299             }
300         }
301         lastActivitysRelatedByOldUserIdCriteria = criteria;
302 
303         return collActivitysRelatedByOldUserId;
304     }
305                   
306                     
307                     
308                                 
309                                                               
310                                         
311                     
312                                 
313           
314     /**
315      * If this collection has already been initialized with
316      * an identical criteria, it returns the collection.
317      * Otherwise if this ScarabUserImpl is new, it will return
318      * an empty collection; or if this ScarabUserImpl has previously
319      * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
320      *
321      * This method is protected by default in order to keep the public
322      * api reasonable.  You can provide public methods for those you
323      * actually need in ScarabUserImpl.
324      */
325     protected List   getActivitysRelatedByOldUserIdJoinActivitySet(Criteria criteria)
326         throws TorqueException
327     {
328         if (collActivitysRelatedByOldUserId == null)
329         {
330             if (isNew())
331             {
332                collActivitysRelatedByOldUserId = new ArrayList  ();
333             }
334             else
335             {
336                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
337                             collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinActivitySet(criteria);
338             }
339         }
340         else
341         {
342             // the following code is to determine if a new query is
343             // called for.  If the criteria is the same as the last
344             // one, just return the collection.
345 
346                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
347                         if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
348             {
349                 collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinActivitySet(criteria);
350             }
351         }
352         lastActivitysRelatedByOldUserIdCriteria = criteria;
353 
354         return collActivitysRelatedByOldUserId;
355     }
356                   
357                     
358                               
359                                             
360                                                                           
361                                         
362                     
363                                             
364                   
365                     
366                               
367                                             
368                                                                           
369                                         
370                     
371                                 
372           
373     /**
374      * If this collection has already been initialized with
375      * an identical criteria, it returns the collection.
376      * Otherwise if this ScarabUserImpl is new, it will return
377      * an empty collection; or if this ScarabUserImpl has previously
378      * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
379      *
380      * This method is protected by default in order to keep the public
381      * api reasonable.  You can provide public methods for those you
382      * actually need in ScarabUserImpl.
383      */
384     protected List   getActivitysRelatedByOldUserIdJoinScarabUserImplRelatedByNewUserId(Criteria criteria)
385         throws TorqueException
386     {
387         if (collActivitysRelatedByOldUserId == null)
388         {
389             if (isNew())
390             {
391                collActivitysRelatedByOldUserId = new ArrayList  ();
392             }
393             else
394             {
395                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
396                             collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinScarabUserImplRelatedByNewUserId(criteria);
397             }
398         }
399         else
400         {
401             // the following code is to determine if a new query is
402             // called for.  If the criteria is the same as the last
403             // one, just return the collection.
404 
405                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
406                         if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
407             {
408                 collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinScarabUserImplRelatedByNewUserId(criteria);
409             }
410         }
411         lastActivitysRelatedByOldUserIdCriteria = criteria;
412 
413         return collActivitysRelatedByOldUserId;
414     }
415                   
416                     
417                     
418                                             
419                                                                           
420                                         
421                     
422                                 
423           
424     /**
425      * If this collection has already been initialized with
426      * an identical criteria, it returns the collection.
427      * Otherwise if this ScarabUserImpl is new, it will return
428      * an empty collection; or if this ScarabUserImpl has previously
429      * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
430      *
431      * This method is protected by default in order to keep the public
432      * api reasonable.  You can provide public methods for those you
433      * actually need in ScarabUserImpl.
434      */
435     protected List   getActivitysRelatedByOldUserIdJoinAttributeOptionRelatedByOldOptionId(Criteria criteria)
436         throws TorqueException
437     {
438         if (collActivitysRelatedByOldUserId == null)
439         {
440             if (isNew())
441             {
442                collActivitysRelatedByOldUserId = new ArrayList  ();
443             }
444             else
445             {
446                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
447                             collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinAttributeOptionRelatedByOldOptionId(criteria);
448             }
449         }
450         else
451         {
452             // the following code is to determine if a new query is
453             // called for.  If the criteria is the same as the last
454             // one, just return the collection.
455 
456                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
457                         if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
458             {
459                 collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinAttributeOptionRelatedByOldOptionId(criteria);
460             }
461         }
462         lastActivitysRelatedByOldUserIdCriteria = criteria;
463 
464         return collActivitysRelatedByOldUserId;
465     }
466                   
467                     
468                     
469                                             
470                                                                           
471                                         
472                     
473                                 
474           
475     /**
476      * If this collection has already been initialized with
477      * an identical criteria, it returns the collection.
478      * Otherwise if this ScarabUserImpl is new, it will return
479      * an empty collection; or if this ScarabUserImpl has previously
480      * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
481      *
482      * This method is protected by default in order to keep the public
483      * api reasonable.  You can provide public methods for those you
484      * actually need in ScarabUserImpl.
485      */
486     protected List   getActivitysRelatedByOldUserIdJoinAttributeOptionRelatedByNewOptionId(Criteria criteria)
487         throws TorqueException
488     {
489         if (collActivitysRelatedByOldUserId == null)
490         {
491             if (isNew())
492             {
493                collActivitysRelatedByOldUserId = new ArrayList  ();
494             }
495             else
496             {
497                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
498                             collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinAttributeOptionRelatedByNewOptionId(criteria);
499             }
500         }
501         else
502         {
503             // the following code is to determine if a new query is
504             // called for.  If the criteria is the same as the last
505             // one, just return the collection.
506 
507                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
508                         if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
509             {
510                 collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinAttributeOptionRelatedByNewOptionId(criteria);
511             }
512         }
513         lastActivitysRelatedByOldUserIdCriteria = criteria;
514 
515         return collActivitysRelatedByOldUserId;
516     }
517                   
518                     
519                     
520                                 
521                                                               
522                                         
523                     
524                                 
525           
526     /**
527      * If this collection has already been initialized with
528      * an identical criteria, it returns the collection.
529      * Otherwise if this ScarabUserImpl is new, it will return
530      * an empty collection; or if this ScarabUserImpl has previously
531      * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
532      *
533      * This method is protected by default in order to keep the public
534      * api reasonable.  You can provide public methods for those you
535      * actually need in ScarabUserImpl.
536      */
537     protected List   getActivitysRelatedByOldUserIdJoinAttachment(Criteria criteria)
538         throws TorqueException
539     {
540         if (collActivitysRelatedByOldUserId == null)
541         {
542             if (isNew())
543             {
544                collActivitysRelatedByOldUserId = new ArrayList  ();
545             }
546             else
547             {
548                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
549                             collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinAttachment(criteria);
550             }
551         }
552         else
553         {
554             // the following code is to determine if a new query is
555             // called for.  If the criteria is the same as the last
556             // one, just return the collection.
557 
558                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
559                         if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
560             {
561                 collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinAttachment(criteria);
562             }
563         }
564         lastActivitysRelatedByOldUserIdCriteria = criteria;
565 
566         return collActivitysRelatedByOldUserId;
567     }
568                   
569                     
570                     
571                                 
572                                                               
573                                         
574                     
575                                 
576           
577     /**
578      * If this collection has already been initialized with
579      * an identical criteria, it returns the collection.
580      * Otherwise if this ScarabUserImpl is new, it will return
581      * an empty collection; or if this ScarabUserImpl has previously
582      * been saved, it will retrieve related ActivitysRelatedByOldUserId from storage.
583      *
584      * This method is protected by default in order to keep the public
585      * api reasonable.  You can provide public methods for those you
586      * actually need in ScarabUserImpl.
587      */
588     protected List   getActivitysRelatedByOldUserIdJoinDepend(Criteria criteria)
589         throws TorqueException
590     {
591         if (collActivitysRelatedByOldUserId == null)
592         {
593             if (isNew())
594             {
595                collActivitysRelatedByOldUserId = new ArrayList  ();
596             }
597             else
598             {
599                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
600                             collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinDepend(criteria);
601             }
602         }
603         else
604         {
605             // the following code is to determine if a new query is
606             // called for.  If the criteria is the same as the last
607             // one, just return the collection.
608 
609                             criteria.add(ActivityPeer.OLD_USER_ID, getUserId() );
610                         if (!lastActivitysRelatedByOldUserIdCriteria.equals(criteria))
611             {
612                 collActivitysRelatedByOldUserId = ActivityPeer.doSelectJoinDepend(criteria);
613             }
614         }
615         lastActivitysRelatedByOldUserIdCriteria = criteria;
616 
617         return collActivitysRelatedByOldUserId;
618     }
619                             
620 
621 
622                                   
623             
624     /**
625      * Collection to store aggregation of collActivitysRelatedByNewUserId
626      */
627     protected List   collActivitysRelatedByNewUserId;
628 
629     /**
630      * Temporary storage of collActivitysRelatedByNewUserId to save a possible db hit in
631      * the event objects are add to the collection, but the
632      * complete collection is never requested.
633      */
634     protected void initActivitysRelatedByNewUserId()
635     {
636         if (collActivitysRelatedByNewUserId == null)
637         {
638             collActivitysRelatedByNewUserId = new ArrayList  ();
639         }
640     }
641 
642                   
643     /**
644      * Method called to associate a Activity object to this object
645      * through the Activity foreign key attribute
646      *
647      * @param l Activity
648      * @throws TorqueException
649      */
650     public void addActivityRelatedByNewUserId(Activity l) throws TorqueException
651     {
652         getActivitysRelatedByNewUserId().add(l);
653         l.setScarabUserRelatedByNewUserId((ScarabUserImpl)this);
654     }
655 
656     /**
657      * The criteria used to select the current contents of collActivitysRelatedByNewUserId
658      */
659     private Criteria lastActivitysRelatedByNewUserIdCriteria = null;
660 
661     /**
662      * If this collection has already been initialized, returns
663      * the collection. Otherwise returns the results of
664      * getActivitysRelatedByNewUserId(new Criteria())
665      *
666      * @throws TorqueException
667      */
668     public List   getActivitysRelatedByNewUserId() throws TorqueException
669     {
670         if (collActivitysRelatedByNewUserId == null)
671         {
672             collActivitysRelatedByNewUserId = getActivitysRelatedByNewUserId(new Criteria(10));
673         }
674         return collActivitysRelatedByNewUserId;
675     }
676 
677     /**
678      * If this collection has already been initialized with
679      * an identical criteria, it returns the collection.
680      * Otherwise if this ScarabUserImpl has previously
681      * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
682      * If this ScarabUserImpl is new, it will return
683      * an empty collection or the current collection, the criteria
684      * is ignored on a new object.
685      *
686      * @throws TorqueException
687      */
688     public List   getActivitysRelatedByNewUserId(Criteria criteria) throws TorqueException
689     {
690         if (collActivitysRelatedByNewUserId == null)
691         {
692             if (isNew())
693             {
694                collActivitysRelatedByNewUserId = new ArrayList  ();
695             }
696             else
697             {
698                       criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
699                       collActivitysRelatedByNewUserId = ActivityPeer.doSelect(criteria);
700             }
701         }
702         else
703         {
704             // criteria has no effect for a new object
705             if (!isNew())
706             {
707                 // the following code is to determine if a new query is
708                 // called for.  If the criteria is the same as the last
709                 // one, just return the collection.
710                       criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
711                       if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
712                 {
713                     collActivitysRelatedByNewUserId = ActivityPeer.doSelect(criteria);
714                 }
715             }
716         }
717         lastActivitysRelatedByNewUserIdCriteria = criteria;
718 
719         return collActivitysRelatedByNewUserId;
720     }
721 
722     /**
723      * If this collection has already been initialized, returns
724      * the collection. Otherwise returns the results of
725      * getActivitysRelatedByNewUserId(new Criteria(),Connection)
726      * This method takes in the Connection also as input so that
727      * referenced objects can also be obtained using a Connection
728      * that is taken as input
729      */
730     public List   getActivitysRelatedByNewUserId(Connection   con) throws TorqueException
731     {
732         if (collActivitysRelatedByNewUserId == null)
733         {
734             collActivitysRelatedByNewUserId = getActivitysRelatedByNewUserId(new Criteria(10),con);
735         }
736         return collActivitysRelatedByNewUserId;
737     }
738 
739     /**
740      * If this collection has already been initialized with
741      * an identical criteria, it returns the collection.
742      * Otherwise if this ScarabUserImpl has previously
743      * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
744      * If this ScarabUserImpl is new, it will return
745      * an empty collection or the current collection, the criteria
746      * is ignored on a new object.
747      * This method takes in the Connection also as input so that
748      * referenced objects can also be obtained using a Connection
749      * that is taken as input
750      */
751     public List   getActivitysRelatedByNewUserId(Criteria criteria,Connection   con) throws TorqueException
752     {
753         if (collActivitysRelatedByNewUserId == null)
754         {
755             if (isNew())
756             {
757                collActivitysRelatedByNewUserId = new ArrayList  ();
758             }
759             else
760             {
761                        criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
762                        collActivitysRelatedByNewUserId = ActivityPeer.doSelect(criteria,con);
763              }
764          }
765          else
766          {
767              // criteria has no effect for a new object
768              if (!isNew())
769              {
770                  // the following code is to determine if a new query is
771                  // called for.  If the criteria is the same as the last
772                  // one, just return the collection.
773                      criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
774                      if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
775                  {
776                      collActivitysRelatedByNewUserId = ActivityPeer.doSelect(criteria,con);
777                  }
778              }
779          }
780          lastActivitysRelatedByNewUserIdCriteria = criteria;
781 
782          return collActivitysRelatedByNewUserId;
783      }
784 
785                                                                   
786               
787                     
788                     
789                                 
790                                                               
791                                         
792                     
793                                 
794           
795     /**
796      * If this collection has already been initialized with
797      * an identical criteria, it returns the collection.
798      * Otherwise if this ScarabUserImpl is new, it will return
799      * an empty collection; or if this ScarabUserImpl has previously
800      * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
801      *
802      * This method is protected by default in order to keep the public
803      * api reasonable.  You can provide public methods for those you
804      * actually need in ScarabUserImpl.
805      */
806     protected List   getActivitysRelatedByNewUserIdJoinIssue(Criteria criteria)
807         throws TorqueException
808     {
809         if (collActivitysRelatedByNewUserId == null)
810         {
811             if (isNew())
812             {
813                collActivitysRelatedByNewUserId = new ArrayList  ();
814             }
815             else
816             {
817                             criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
818                             collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinIssue(criteria);
819             }
820         }
821         else
822         {
823             // the following code is to determine if a new query is
824             // called for.  If the criteria is the same as the last
825             // one, just return the collection.
826 
827                             criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
828                         if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
829             {
830                 collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinIssue(criteria);
831             }
832         }
833         lastActivitysRelatedByNewUserIdCriteria = criteria;
834 
835         return collActivitysRelatedByNewUserId;
836     }
837                   
838                     
839                     
840                                 
841                                                               
842                                         
843                     
844                                 
845           
846     /**
847      * If this collection has already been initialized with
848      * an identical criteria, it returns the collection.
849      * Otherwise if this ScarabUserImpl is new, it will return
850      * an empty collection; or if this ScarabUserImpl has previously
851      * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
852      *
853      * This method is protected by default in order to keep the public
854      * api reasonable.  You can provide public methods for those you
855      * actually need in ScarabUserImpl.
856      */
857     protected List   getActivitysRelatedByNewUserIdJoinAttribute(Criteria criteria)
858         throws TorqueException
859     {
860         if (collActivitysRelatedByNewUserId == null)
861         {
862             if (isNew())
863             {
864                collActivitysRelatedByNewUserId = new ArrayList  ();
865             }
866             else
867             {
868                             criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
869                             collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinAttribute(criteria);
870             }
871         }
872         else
873         {
874             // the following code is to determine if a new query is
875             // called for.  If the criteria is the same as the last
876             // one, just return the collection.
877 
878                             criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
879                         if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
880             {
881                 collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinAttribute(criteria);
882             }
883         }
884         lastActivitysRelatedByNewUserIdCriteria = criteria;
885 
886         return collActivitysRelatedByNewUserId;
887     }
888                   
889                     
890                     
891                                 
892                                                               
893                                         
894                     
895                                 
896           
897     /**
898      * If this collection has already been initialized with
899      * an identical criteria, it returns the collection.
900      * Otherwise if this ScarabUserImpl is new, it will return
901      * an empty collection; or if this ScarabUserImpl has previously
902      * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
903      *
904      * This method is protected by default in order to keep the public
905      * api reasonable.  You can provide public methods for those you
906      * actually need in ScarabUserImpl.
907      */
908     protected List   getActivitysRelatedByNewUserIdJoinActivitySet(Criteria criteria)
909         throws TorqueException
910     {
911         if (collActivitysRelatedByNewUserId == null)
912         {
913             if (isNew())
914             {
915                collActivitysRelatedByNewUserId = new ArrayList  ();
916             }
917             else
918             {
919                             criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
920                             collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinActivitySet(criteria);
921             }
922         }
923         else
924         {
925             // the following code is to determine if a new query is
926             // called for.  If the criteria is the same as the last
927             // one, just return the collection.
928 
929                             criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
930                         if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
931             {
932                 collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinActivitySet(criteria);
933             }
934         }
935         lastActivitysRelatedByNewUserIdCriteria = criteria;
936 
937         return collActivitysRelatedByNewUserId;
938     }
939                   
940                     
941                               
942                                             
943                                                                           
944                                         
945                     
946                                 
947           
948     /**
949      * If this collection has already been initialized with
950      * an identical criteria, it returns the collection.
951      * Otherwise if this ScarabUserImpl is new, it will return
952      * an empty collection; or if this ScarabUserImpl has previously
953      * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
954      *
955      * This method is protected by default in order to keep the public
956      * api reasonable.  You can provide public methods for those you
957      * actually need in ScarabUserImpl.
958      */
959     protected List   getActivitysRelatedByNewUserIdJoinScarabUserImplRelatedByOldUserId(Criteria criteria)
960         throws TorqueException
961     {
962         if (collActivitysRelatedByNewUserId == null)
963         {
964             if (isNew())
965             {
966                collActivitysRelatedByNewUserId = new ArrayList  ();
967             }
968             else
969             {
970                             criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
971                             collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinScarabUserImplRelatedByOldUserId(criteria);
972             }
973         }
974         else
975         {
976             // the following code is to determine if a new query is
977             // called for.  If the criteria is the same as the last
978             // one, just return the collection.
979 
980                             criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
981                         if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
982             {
983                 collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinScarabUserImplRelatedByOldUserId(criteria);
984             }
985         }
986         lastActivitysRelatedByNewUserIdCriteria = criteria;
987 
988         return collActivitysRelatedByNewUserId;
989     }
990                   
991                     
992                               
993                                             
994                                                                           
995                                         
996                     
997                                             
998                   
999                     
1000                    
1001                                            
1002                                                                          
1003                                        
1004                    
1005                                
1006          
1007    /**
1008     * If this collection has already been initialized with
1009     * an identical criteria, it returns the collection.
1010     * Otherwise if this ScarabUserImpl is new, it will return
1011     * an empty collection; or if this ScarabUserImpl has previously
1012     * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
1013     *
1014     * This method is protected by default in order to keep the public
1015     * api reasonable.  You can provide public methods for those you
1016     * actually need in ScarabUserImpl.
1017     */
1018    protected List   getActivitysRelatedByNewUserIdJoinAttributeOptionRelatedByOldOptionId(Criteria criteria)
1019        throws TorqueException
1020    {
1021        if (collActivitysRelatedByNewUserId == null)
1022        {
1023            if (isNew())
1024            {
1025               collActivitysRelatedByNewUserId = new ArrayList  ();
1026            }
1027            else
1028            {
1029                            criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
1030                            collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinAttributeOptionRelatedByOldOptionId(criteria);
1031            }
1032        }
1033        else
1034        {
1035            // the following code is to determine if a new query is
1036            // called for.  If the criteria is the same as the last
1037            // one, just return the collection.
1038
1039                            criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
1040                        if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
1041            {
1042                collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinAttributeOptionRelatedByOldOptionId(criteria);
1043            }
1044        }
1045        lastActivitysRelatedByNewUserIdCriteria = criteria;
1046
1047        return collActivitysRelatedByNewUserId;
1048    }
1049                  
1050                    
1051                    
1052                                            
1053                                                                          
1054                                        
1055                    
1056                                
1057          
1058    /**
1059     * If this collection has already been initialized with
1060     * an identical criteria, it returns the collection.
1061     * Otherwise if this ScarabUserImpl is new, it will return
1062     * an empty collection; or if this ScarabUserImpl has previously
1063     * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
1064     *
1065     * This method is protected by default in order to keep the public
1066     * api reasonable.  You can provide public methods for those you
1067     * actually need in ScarabUserImpl.
1068     */
1069    protected List   getActivitysRelatedByNewUserIdJoinAttributeOptionRelatedByNewOptionId(Criteria criteria)
1070        throws TorqueException
1071    {
1072        if (collActivitysRelatedByNewUserId == null)
1073        {
1074            if (isNew())
1075            {
1076               collActivitysRelatedByNewUserId = new ArrayList  ();
1077            }
1078            else
1079            {
1080                            criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
1081                            collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinAttributeOptionRelatedByNewOptionId(criteria);
1082            }
1083        }
1084        else
1085        {
1086            // the following code is to determine if a new query is
1087            // called for.  If the criteria is the same as the last
1088            // one, just return the collection.
1089
1090                            criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
1091                        if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
1092            {
1093                collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinAttributeOptionRelatedByNewOptionId(criteria);
1094            }
1095        }
1096        lastActivitysRelatedByNewUserIdCriteria = criteria;
1097
1098        return collActivitysRelatedByNewUserId;
1099    }
1100                  
1101                    
1102                    
1103                                
1104                                                              
1105                                        
1106                    
1107                                
1108          
1109    /**
1110     * If this collection has already been initialized with
1111     * an identical criteria, it returns the collection.
1112     * Otherwise if this ScarabUserImpl is new, it will return
1113     * an empty collection; or if this ScarabUserImpl has previously
1114     * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
1115     *
1116     * This method is protected by default in order to keep the public
1117     * api reasonable.  You can provide public methods for those you
1118     * actually need in ScarabUserImpl.
1119     */
1120    protected List   getActivitysRelatedByNewUserIdJoinAttachment(Criteria criteria)
1121        throws TorqueException
1122    {
1123        if (collActivitysRelatedByNewUserId == null)
1124        {
1125            if (isNew())
1126            {
1127               collActivitysRelatedByNewUserId = new ArrayList  ();
1128            }
1129            else
1130            {
1131                            criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
1132                            collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinAttachment(criteria);
1133            }
1134        }
1135        else
1136        {
1137            // the following code is to determine if a new query is
1138            // called for.  If the criteria is the same as the last
1139            // one, just return the collection.
1140
1141                            criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
1142                        if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
1143            {
1144                collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinAttachment(criteria);
1145            }
1146        }
1147        lastActivitysRelatedByNewUserIdCriteria = criteria;
1148
1149        return collActivitysRelatedByNewUserId;
1150    }
1151                  
1152                    
1153                    
1154                                
1155                                                              
1156                                        
1157                    
1158                                
1159          
1160    /**
1161     * If this collection has already been initialized with
1162     * an identical criteria, it returns the collection.
1163     * Otherwise if this ScarabUserImpl is new, it will return
1164     * an empty collection; or if this ScarabUserImpl has previously
1165     * been saved, it will retrieve related ActivitysRelatedByNewUserId from storage.
1166     *
1167     * This method is protected by default in order to keep the public
1168     * api reasonable.  You can provide public methods for those you
1169     * actually need in ScarabUserImpl.
1170     */
1171    protected List   getActivitysRelatedByNewUserIdJoinDepend(Criteria criteria)
1172        throws TorqueException
1173    {
1174        if (collActivitysRelatedByNewUserId == null)
1175        {
1176            if (isNew())
1177            {
1178               collActivitysRelatedByNewUserId = new ArrayList  ();
1179            }
1180            else
1181            {
1182                            criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
1183                            collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinDepend(criteria);
1184            }
1185        }
1186        else
1187        {
1188            // the following code is to determine if a new query is
1189            // called for.  If the criteria is the same as the last
1190            // one, just return the collection.
1191
1192                            criteria.add(ActivityPeer.NEW_USER_ID, getUserId() );
1193                        if (!lastActivitysRelatedByNewUserIdCriteria.equals(criteria))
1194            {
1195                collActivitysRelatedByNewUserId = ActivityPeer.doSelectJoinDepend(criteria);
1196            }
1197        }
1198        lastActivitysRelatedByNewUserIdCriteria = criteria;
1199
1200        return collActivitysRelatedByNewUserId;
1201    }
1202                            
1203
1204
1205                                  
1206            
1207    /**
1208     * Collection to store aggregation of collAttachmentsRelatedByCreatedBy
1209     */
1210    protected List   collAttachmentsRelatedByCreatedBy;
1211
1212    /**
1213     * Temporary storage of collAttachmentsRelatedByCreatedBy to save a possible db hit in
1214     * the event objects are add to the collection, but the
1215     * complete collection is never requested.
1216     */
1217    protected void initAttachmentsRelatedByCreatedBy()
1218    {
1219        if (collAttachmentsRelatedByCreatedBy == null)
1220        {
1221            collAttachmentsRelatedByCreatedBy = new ArrayList  ();
1222        }
1223    }
1224
1225                  
1226    /**
1227     * Method called to associate a Attachment object to this object
1228     * through the Attachment foreign key attribute
1229     *
1230     * @param l Attachment
1231     * @throws TorqueException
1232     */
1233    public void addAttachmentRelatedByCreatedBy(Attachment l) throws TorqueException
1234    {
1235        getAttachmentsRelatedByCreatedBy().add(l);
1236        l.setScarabUserRelatedByCreatedBy((ScarabUserImpl)this);
1237    }
1238
1239    /**
1240     * The criteria used to select the current contents of collAttachmentsRelatedByCreatedBy
1241     */
1242    private Criteria lastAttachmentsRelatedByCreatedByCriteria = null;
1243
1244    /**
1245     * If this collection has already been initialized, returns
1246     * the collection. Otherwise returns the results of
1247     * getAttachmentsRelatedByCreatedBy(new Criteria())
1248     *
1249     * @throws TorqueException
1250     */
1251    public List   getAttachmentsRelatedByCreatedBy() throws TorqueException
1252    {
1253        if (collAttachmentsRelatedByCreatedBy == null)
1254        {
1255            collAttachmentsRelatedByCreatedBy = getAttachmentsRelatedByCreatedBy(new Criteria(10));
1256        }
1257        return collAttachmentsRelatedByCreatedBy;
1258    }
1259
1260    /**
1261     * If this collection has already been initialized with
1262     * an identical criteria, it returns the collection.
1263     * Otherwise if this ScarabUserImpl has previously
1264     * been saved, it will retrieve related AttachmentsRelatedByCreatedBy from storage.
1265     * If this ScarabUserImpl is new, it will return
1266     * an empty collection or the current collection, the criteria
1267     * is ignored on a new object.
1268     *
1269     * @throws TorqueException
1270     */
1271    public List   getAttachmentsRelatedByCreatedBy(Criteria criteria) throws TorqueException
1272    {
1273        if (collAttachmentsRelatedByCreatedBy == null)
1274        {
1275            if (isNew())
1276            {
1277               collAttachmentsRelatedByCreatedBy = new ArrayList  ();
1278            }
1279            else
1280            {
1281                      criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1282                      collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelect(criteria);
1283            }
1284        }
1285        else
1286        {
1287            // criteria has no effect for a new object
1288            if (!isNew())
1289            {
1290                // the following code is to determine if a new query is
1291                // called for.  If the criteria is the same as the last
1292                // one, just return the collection.
1293                      criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1294                      if (!lastAttachmentsRelatedByCreatedByCriteria.equals(criteria))
1295                {
1296                    collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelect(criteria);
1297                }
1298            }
1299        }
1300        lastAttachmentsRelatedByCreatedByCriteria = criteria;
1301
1302        return collAttachmentsRelatedByCreatedBy;
1303    }
1304
1305    /**
1306     * If this collection has already been initialized, returns
1307     * the collection. Otherwise returns the results of
1308     * getAttachmentsRelatedByCreatedBy(new Criteria(),Connection)
1309     * This method takes in the Connection also as input so that
1310     * referenced objects can also be obtained using a Connection
1311     * that is taken as input
1312     */
1313    public List   getAttachmentsRelatedByCreatedBy(Connection   con) throws TorqueException
1314    {
1315        if (collAttachmentsRelatedByCreatedBy == null)
1316        {
1317            collAttachmentsRelatedByCreatedBy = getAttachmentsRelatedByCreatedBy(new Criteria(10),con);
1318        }
1319        return collAttachmentsRelatedByCreatedBy;
1320    }
1321
1322    /**
1323     * If this collection has already been initialized with
1324     * an identical criteria, it returns the collection.
1325     * Otherwise if this ScarabUserImpl has previously
1326     * been saved, it will retrieve related AttachmentsRelatedByCreatedBy from storage.
1327     * If this ScarabUserImpl is new, it will return
1328     * an empty collection or the current collection, the criteria
1329     * is ignored on a new object.
1330     * This method takes in the Connection also as input so that
1331     * referenced objects can also be obtained using a Connection
1332     * that is taken as input
1333     */
1334    public List   getAttachmentsRelatedByCreatedBy(Criteria criteria,Connection   con) throws TorqueException
1335    {
1336        if (collAttachmentsRelatedByCreatedBy == null)
1337        {
1338            if (isNew())
1339            {
1340               collAttachmentsRelatedByCreatedBy = new ArrayList  ();
1341            }
1342            else
1343            {
1344                       criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1345                       collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelect(criteria,con);
1346             }
1347         }
1348         else
1349         {
1350             // criteria has no effect for a new object
1351             if (!isNew())
1352             {
1353                 // the following code is to determine if a new query is
1354                 // called for.  If the criteria is the same as the last
1355                 // one, just return the collection.
1356                     criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1357                     if (!lastAttachmentsRelatedByCreatedByCriteria.equals(criteria))
1358                 {
1359                     collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelect(criteria,con);
1360                 }
1361             }
1362         }
1363         lastAttachmentsRelatedByCreatedByCriteria = criteria;
1364
1365         return collAttachmentsRelatedByCreatedBy;
1366     }
1367
1368                                    
1369              
1370                    
1371                    
1372                                
1373                                                              
1374                                        
1375                    
1376                                
1377          
1378    /**
1379     * If this collection has already been initialized with
1380     * an identical criteria, it returns the collection.
1381     * Otherwise if this ScarabUserImpl is new, it will return
1382     * an empty collection; or if this ScarabUserImpl has previously
1383     * been saved, it will retrieve related AttachmentsRelatedByCreatedBy from storage.
1384     *
1385     * This method is protected by default in order to keep the public
1386     * api reasonable.  You can provide public methods for those you
1387     * actually need in ScarabUserImpl.
1388     */
1389    protected List   getAttachmentsRelatedByCreatedByJoinIssue(Criteria criteria)
1390        throws TorqueException
1391    {
1392        if (collAttachmentsRelatedByCreatedBy == null)
1393        {
1394            if (isNew())
1395            {
1396               collAttachmentsRelatedByCreatedBy = new ArrayList  ();
1397            }
1398            else
1399            {
1400                            criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1401                            collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelectJoinIssue(criteria);
1402            }
1403        }
1404        else
1405        {
1406            // the following code is to determine if a new query is
1407            // called for.  If the criteria is the same as the last
1408            // one, just return the collection.
1409
1410                            criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1411                        if (!lastAttachmentsRelatedByCreatedByCriteria.equals(criteria))
1412            {
1413                collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelectJoinIssue(criteria);
1414            }
1415        }
1416        lastAttachmentsRelatedByCreatedByCriteria = criteria;
1417
1418        return collAttachmentsRelatedByCreatedBy;
1419    }
1420                  
1421                    
1422                    
1423                                
1424                                                              
1425                                        
1426                    
1427                                
1428          
1429    /**
1430     * If this collection has already been initialized with
1431     * an identical criteria, it returns the collection.
1432     * Otherwise if this ScarabUserImpl is new, it will return
1433     * an empty collection; or if this ScarabUserImpl has previously
1434     * been saved, it will retrieve related AttachmentsRelatedByCreatedBy from storage.
1435     *
1436     * This method is protected by default in order to keep the public
1437     * api reasonable.  You can provide public methods for those you
1438     * actually need in ScarabUserImpl.
1439     */
1440    protected List   getAttachmentsRelatedByCreatedByJoinAttachmentType(Criteria criteria)
1441        throws TorqueException
1442    {
1443        if (collAttachmentsRelatedByCreatedBy == null)
1444        {
1445            if (isNew())
1446            {
1447               collAttachmentsRelatedByCreatedBy = new ArrayList  ();
1448            }
1449            else
1450            {
1451                            criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1452                            collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelectJoinAttachmentType(criteria);
1453            }
1454        }
1455        else
1456        {
1457            // the following code is to determine if a new query is
1458            // called for.  If the criteria is the same as the last
1459            // one, just return the collection.
1460
1461                            criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1462                        if (!lastAttachmentsRelatedByCreatedByCriteria.equals(criteria))
1463            {
1464                collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelectJoinAttachmentType(criteria);
1465            }
1466        }
1467        lastAttachmentsRelatedByCreatedByCriteria = criteria;
1468
1469        return collAttachmentsRelatedByCreatedBy;
1470    }
1471                  
1472                    
1473                              
1474                                            
1475                                                                          
1476                                        
1477                    
1478                                            
1479                  
1480                    
1481                              
1482                                            
1483                                                                          
1484                                        
1485                    
1486                                
1487          
1488    /**
1489     * If this collection has already been initialized with
1490     * an identical criteria, it returns the collection.
1491     * Otherwise if this ScarabUserImpl is new, it will return
1492     * an empty collection; or if this ScarabUserImpl has previously
1493     * been saved, it will retrieve related AttachmentsRelatedByCreatedBy from storage.
1494     *
1495     * This method is protected by default in order to keep the public
1496     * api reasonable.  You can provide public methods for those you
1497     * actually need in ScarabUserImpl.
1498     */
1499    protected List   getAttachmentsRelatedByCreatedByJoinScarabUserImplRelatedByModifiedBy(Criteria criteria)
1500        throws TorqueException
1501    {
1502        if (collAttachmentsRelatedByCreatedBy == null)
1503        {
1504            if (isNew())
1505            {
1506               collAttachmentsRelatedByCreatedBy = new ArrayList  ();
1507            }
1508            else
1509            {
1510                            criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1511                            collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelectJoinScarabUserImplRelatedByModifiedBy(criteria);
1512            }
1513        }
1514        else
1515        {
1516            // the following code is to determine if a new query is
1517            // called for.  If the criteria is the same as the last
1518            // one, just return the collection.
1519
1520                            criteria.add(AttachmentPeer.CREATED_BY, getUserId() );
1521                        if (!lastAttachmentsRelatedByCreatedByCriteria.equals(criteria))
1522            {
1523                collAttachmentsRelatedByCreatedBy = AttachmentPeer.doSelectJoinScarabUserImplRelatedByModifiedBy(criteria);
1524            }
1525        }
1526        lastAttachmentsRelatedByCreatedByCriteria = criteria;
1527
1528        return collAttachmentsRelatedByCreatedBy;
1529    }
1530                            
1531
1532
1533                                  
1534            
1535    /**
1536     * Collection to store aggregation of collAttachmentsRelatedByModifiedBy
1537     */
1538    protected List   collAttachmentsRelatedByModifiedBy;
1539
1540    /**
1541     * Temporary storage of collAttachmentsRelatedByModifiedBy to save a possible db hit in
1542     * the event objects are add to the collection, but the
1543     * complete collection is never requested.
1544     */
1545    protected void initAttachmentsRelatedByModifiedBy()
1546    {
1547        if (collAttachmentsRelatedByModifiedBy == null)
1548        {
1549            collAttachmentsRelatedByModifiedBy = new ArrayList  ();
1550        }
1551    }
1552
1553                  
1554    /**
1555     * Method called to associate a Attachment object to this object
1556     * through the Attachment foreign key attribute
1557     *
1558     * @param l Attachment
1559     * @throws TorqueException
1560     */
1561    public void addAttachmentRelatedByModifiedBy(Attachment l) throws TorqueException
1562    {
1563        getAttachmentsRelatedByModifiedBy().add(l);
1564        l.setScarabUserRelatedByModifiedBy((ScarabUserImpl)this);
1565    }
1566
1567    /**
1568     * The criteria used to select the current contents of collAttachmentsRelatedByModifiedBy
1569     */
1570    private Criteria lastAttachmentsRelatedByModifiedByCriteria = null;
1571
1572    /**
1573     * If this collection has already been initialized, returns
1574     * the collection. Otherwise returns the results of
1575     * getAttachmentsRelatedByModifiedBy(new Criteria())
1576     *
1577     * @throws TorqueException
1578     */
1579    public List   getAttachmentsRelatedByModifiedBy() throws TorqueException
1580    {
1581        if (collAttachmentsRelatedByModifiedBy == null)
1582        {
1583            collAttachmentsRelatedByModifiedBy = getAttachmentsRelatedByModifiedBy(new Criteria(10));
1584        }
1585        return collAttachmentsRelatedByModifiedBy;
1586    }
1587
1588    /**
1589     * If this collection has already been initialized with
1590     * an identical criteria, it returns the collection.
1591     * Otherwise if this ScarabUserImpl has previously
1592     * been saved, it will retrieve related AttachmentsRelatedByModifiedBy from storage.
1593     * If this ScarabUserImpl is new, it will return
1594     * an empty collection or the current collection, the criteria
1595     * is ignored on a new object.
1596     *
1597     * @throws TorqueException
1598     */
1599    public List   getAttachmentsRelatedByModifiedBy(Criteria criteria) throws TorqueException
1600    {
1601        if (collAttachmentsRelatedByModifiedBy == null)
1602        {
1603            if (isNew())
1604            {
1605               collAttachmentsRelatedByModifiedBy = new ArrayList  ();
1606            }
1607            else
1608            {
1609                      criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1610                      collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelect(criteria);
1611            }
1612        }
1613        else
1614        {
1615            // criteria has no effect for a new object
1616            if (!isNew())
1617            {
1618                // the following code is to determine if a new query is
1619                // called for.  If the criteria is the same as the last
1620                // one, just return the collection.
1621                      criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1622                      if (!lastAttachmentsRelatedByModifiedByCriteria.equals(criteria))
1623                {
1624                    collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelect(criteria);
1625                }
1626            }
1627        }
1628        lastAttachmentsRelatedByModifiedByCriteria = criteria;
1629
1630        return collAttachmentsRelatedByModifiedBy;
1631    }
1632
1633    /**
1634     * If this collection has already been initialized, returns
1635     * the collection. Otherwise returns the results of
1636     * getAttachmentsRelatedByModifiedBy(new Criteria(),Connection)
1637     * This method takes in the Connection also as input so that
1638     * referenced objects can also be obtained using a Connection
1639     * that is taken as input
1640     */
1641    public List   getAttachmentsRelatedByModifiedBy(Connection   con) throws TorqueException
1642    {
1643        if (collAttachmentsRelatedByModifiedBy == null)
1644        {
1645            collAttachmentsRelatedByModifiedBy = getAttachmentsRelatedByModifiedBy(new Criteria(10),con);
1646        }
1647        return collAttachmentsRelatedByModifiedBy;
1648    }
1649
1650    /**
1651     * If this collection has already been initialized with
1652     * an identical criteria, it returns the collection.
1653     * Otherwise if this ScarabUserImpl has previously
1654     * been saved, it will retrieve related AttachmentsRelatedByModifiedBy from storage.
1655     * If this ScarabUserImpl is new, it will return
1656     * an empty collection or the current collection, the criteria
1657     * is ignored on a new object.
1658     * This method takes in the Connection also as input so that
1659     * referenced objects can also be obtained using a Connection
1660     * that is taken as input
1661     */
1662    public List   getAttachmentsRelatedByModifiedBy(Criteria criteria,Connection   con) throws TorqueException
1663    {
1664        if (collAttachmentsRelatedByModifiedBy == null)
1665        {
1666            if (isNew())
1667            {
1668               collAttachmentsRelatedByModifiedBy = new ArrayList  ();
1669            }
1670            else
1671            {
1672                       criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1673                       collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelect(criteria,con);
1674             }
1675         }
1676         else
1677         {
1678             // criteria has no effect for a new object
1679             if (!isNew())
1680             {
1681                 // the following code is to determine if a new query is
1682                 // called for.  If the criteria is the same as the last
1683                 // one, just return the collection.
1684                     criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1685                     if (!lastAttachmentsRelatedByModifiedByCriteria.equals(criteria))
1686                 {
1687                     collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelect(criteria,con);
1688                 }
1689             }
1690         }
1691         lastAttachmentsRelatedByModifiedByCriteria = criteria;
1692
1693         return collAttachmentsRelatedByModifiedBy;
1694     }
1695
1696                                    
1697              
1698                    
1699                    
1700                                
1701                                                              
1702                                        
1703                    
1704                                
1705          
1706    /**
1707     * If this collection has already been initialized with
1708     * an identical criteria, it returns the collection.
1709     * Otherwise if this ScarabUserImpl is new, it will return
1710     * an empty collection; or if this ScarabUserImpl has previously
1711     * been saved, it will retrieve related AttachmentsRelatedByModifiedBy from storage.
1712     *
1713     * This method is protected by default in order to keep the public
1714     * api reasonable.  You can provide public methods for those you
1715     * actually need in ScarabUserImpl.
1716     */
1717    protected List   getAttachmentsRelatedByModifiedByJoinIssue(Criteria criteria)
1718        throws TorqueException
1719    {
1720        if (collAttachmentsRelatedByModifiedBy == null)
1721        {
1722            if (isNew())
1723            {
1724               collAttachmentsRelatedByModifiedBy = new ArrayList  ();
1725            }
1726            else
1727            {
1728                            criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1729                            collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelectJoinIssue(criteria);
1730            }
1731        }
1732        else
1733        {
1734            // the following code is to determine if a new query is
1735            // called for.  If the criteria is the same as the last
1736            // one, just return the collection.
1737
1738                            criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1739                        if (!lastAttachmentsRelatedByModifiedByCriteria.equals(criteria))
1740            {
1741                collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelectJoinIssue(criteria);
1742            }
1743        }
1744        lastAttachmentsRelatedByModifiedByCriteria = criteria;
1745
1746        return collAttachmentsRelatedByModifiedBy;
1747    }
1748                  
1749                    
1750                    
1751                                
1752                                                              
1753                                        
1754                    
1755                                
1756          
1757    /**
1758     * If this collection has already been initialized with
1759     * an identical criteria, it returns the collection.
1760     * Otherwise if this ScarabUserImpl is new, it will return
1761     * an empty collection; or if this ScarabUserImpl has previously
1762     * been saved, it will retrieve related AttachmentsRelatedByModifiedBy from storage.
1763     *
1764     * This method is protected by default in order to keep the public
1765     * api reasonable.  You can provide public methods for those you
1766     * actually need in ScarabUserImpl.
1767     */
1768    protected List   getAttachmentsRelatedByModifiedByJoinAttachmentType(Criteria criteria)
1769        throws TorqueException
1770    {
1771        if (collAttachmentsRelatedByModifiedBy == null)
1772        {
1773            if (isNew())
1774            {
1775               collAttachmentsRelatedByModifiedBy = new ArrayList  ();
1776            }
1777            else
1778            {
1779                            criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1780                            collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelectJoinAttachmentType(criteria);
1781            }
1782        }
1783        else
1784        {
1785            // the following code is to determine if a new query is
1786            // called for.  If the criteria is the same as the last
1787            // one, just return the collection.
1788
1789                            criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1790                        if (!lastAttachmentsRelatedByModifiedByCriteria.equals(criteria))
1791            {
1792                collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelectJoinAttachmentType(criteria);
1793            }
1794        }
1795        lastAttachmentsRelatedByModifiedByCriteria = criteria;
1796
1797        return collAttachmentsRelatedByModifiedBy;
1798    }
1799                  
1800                    
1801                              
1802                                            
1803                                                                          
1804                                        
1805                    
1806                                
1807          
1808    /**
1809     * If this collection has already been initialized with
1810     * an identical criteria, it returns the collection.
1811     * Otherwise if this ScarabUserImpl is new, it will return
1812     * an empty collection; or if this ScarabUserImpl has previously
1813     * been saved, it will retrieve related AttachmentsRelatedByModifiedBy from storage.
1814     *
1815     * This method is protected by default in order to keep the public
1816     * api reasonable.  You can provide public methods for those you
1817     * actually need in ScarabUserImpl.
1818     */
1819    protected List   getAttachmentsRelatedByModifiedByJoinScarabUserImplRelatedByCreatedBy(Criteria criteria)
1820        throws TorqueException
1821    {
1822        if (collAttachmentsRelatedByModifiedBy == null)
1823        {
1824            if (isNew())
1825            {
1826               collAttachmentsRelatedByModifiedBy = new ArrayList  ();
1827            }
1828            else
1829            {
1830                            criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1831                            collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelectJoinScarabUserImplRelatedByCreatedBy(criteria);
1832            }
1833        }
1834        else
1835        {
1836            // the following code is to determine if a new query is
1837            // called for.  If the criteria is the same as the last
1838            // one, just return the collection.
1839
1840                            criteria.add(AttachmentPeer.MODIFIED_BY, getUserId() );
1841                        if (!lastAttachmentsRelatedByModifiedByCriteria.equals(criteria))
1842            {
1843                collAttachmentsRelatedByModifiedBy = AttachmentPeer.doSelectJoinScarabUserImplRelatedByCreatedBy(criteria);
1844            }
1845        }
1846        lastAttachmentsRelatedByModifiedByCriteria = criteria;
1847
1848        return collAttachmentsRelatedByModifiedBy;
1849    }
1850                  
1851                    
1852                              
1853                                            
1854                                                                          
1855                                        
1856                    
1857                                            
1858                            
1859
1860
1861                          
1862            
1863    /**
1864     * Collection to store aggregation of collAttributes
1865     */
1866    protected List   collAttributes;
1867
1868    /**
1869     * Temporary storage of collAttributes to save a possible db hit in
1870     * the event objects are add to the collection, but the
1871     * complete collection is never requested.
1872     */
1873    protected void initAttributes()
1874    {
1875        if (collAttributes == null)
1876        {
1877            collAttributes = new ArrayList  ();
1878        }
1879    }
1880
1881                  
1882    /**
1883     * Method called to associate a Attribute object to this object
1884     * through the Attribute foreign key attribute
1885     *
1886     * @param l Attribute
1887     * @throws TorqueException
1888     */
1889    public void addAttribute(Attribute l) throws TorqueException
1890    {
1891        getAttributes().add(l);
1892        l.setScarabUser((ScarabUserImpl)this);
1893    }
1894
1895    /**
1896     * The criteria used to select the current contents of collAttributes
1897     */
1898    private Criteria lastAttributesCriteria = null;
1899
1900    /**
1901     * If this collection has already been initialized, returns
1902     * the collection. Otherwise returns the results of
1903     * getAttributes(new Criteria())
1904     *
1905     * @throws TorqueException
1906     */
1907    public List   getAttributes() throws TorqueException
1908    {
1909        if (collAttributes == null)
1910        {
1911            collAttributes = getAttributes(new Criteria(10));
1912        }
1913        return collAttributes;
1914    }
1915
1916    /**
1917     * If this collection has already been initialized with
1918     * an identical criteria, it returns the collection.
1919     * Otherwise if this ScarabUserImpl has previously
1920     * been saved, it will retrieve related Attributes from storage.
1921     * If this ScarabUserImpl is new, it will return
1922     * an empty collection or the current collection, the criteria
1923     * is ignored on a new object.
1924     *
1925     * @throws TorqueException
1926     */
1927    public List   getAttributes(Criteria criteria) throws TorqueException
1928    {
1929        if (collAttributes == null)
1930        {
1931            if (isNew())
1932            {
1933               collAttributes = new ArrayList  ();
1934            }
1935            else
1936            {
1937                      criteria.add(AttributePeer.CREATED_BY, getUserId() );
1938                      collAttributes = AttributePeer.doSelect(criteria);
1939            }
1940        }
1941        else
1942        {
1943            // criteria has no effect for a new object
1944            if (!isNew())
1945            {
1946                // the following code is to determine if a new query is
1947                // called for.  If the criteria is the same as the last
1948                // one, just return the collection.
1949                      criteria.add(AttributePeer.CREATED_BY, getUserId() );
1950                      if (!lastAttributesCriteria.equals(criteria))
1951                {
1952                    collAttributes = AttributePeer.doSelect(criteria);
1953                }
1954            }
1955        }
1956        lastAttributesCriteria = criteria;
1957
1958        return collAttributes;
1959    }
1960
1961    /**
1962     * If this collection has already been initialized, returns
1963     * the collection. Otherwise returns the results of
1964     * getAttributes(new Criteria(),Connection)
1965     * This method takes in the Connection also as input so that
1966     * referenced objects can also be obtained using a Connection
1967     * that is taken as input
1968     */
1969    public List   getAttributes(Connection   con) throws TorqueException
1970    {
1971        if (collAttributes == null)
1972        {
1973            collAttributes = getAttributes(new Criteria(10),con);
1974        }
1975        return collAttributes;
1976    }
1977
1978    /**
1979     * If this collection has already been initialized with
1980     * an identical criteria, it returns the collection.
1981     * Otherwise if this ScarabUserImpl has previously
1982     * been saved, it will retrieve related Attributes from storage.
1983     * If this ScarabUserImpl is new, it will return
1984     * an empty collection or the current collection, the criteria
1985     * is ignored on a new object.
1986     * This method takes in the Connection also as input so that
1987     * referenced objects can also be obtained using a Connection
1988     * that is taken as input
1989     */
1990    public List   getAttributes(Criteria criteria,Connection   con) throws TorqueException
1991    {
1992        if (collAttributes == null)
1993        {
1994            if (isNew())
1995            {
1996               collAttributes = new ArrayList  ();
1997            }
1998            else
1999            {
2000                       criteria.add(AttributePeer.CREATED_BY, getUserId() );
2001                       collAttributes = AttributePeer.doSelect(criteria,con);
2002             }
2003         }
2004         else
2005         {
2006             // criteria has no effect for a new object
2007             if (!isNew())
2008             {
2009                 // the following code is to determine if a new query is
2010                 // called for.  If the criteria is the same as the last
2011                 // one, just return the collection.
2012                     criteria.add(AttributePeer.CREATED_BY, getUserId() );
2013                     if (!lastAttributesCriteria.equals(criteria))
2014                 {
2015                     collAttributes = AttributePeer.doSelect(criteria,con);
2016                 }
2017             }
2018         }
2019         lastAttributesCriteria = criteria;
2020
2021         return collAttributes;
2022     }
2023
2024                              
2025              
2026                    
2027                    
2028                                
2029                                                              
2030                                        
2031                    
2032                    
2033          
2034    /**
2035     * If this collection has already been initialized with
2036     * an identical criteria, it returns the collection.
2037     * Otherwise if this ScarabUserImpl is new, it will return
2038     * an empty collection; or if this ScarabUserImpl has previously
2039     * been saved, it will retrieve related Attributes from storage.
2040     *
2041     * This method is protected by default in order to keep the public
2042     * api reasonable.  You can provide public methods for those you
2043     * actually need in ScarabUserImpl.
2044     */
2045    protected List   getAttributesJoinAttributeType(Criteria criteria)
2046        throws TorqueException
2047    {
2048        if (collAttributes == null)
2049        {
2050            if (isNew())
2051            {
2052               collAttributes = new ArrayList  ();
2053            }
2054            else
2055            {
2056                            criteria.add(AttributePeer.CREATED_BY, getUserId() );
2057                            collAttributes = AttributePeer.doSelectJoinAttributeType(criteria);
2058            }
2059        }
2060        else
2061        {
2062            // the following code is to determine if a new query is
2063            // called for.  If the criteria is the same as the last
2064            // one, just return the collection.
2065
2066                            criteria.add(AttributePeer.CREATED_BY, getUserId() );
2067                        if (!lastAttributesCriteria.equals(criteria))
2068            {
2069                collAttributes = AttributePeer.doSelectJoinAttributeType(criteria);
2070            }
2071        }
2072        lastAttributesCriteria = criteria;
2073
2074        return collAttributes;
2075    }
2076                  
2077                    
2078                    
2079                                
2080                                                              
2081                                        
2082                    
2083                    
2084          
2085    /**
2086     * If this collection has already been initialized with
2087     * an identical criteria, it returns the collection.
2088     * Otherwise if this ScarabUserImpl is new, it will return
2089     * an empty collection; or if this ScarabUserImpl has previously
2090     * been saved, it will retrieve related Attributes from storage.
2091     *
2092     * This method is protected by default in order to keep the public
2093     * api reasonable.  You can provide public methods for those you
2094     * actually need in ScarabUserImpl.
2095     */
2096    protected List   getAttributesJoinAttributeOption(Criteria criteria)
2097        throws TorqueException
2098    {
2099        if (collAttributes == null)
2100        {
2101            if (isNew())
2102            {
2103               collAttributes = new ArrayList  ();
2104            }
2105            else
2106            {
2107                            criteria.add(AttributePeer.CREATED_BY, getUserId() );
2108                            collAttributes = AttributePeer.doSelectJoinAttributeOption(criteria);
2109            }
2110        }
2111        else
2112        {
2113            // the following code is to determine if a new query is
2114            // called for.  If the criteria is the same as the last
2115            // one, just return the collection.
2116
2117                            criteria.add(AttributePeer.CREATED_BY, getUserId() );
2118                        if (!lastAttributesCriteria.equals(criteria))
2119            {
2120                collAttributes = AttributePeer.doSelectJoinAttributeOption(criteria);
2121            }
2122        }
2123        lastAttributesCriteria = criteria;
2124
2125        return collAttributes;
2126    }
2127                  
2128                    
2129                              
2130                                
2131                                                              
2132                                        
2133                    
2134                    
2135          
2136    /**
2137     * If this collection has already been initialized with
2138     * an identical criteria, it returns the collection.
2139     * Otherwise if this ScarabUserImpl is new, it will return
2140     * an empty collection; or if this ScarabUserImpl has previously
2141     * been saved, it will retrieve related Attributes from storage.
2142     *
2143     * This method is protected by default in order to keep the public
2144     * api reasonable.  You can provide public methods for those you
2145     * actually need in ScarabUserImpl.
2146     */
2147    protected List   getAttributesJoinScarabUserImpl(Criteria criteria)
2148        throws TorqueException
2149    {
2150        if (collAttributes == null)
2151        {
2152            if (isNew())
2153            {
2154               collAttributes = new ArrayList  ();
2155            }
2156            else
2157            {
2158                            criteria.add(AttributePeer.CREATED_BY, getUserId() );
2159                            collAttributes = AttributePeer.doSelectJoinScarabUserImpl(criteria);
2160            }
2161        }
2162        else
2163        {
2164            // the following code is to determine if a new query is
2165            // called for.  If the criteria is the same as the last
2166            // one, just return the collection.
2167
2168                            criteria.add(AttributePeer.CREATED_BY, getUserId() );
2169                        if (!lastAttributesCriteria.equals(criteria))
2170            {
2171                collAttributes = AttributePeer.doSelectJoinScarabUserImpl(criteria);
2172            }
2173        }
2174        lastAttributesCriteria = criteria;
2175
2176        return collAttributes;
2177    }
2178                            
2179
2180
2181                          
2182            
2183    /**
2184     * Collection to store aggregation of collMITLists
2185     */
2186    protected List   collMITLists;
2187
2188    /**
2189     * Temporary storage of collMITLists to save a possible db hit in
2190     * the event objects are add to the collection, but the
2191     * complete collection is never requested.
2192     */
2193    protected void initMITLists()
2194    {
2195        if (collMITLists == null)
2196        {
2197            collMITLists = new ArrayList  ();
2198        }
2199    }
2200
2201                  
2202    /**
2203     * Method called to associate a MITList object to this object
2204     * through the MITList foreign key attribute
2205     *
2206     * @param l MITList
2207     * @throws TorqueException
2208     */
2209    public void addMITList(MITList l) throws TorqueException
2210    {
2211        getMITLists().add(l);
2212        l.setScarabUser((ScarabUserImpl)this);
2213    }
2214
2215    /**
2216     * The criteria used to select the current contents of collMITLists
2217     */
2218    private Criteria lastMITListsCriteria = null;
2219
2220    /**
2221     * If this collection has already been initialized, returns
2222     * the collection. Otherwise returns the results of
2223     * getMITLists(new Criteria())
2224     *
2225     * @throws TorqueException
2226     */
2227    public List   getMITLists() throws TorqueException
2228    {
2229        if (collMITLists == null)
2230        {
2231            collMITLists = getMITLists(new Criteria(10));
2232        }
2233        return collMITLists;
2234    }
2235
2236    /**
2237     * If this collection has already been initialized with
2238     * an identical criteria, it returns the collection.
2239     * Otherwise if this ScarabUserImpl has previously
2240     * been saved, it will retrieve related MITLists from storage.
2241     * If this ScarabUserImpl is new, it will return
2242     * an empty collection or the current collection, the criteria
2243     * is ignored on a new object.
2244     *
2245     * @throws TorqueException
2246     */
2247    public List   getMITLists(Criteria criteria) throws TorqueException
2248    {
2249        if (collMITLists == null)
2250        {
2251            if (isNew())
2252            {
2253               collMITLists = new ArrayList  ();
2254            }
2255            else
2256            {
2257                      criteria.add(MITListPeer.USER_ID, getUserId() );
2258                      collMITLists = MITListPeer.doSelect(criteria);
2259            }
2260        }
2261        else
2262        {
2263            // criteria has no effect for a new object
2264            if (!isNew())
2265            {
2266                // the following code is to determine if a new query is
2267                // called for.  If the criteria is the same as the last
2268                // one, just return the collection.
2269                      criteria.add(MITListPeer.USER_ID, getUserId() );
2270                      if (!lastMITListsCriteria.equals(criteria))
2271                {
2272                    collMITLists = MITListPeer.doSelect(criteria);
2273                }
2274            }
2275        }
2276        lastMITListsCriteria = criteria;
2277
2278        return collMITLists;
2279    }
2280
2281    /**
2282     * If this collection has already been initialized, returns
2283     * the collection. Otherwise returns the results of
2284     * getMITLists(new Criteria(),Connection)
2285     * This method takes in the Connection also as input so that
2286     * referenced objects can also be obtained using a Connection
2287     * that is taken as input
2288     */
2289    public List   getMITLists(Connection   con) throws TorqueException
2290    {
2291        if (collMITLists == null)
2292        {
2293            collMITLists = getMITLists(new Criteria(10),con);
2294        }
2295        return collMITLists;
2296    }
2297
2298    /**
2299     * If this collection has already been initialized with
2300     * an identical criteria, it returns the collection.
2301     * Otherwise if this ScarabUserImpl has previously
2302     * been saved, it will retrieve related MITLists from storage.
2303     * If this ScarabUserImpl is new, it will return
2304     * an empty collection or the current collection, the criteria
2305     * is ignored on a new object.
2306     * This method takes in the Connection also as input so that
2307     * referenced objects can also be obtained using a Connection
2308     * that is taken as input
2309     */
2310    public List   getMITLists(Criteria criteria,Connection   con) throws TorqueException
2311    {
2312        if (collMITLists == null)
2313        {
2314            if (isNew())
2315            {
2316               collMITLists = new ArrayList  ();
2317            }
2318            else
2319            {
2320                       criteria.add(MITListPeer.USER_ID, getUserId() );
2321                       collMITLists = MITListPeer.doSelect(criteria,con);
2322             }
2323         }
2324         else
2325         {
2326             // criteria has no effect for a new object
2327             if (!isNew())
2328             {
2329                 // the following code is to determine if a new query is
2330                 // called for.  If the criteria is the same as the last
2331                 // one, just return the collection.
2332                     criteria.add(MITListPeer.USER_ID, getUserId() );
2333                     if (!lastMITListsCriteria.equals(criteria))
2334                 {
2335                     collMITLists = MITListPeer.doSelect(criteria,con);
2336                 }
2337             }
2338         }
2339         lastMITListsCriteria = criteria;
2340
2341         return collMITLists;
2342     }
2343
2344                  
2345              
2346                    
2347                              
2348                                
2349                                                              
2350                                        
2351                    
2352                    
2353          
2354    /**
2355     * If this collection has already been initialized with
2356     * an identical criteria, it returns the collection.
2357     * Otherwise if this ScarabUserImpl is new, it will return
2358     * an empty collection; or if this ScarabUserImpl has previously
2359     * been saved, it will retrieve related MITLists from storage.
2360     *
2361     * This method is protected by default in order to keep the public
2362     * api reasonable.  You can provide public methods for those you
2363     * actually need in ScarabUserImpl.
2364     */
2365    protected List   getMITListsJoinScarabUserImpl(Criteria criteria)
2366        throws TorqueException
2367    {
2368        if (collMITLists == null)
2369        {
2370            if (isNew())
2371            {
2372               collMITLists = new ArrayList  ();
2373            }
2374            else
2375            {
2376                            criteria.add(MITListPeer.USER_ID, getUserId() );
2377                            collMITLists = MITListPeer.doSelectJoinScarabUserImpl(criteria);
2378            }
2379        }
2380        else
2381        {
2382            // the following code is to determine if a new query is
2383            // called for.  If the criteria is the same as the last
2384            // one, just return the collection.
2385
2386                            criteria.add(MITListPeer.USER_ID, getUserId() );
2387                        if (!lastMITListsCriteria.equals(criteria))
2388            {
2389                collMITLists = MITListPeer.doSelectJoinScarabUserImpl(criteria);
2390            }
2391        }
2392        lastMITListsCriteria = criteria;
2393
2394        return collMITLists;
2395    }
2396                            
2397
2398
2399                          
2400            
2401    /**
2402     * Collection to store aggregation of collAttributeValues
2403     */
2404    protected List   collAttributeValues;
2405
2406    /**
2407     * Temporary storage of collAttributeValues to save a possible db hit in
2408     * the event objects are add to the collection, but the
2409     * complete collection is never requested.
2410     */
2411    protected void initAttributeValues()
2412    {
2413        if (collAttributeValues == null)
2414        {
2415            collAttributeValues = new ArrayList  ();
2416        }
2417    }
2418
2419                  
2420    /**
2421     * Method called to associate a AttributeValue object to this object
2422     * through the AttributeValue foreign key attribute
2423     *
2424     * @param l AttributeValue
2425     * @throws TorqueException
2426     */
2427    public void addAttributeValue(AttributeValue l) throws TorqueException
2428    {
2429        getAttributeValues().add(l);
2430        l.setScarabUser((ScarabUserImpl)this);
2431    }
2432
2433    /**
2434     * The criteria used to select the current contents of collAttributeValues
2435     */
2436    private Criteria lastAttributeValuesCriteria = null;
2437
2438    /**
2439     * If this collection has already been initialized, returns
2440     * the collection. Otherwise returns the results of
2441     * getAttributeValues(new Criteria())
2442     *
2443     * @throws TorqueException
2444     */
2445    public List   getAttributeValues() throws TorqueException
2446    {
2447        if (collAttributeValues == null)
2448        {
2449            collAttributeValues = getAttributeValues(new Criteria(10));
2450        }
2451        return collAttributeValues;
2452    }
2453
2454    /**
2455     * If this collection has already been initialized with
2456     * an identical criteria, it returns the collection.
2457     * Otherwise if this ScarabUserImpl has previously
2458     * been saved, it will retrieve related AttributeValues from storage.
2459     * If this ScarabUserImpl is new, it will return
2460     * an empty collection or the current collection, the criteria
2461     * is ignored on a new object.
2462     *
2463     * @throws TorqueException
2464     */
2465    public List   getAttributeValues(Criteria criteria) throws TorqueException
2466    {
2467        if (collAttributeValues == null)
2468        {
2469            if (isNew())
2470            {
2471               collAttributeValues = new ArrayList  ();
2472            }
2473            else
2474            {
2475                      criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2476                      collAttributeValues = AttributeValuePeer.doSelect(criteria);
2477            }
2478        }
2479        else
2480        {
2481            // criteria has no effect for a new object
2482            if (!isNew())
2483            {
2484                // the following code is to determine if a new query is
2485                // called for.  If the criteria is the same as the last
2486                // one, just return the collection.
2487                      criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2488                      if (!lastAttributeValuesCriteria.equals(criteria))
2489                {
2490                    collAttributeValues = AttributeValuePeer.doSelect(criteria);
2491                }
2492            }
2493        }
2494        lastAttributeValuesCriteria = criteria;
2495
2496        return collAttributeValues;
2497    }
2498
2499    /**
2500     * If this collection has already been initialized, returns
2501     * the collection. Otherwise returns the results of
2502     * getAttributeValues(new Criteria(),Connection)
2503     * This method takes in the Connection also as input so that
2504     * referenced objects can also be obtained using a Connection
2505     * that is taken as input
2506     */
2507    public List   getAttributeValues(Connection   con) throws TorqueException
2508    {
2509        if (collAttributeValues == null)
2510        {
2511            collAttributeValues = getAttributeValues(new Criteria(10),con);
2512        }
2513        return collAttributeValues;
2514    }
2515
2516    /**
2517     * If this collection has already been initialized with
2518     * an identical criteria, it returns the collection.
2519     * Otherwise if this ScarabUserImpl has previously
2520     * been saved, it will retrieve related AttributeValues from storage.
2521     * If this ScarabUserImpl is new, it will return
2522     * an empty collection or the current collection, the criteria
2523     * is ignored on a new object.
2524     * This method takes in the Connection also as input so that
2525     * referenced objects can also be obtained using a Connection
2526     * that is taken as input
2527     */
2528    public List   getAttributeValues(Criteria criteria,Connection   con) throws TorqueException
2529    {
2530        if (collAttributeValues == null)
2531        {
2532            if (isNew())
2533            {
2534               collAttributeValues = new ArrayList  ();
2535            }
2536            else
2537            {
2538                       criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2539                       collAttributeValues = AttributeValuePeer.doSelect(criteria,con);
2540             }
2541         }
2542         else
2543         {
2544             // criteria has no effect for a new object
2545             if (!isNew())
2546             {
2547                 // the following code is to determine if a new query is
2548                 // called for.  If the criteria is the same as the last
2549                 // one, just return the collection.
2550                     criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2551                     if (!lastAttributeValuesCriteria.equals(criteria))
2552                 {
2553                     collAttributeValues = AttributeValuePeer.doSelect(criteria,con);
2554                 }
2555             }
2556         }
2557         lastAttributeValuesCriteria = criteria;
2558
2559         return collAttributeValues;
2560     }
2561
2562                                    
2563              
2564                    
2565                    
2566                                
2567                                                              
2568                                        
2569                    
2570                    
2571          
2572    /**
2573     * If this collection has already been initialized with
2574     * an identical criteria, it returns the collection.
2575     * Otherwise if this ScarabUserImpl is new, it will return
2576     * an empty collection; or if this ScarabUserImpl has previously
2577     * been saved, it will retrieve related AttributeValues from storage.
2578     *
2579     * This method is protected by default in order to keep the public
2580     * api reasonable.  You can provide public methods for those you
2581     * actually need in ScarabUserImpl.
2582     */
2583    protected List   getAttributeValuesJoinIssue(Criteria criteria)
2584        throws TorqueException
2585    {
2586        if (collAttributeValues == null)
2587        {
2588            if (isNew())
2589            {
2590               collAttributeValues = new ArrayList  ();
2591            }
2592            else
2593            {
2594                            criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2595                            collAttributeValues = AttributeValuePeer.doSelectJoinIssue(criteria);
2596            }
2597        }
2598        else
2599        {
2600            // the following code is to determine if a new query is
2601            // called for.  If the criteria is the same as the last
2602            // one, just return the collection.
2603
2604                            criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2605                        if (!lastAttributeValuesCriteria.equals(criteria))
2606            {
2607                collAttributeValues = AttributeValuePeer.doSelectJoinIssue(criteria);
2608            }
2609        }
2610        lastAttributeValuesCriteria = criteria;
2611
2612        return collAttributeValues;
2613    }
2614                  
2615                    
2616                    
2617                                
2618                                                              
2619                                        
2620                    
2621                    
2622          
2623    /**
2624     * If this collection has already been initialized with
2625     * an identical criteria, it returns the collection.
2626     * Otherwise if this ScarabUserImpl is new, it will return
2627     * an empty collection; or if this ScarabUserImpl has previously
2628     * been saved, it will retrieve related AttributeValues from storage.
2629     *
2630     * This method is protected by default in order to keep the public
2631     * api reasonable.  You can provide public methods for those you
2632     * actually need in ScarabUserImpl.
2633     */
2634    protected List   getAttributeValuesJoinAttribute(Criteria criteria)
2635        throws TorqueException
2636    {
2637        if (collAttributeValues == null)
2638        {
2639            if (isNew())
2640            {
2641               collAttributeValues = new ArrayList  ();
2642            }
2643            else
2644            {
2645                            criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2646                            collAttributeValues = AttributeValuePeer.doSelectJoinAttribute(criteria);
2647            }
2648        }
2649        else
2650        {
2651            // the following code is to determine if a new query is
2652            // called for.  If the criteria is the same as the last
2653            // one, just return the collection.
2654
2655                            criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2656                        if (!lastAttributeValuesCriteria.equals(criteria))
2657            {
2658                collAttributeValues = AttributeValuePeer.doSelectJoinAttribute(criteria);
2659            }
2660        }
2661        lastAttributeValuesCriteria = criteria;
2662
2663        return collAttributeValues;
2664    }
2665                  
2666                    
2667                    
2668                                
2669                                                              
2670                                        
2671                    
2672                    
2673          
2674    /**
2675     * If this collection has already been initialized with
2676     * an identical criteria, it returns the collection.
2677     * Otherwise if this ScarabUserImpl is new, it will return
2678     * an empty collection; or if this ScarabUserImpl has previously
2679     * been saved, it will retrieve related AttributeValues from storage.
2680     *
2681     * This method is protected by default in order to keep the public
2682     * api reasonable.  You can provide public methods for those you
2683     * actually need in ScarabUserImpl.
2684     */
2685    protected List   getAttributeValuesJoinAttributeOption(Criteria criteria)
2686        throws TorqueException
2687    {
2688        if (collAttributeValues == null)
2689        {
2690            if (isNew())
2691            {
2692               collAttributeValues = new ArrayList  ();
2693            }
2694            else
2695            {
2696                            criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2697                            collAttributeValues = AttributeValuePeer.doSelectJoinAttributeOption(criteria);
2698            }
2699        }
2700        else
2701        {
2702            // the following code is to determine if a new query is
2703            // called for.  If the criteria is the same as the last
2704            // one, just return the collection.
2705
2706                            criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2707                        if (!lastAttributeValuesCriteria.equals(criteria))
2708            {
2709                collAttributeValues = AttributeValuePeer.doSelectJoinAttributeOption(criteria);
2710            }
2711        }
2712        lastAttributeValuesCriteria = criteria;
2713
2714        return collAttributeValues;
2715    }
2716                  
2717                    
2718                              
2719                                
2720                                                              
2721                                        
2722                    
2723                    
2724          
2725    /**
2726     * If this collection has already been initialized with
2727     * an identical criteria, it returns the collection.
2728     * Otherwise if this ScarabUserImpl is new, it will return
2729     * an empty collection; or if this ScarabUserImpl has previously
2730     * been saved, it will retrieve related AttributeValues from storage.
2731     *
2732     * This method is protected by default in order to keep the public
2733     * api reasonable.  You can provide public methods for those you
2734     * actually need in ScarabUserImpl.
2735     */
2736    protected List   getAttributeValuesJoinScarabUserImpl(Criteria criteria)
2737        throws TorqueException
2738    {
2739        if (collAttributeValues == null)
2740        {
2741            if (isNew())
2742            {
2743               collAttributeValues = new ArrayList  ();
2744            }
2745            else
2746            {
2747                            criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2748                            collAttributeValues = AttributeValuePeer.doSelectJoinScarabUserImpl(criteria);
2749            }
2750        }
2751        else
2752        {
2753            // the following code is to determine if a new query is
2754            // called for.  If the criteria is the same as the last
2755            // one, just return the collection.
2756
2757                            criteria.add(AttributeValuePeer.USER_ID, getUserId() );
2758                        if (!lastAttributeValuesCriteria.equals(criteria))
2759            {
2760                collAttributeValues = AttributeValuePeer.doSelectJoinScarabUserImpl(criteria);
2761            }
2762        }
2763        lastAttributeValuesCriteria = criteria;
2764
2765        return collAttributeValues;
2766    }
2767                            
2768
2769
2770                                  
2771            
2772    /**
2773     * Collection to store aggregation of collScarabModulesRelatedByOwnerId
2774     */
2775    protected List   collScarabModulesRelatedByOwnerId;
2776
2777    /**
2778     * Temporary storage of collScarabModulesRelatedByOwnerId to save a possible db hit in
2779     * the event objects are add to the collection, but the
2780     * complete collection is never requested.
2781     */
2782    protected void initScarabModulesRelatedByOwnerId()
2783    {
2784        if (collScarabModulesRelatedByOwnerId == null)
2785        {
2786            collScarabModulesRelatedByOwnerId = new ArrayList  ();
2787        }
2788    }
2789
2790                  
2791    /**
2792     * Method called to associate a ScarabModule object to this object
2793     * through the ScarabModule foreign key attribute
2794     *
2795     * @param l ScarabModule
2796     * @throws TorqueException
2797     */
2798    public void addScarabModuleRelatedByOwnerId(ScarabModule l) throws TorqueException
2799    {
2800        getScarabModulesRelatedByOwnerId().add(l);
2801        l.setScarabUserRelatedByOwnerId((ScarabUserImpl)this);
2802    }
2803
2804    /**
2805     * The criteria used to select the current contents of collScarabModulesRelatedByOwnerId
2806     */
2807    private Criteria lastScarabModulesRelatedByOwnerIdCriteria = null;
2808
2809    /**
2810     * If this collection has already been initialized, returns
2811     * the collection. Otherwise returns the results of
2812     * getScarabModulesRelatedByOwnerId(new Criteria())
2813     *
2814     * @throws TorqueException
2815     */
2816    public List   getScarabModulesRelatedByOwnerId() throws TorqueException
2817    {
2818        if (collScarabModulesRelatedByOwnerId == null)
2819        {
2820            collScarabModulesRelatedByOwnerId = getScarabModulesRelatedByOwnerId(new Criteria(10));
2821        }
2822        return collScarabModulesRelatedByOwnerId;
2823    }
2824
2825    /**
2826     * If this collection has already been initialized with
2827     * an identical criteria, it returns the collection.
2828     * Otherwise if this ScarabUserImpl has previously
2829     * been saved, it will retrieve related ScarabModulesRelatedByOwnerId from storage.
2830     * If this ScarabUserImpl is new, it will return
2831     * an empty collection or the current collection, the criteria
2832     * is ignored on a new object.
2833     *
2834     * @throws TorqueException
2835     */
2836    public List   getScarabModulesRelatedByOwnerId(Criteria criteria) throws TorqueException
2837    {
2838        if (collScarabModulesRelatedByOwnerId == null)
2839        {
2840            if (isNew())
2841            {
2842               collScarabModulesRelatedByOwnerId = new ArrayList  ();
2843            }
2844            else
2845            {
2846                      criteria.add(ScarabModulePeer.OWNER_ID, getUserId() );
2847                      collScarabModulesRelatedByOwnerId = ScarabModulePeer.doSelect(criteria);
2848            }
2849        }
2850        else
2851        {
2852            // criteria has no effect for a new object
2853            if (!isNew())
2854            {
2855                // the following code is to determine if a new query is
2856                // called for.  If the criteria is the same as the last
2857                // one, just return the collection.
2858                      criteria.add(ScarabModulePeer.OWNER_ID, getUserId() );
2859                      if (!lastScarabModulesRelatedByOwnerIdCriteria.equals(criteria))
2860                {
2861                    collScarabModulesRelatedByOwnerId = ScarabModulePeer.doSelect(criteria);
2862                }
2863            }
2864        }
2865        lastScarabModulesRelatedByOwnerIdCriteria = criteria;
2866
2867        return collScarabModulesRelatedByOwnerId;
2868    }
2869
2870    /**
2871     * If this collection has already been initialized, returns
2872     * the collection. Otherwise returns the results of
2873     * getScarabModulesRelatedByOwnerId(new Criteria(),Connection)
2874     * This method takes in the Connection also as input so that
2875     * referenced objects can also be obtained using a Connection
2876     * that is taken as input
2877     */
2878    public List   getScarabModulesRelatedByOwnerId(Connection   con) throws TorqueException
2879    {
2880        if (collScarabModulesRelatedByOwnerId == null)
2881        {
2882            collScarabModulesRelatedByOwnerId = getScarabModulesRelatedByOwnerId(new Criteria(10),con);
2883        }
2884        return collScarabModulesRelatedByOwnerId;
2885    }
2886
2887    /**
2888     * If this collection has already been initialized with
2889     * an identical criteria, it returns the collection.
2890     * Otherwise if this ScarabUserImpl has previously
2891     * been saved, it will retrieve related ScarabModulesRelatedByOwnerId from storage.
2892     * If this ScarabUserImpl is new, it will return
2893     * an empty collection or the current collection, the criteria
2894     * is ignored on a new object.
2895     * This method takes in the Connection also as input so that
2896     * referenced objects can also be obtained using a Connection
2897     * that is taken as input
2898     */
2899    public List   getScarabModulesRelatedByOwnerId(Criteria criteria,Connection   con) throws TorqueException
2900    {
2901        if (collScarabModulesRelatedByOwnerId == null)
2902        {
2903            if (isNew())
2904            {
2905               collScarabModulesRelatedByOwnerId = new ArrayList  ();
2906            }
2907            else
2908            {
2909                       criteria.add(ScarabModulePeer.OWNER_ID, getUserId() );
2910                       collScarabModulesRelatedByOwnerId = ScarabModulePeer.doSelect(criteria,con);
2911             }
2912         }
2913         else
2914         {
2915             // criteria has no effect for a new object
2916             if (!isNew())
2917             {
2918                 // the following code is to determine if a new query is
2919                 // called for.  If the criteria is the same as the last
2920                 // one, just return the collection.
2921                     criteria.add(ScarabModulePeer.OWNER_ID, getUserId() );
2922                     if (!lastScarabModulesRelatedByOwnerIdCriteria.equals(criteria))
2923                 {
2924                     collScarabModulesRelatedByOwnerId = ScarabModulePeer.doSelect(criteria,con);
2925                 }
2926             }
2927         }
2928         lastScarabModulesRelatedByOwnerIdCriteria = criteria;
2929
2930         return collScarabModulesRelatedByOwnerId;
2931     }
2932
2933                              
2934              
2935                    
2936                    
2937                                
2938                                                              
2939                                                  
2940                    
2941                                
2942                  
2943                    
2944                              
2945                                            
2946                                                                          
2947                                        
2948                    
2949                                            
2950                  
2951                    
2952                              
2953                                            
2954                                                                          
2955                                        
2956                    
2957                                
2958          
2959    /**
2960     * If this collection has already been initialized with
2961     * an identical criteria, it returns the collection.
2962     * Otherwise if this ScarabUserImpl is new, it will return
2963     * an empty collection; or if this ScarabUserImpl has previously
2964     * been saved, it will retrieve related ScarabModulesRelatedByOwnerId from storage.
2965     *
2966     * This method is protected by default in order to keep the public
2967     * api reasonable.  You can provide public methods for those you
2968     * actually need in ScarabUserImpl.
2969     */
2970    protected List   getScarabModulesRelatedByOwnerIdJoinScarabUserImplRelatedByQaContactId(Criteria criteria)
2971        throws TorqueException
2972    {
2973        if (collScarabModulesRelatedByOwnerId == null)
2974        {
2975            if (isNew())
2976            {
2977               collScarabModulesRelatedByOwnerId = new ArrayList  ();
2978            }
2979            else
2980            {
2981                            criteria.add(ScarabModulePeer.OWNER_ID, getUserId() );
2982                            collScarabModulesRelatedByOwnerId = ScarabModulePeer.doSelectJoinScarabUserImplRelatedByQaContactId(criteria);
2983            }
2984        }
2985        else
2986        {
2987            // the following code is to determine if a new query is
2988            // called for.  If the criteria is the same as the last
2989            // one, just return the collection.
2990
2991                            criteria.add(ScarabModulePeer.OWNER_ID, getUserId() );
2992                        if (!lastScarabModulesRelatedByOwnerIdCriteria.equals(criteria))
2993            {
2994                collScarabModulesRelatedByOwnerId = ScarabModulePeer.doSelectJoinScarabUserImplRelatedByQaContactId(criteria);
2995            }
2996        }
2997        lastScarabModulesRelatedByOwnerIdCriteria = criteria;
2998
2999        return collScarabModulesRelatedByOwnerId;
3000    }
3001                            
3002
3003
3004                                  
3005            
3006    /**
3007     * Collection to store aggregation of collScarabModulesRelatedByQaContactId
3008     */
3009    protected List   collScarabModulesRelatedByQaContactId;
3010
3011    /**
3012     * Temporary storage of collScarabModulesRelatedByQaContactId to save a possible db hit in
3013     * the event objects are add to the collection, but the
3014     * complete collection is never requested.
3015     */
3016    protected void initScarabModulesRelatedByQaContactId()
3017    {
3018        if (collScarabModulesRelatedByQaContactId == null)
3019        {
3020            collScarabModulesRelatedByQaContactId = new ArrayList  ();
3021        }
3022    }
3023
3024                  
3025    /**
3026     * Method called to associate a ScarabModule object to this object
3027     * through the ScarabModule foreign key attribute
3028     *
3029     * @param l ScarabModule
3030     * @throws TorqueException
3031     */
3032    public void addScarabModuleRelatedByQaContactId(ScarabModule l) throws TorqueException
3033    {
3034        getScarabModulesRelatedByQaContactId().add(l);
3035        l.setScarabUserRelatedByQaContactId((ScarabUserImpl)this);
3036    }
3037
3038    /**
3039     * The criteria used to select the current contents of collScarabModulesRelatedByQaContactId
3040     */
3041    private Criteria lastScarabModulesRelatedByQaContactIdCriteria = null;
3042
3043    /**
3044     * If this collection has already been initialized, returns
3045     * the collection. Otherwise returns the results of
3046     * getScarabModulesRelatedByQaContactId(new Criteria())
3047     *
3048     * @throws TorqueException
3049     */
3050    public List   getScarabModulesRelatedByQaContactId() throws TorqueException
3051    {
3052        if (collScarabModulesRelatedByQaContactId == null)
3053        {
3054            collScarabModulesRelatedByQaContactId = getScarabModulesRelatedByQaContactId(new Criteria(10));
3055        }
3056        return collScarabModulesRelatedByQaContactId;
3057    }
3058
3059    /**
3060     * If this collection has already been initialized with
3061     * an identical criteria, it returns the collection.
3062     * Otherwise if this ScarabUserImpl has previously
3063     * been saved, it will retrieve related ScarabModulesRelatedByQaContactId from storage.
3064     * If this ScarabUserImpl is new, it will return
3065     * an empty collection or the current collection, the criteria
3066     * is ignored on a new object.
3067     *
3068     * @throws TorqueException
3069     */
3070    public List   getScarabModulesRelatedByQaContactId(Criteria criteria) throws TorqueException
3071    {
3072        if (collScarabModulesRelatedByQaContactId == null)
3073        {
3074            if (isNew())
3075            {
3076               collScarabModulesRelatedByQaContactId = new ArrayList  ();
3077            }
3078            else
3079            {
3080                      criteria.add(ScarabModulePeer.QA_CONTACT_ID, getUserId() );
3081                      collScarabModulesRelatedByQaContactId = ScarabModulePeer.doSelect(criteria);
3082            }
3083        }
3084        else
3085        {
3086            // criteria has no effect for a new object
3087            if (!isNew())
3088            {
3089                // the following code is to determine if a new query is
3090                // called for.  If the criteria is the same as the last
3091                // one, just return the collection.
3092                      criteria.add(ScarabModulePeer.QA_CONTACT_ID, getUserId() );
3093                      if (!lastScarabModulesRelatedByQaContactIdCriteria.equals(criteria))
3094                {
3095                    collScarabModulesRelatedByQaContactId = ScarabModulePeer.doSelect(criteria);
3096                }
3097            }
3098        }
3099        lastScarabModulesRelatedByQaContactIdCriteria = criteria;
3100
3101        return collScarabModulesRelatedByQaContactId;
3102    }
3103
3104    /**
3105     * If this collection has already been initialized, returns
3106     * the collection. Otherwise returns the results of
3107     * getScarabModulesRelatedByQaContactId(new Criteria(),Connection)
3108     * This method takes in the Connection also as input so that
3109     * referenced objects can also be obtained using a Connection
3110     * that is taken as input
3111     */
3112    public List   getScarabModulesRelatedByQaContactId(Connection   con) throws TorqueException
3113    {
3114        if (collScarabModulesRelatedByQaContactId == null)
3115        {
3116            collScarabModulesRelatedByQaContactId = getScarabModulesRelatedByQaContactId(new Criteria(10),con);
3117        }
3118        return collScarabModulesRelatedByQaContactId;
3119    }
3120
3121    /**
3122     * If this collection has already been initialized with
3123     * an identical criteria, it returns the collection.
3124     * Otherwise if this ScarabUserImpl has previously
3125     * been saved, it will retrieve related ScarabModulesRelatedByQaContactId from storage.
3126     * If this ScarabUserImpl is new, it will return
3127     * an empty collection or the current collection, the criteria
3128     * is ignored on a new object.
3129     * This method takes in the Connection also as input so that
3130     * referenced objects can also be obtained using a Connection
3131     * that is taken as input
3132     */
3133    public List   getScarabModulesRelatedByQaContactId(Criteria criteria,Connection   con) throws TorqueException
3134    {
3135        if (collScarabModulesRelatedByQaContactId == null)
3136        {
3137            if (isNew())
3138            {
3139               collScarabModulesRelatedByQaContactId = new ArrayList  ();
3140            }
3141            else
3142            {
3143                       criteria.add(ScarabModulePeer.QA_CONTACT_ID, getUserId() );
3144                       collScarabModulesRelatedByQaContactId = ScarabModulePeer.doSelect(criteria,con);
3145             }
3146         }
3147         else
3148         {
3149             // criteria has no effect for a new object
3150             if (!isNew())
3151             {
3152                 // the following code is to determine if a new query is
3153                 // called for.  If the criteria is the same as the last
3154                 // one, just return the collection.
3155                     criteria.add(ScarabModulePeer.QA_CONTACT_ID, getUserId() );
3156                     if (!lastScarabModulesRelatedByQaContactIdCriteria.equals(criteria))
3157                 {
3158                     collScarabModulesRelatedByQaContactId = ScarabModulePeer.doSelect(criteria,con);
3159                 }
3160             }
3161         }
3162         lastScarabModulesRelatedByQaContactIdCriteria = criteria;
3163
3164         return collScarabModulesRelatedByQaContactId;
3165     }
3166
3167                              
3168              
3169                    
3170                    
3171                                
3172                                                              
3173                                                  
3174                    
3175                                
3176                  
3177                    
3178                              
3179                                            
3180                                                                          
3181                                        
3182                    
3183                                
3184          
3185    /**
3186     * If this collection has already been initialized with
3187     * an identical criteria, it returns the collection.
3188     * Otherwise if this ScarabUserImpl is new, it will return
3189     * an empty collection; or if this ScarabUserImpl has previously
3190     * been saved, it will retrieve related ScarabModulesRelatedByQaContactId from storage.
3191     *
3192     * This method is protected by default in order to keep the public
3193     * api reasonable.  You can provide public methods for those you
3194     * actually need in ScarabUserImpl.
3195     */
3196    protected List   getScarabModulesRelatedByQaContactIdJoinScarabUserImplRelatedByOwnerId(Criteria criteria)
3197        throws TorqueException
3198    {
3199        if (collScarabModulesRelatedByQaContactId == null)
3200        {
3201            if (isNew())
3202            {
3203               collScarabModulesRelatedByQaContactId = new ArrayList  ();
3204            }
3205            else
3206            {
3207                            criteria.add(ScarabModulePeer.QA_CONTACT_ID, getUserId() );
3208                            collScarabModulesRelatedByQaContactId = ScarabModulePeer.doSelectJoinScarabUserImplRelatedByOwnerId(criteria);
3209            }
3210        }
3211        else
3212        {
3213            // the following code is to determine if a new query is
3214            // called for.  If the criteria is the same as the last
3215            // one, just return the collection.
3216
3217                            criteria.add(ScarabModulePeer.QA_CONTACT_ID, getUserId() );
3218                        if (!lastScarabModulesRelatedByQaContactIdCriteria.equals(criteria))
3219            {
3220                collScarabModulesRelatedByQaContactId = ScarabModulePeer.doSelectJoinScarabUserImplRelatedByOwnerId(criteria);
3221            }
3222        }
3223        lastScarabModulesRelatedByQaContactIdCriteria = criteria;
3224
3225        return collScarabModulesRelatedByQaContactId;
3226    }
3227                  
3228                    
3229                              
3230                                            
3231                                                                          
3232                                        
3233                    
3234                                            
3235                            
3236
3237
3238                          
3239            
3240    /**
3241     * Collection to store aggregation of collRModuleUserAttributes
3242     */
3243    protected List   collRModuleUserAttributes;
3244
3245    /**
3246     * Temporary storage of collRModuleUserAttributes to save a possible db hit in
3247     * the event objects are add to the collection, but the
3248     * complete collection is never requested.
3249     */
3250    protected void initRModuleUserAttributes()
3251    {
3252        if (collRModuleUserAttributes == null)
3253        {
3254            collRModuleUserAttributes = new ArrayList  ();
3255        }
3256    }
3257
3258                  
3259    /**
3260     * Method called to associate a RModuleUserAttribute object to this object
3261     * through the RModuleUserAttribute foreign key attribute
3262     *
3263     * @param l RModuleUserAttribute
3264     * @throws TorqueException
3265     */
3266    public void addRModuleUserAttribute(RModuleUserAttribute l) throws TorqueException
3267    {
3268        getRModuleUserAttributes().add(l);
3269        l.setScarabUser((ScarabUserImpl)this);
3270    }
3271
3272    /**
3273     * The criteria used to select the current contents of collRModuleUserAttributes
3274     */
3275    private Criteria lastRModuleUserAttributesCriteria = null;
3276
3277    /**
3278     * If this collection has already been initialized, returns
3279     * the collection. Otherwise returns the results of
3280     * getRModuleUserAttributes(new Criteria())
3281     *
3282     * @throws TorqueException
3283     */
3284    public List   getRModuleUserAttributes() throws TorqueException
3285    {
3286        if (collRModuleUserAttributes == null)
3287        {
3288            collRModuleUserAttributes = getRModuleUserAttributes(new Criteria(10));
3289        }
3290        return collRModuleUserAttributes;
3291    }
3292
3293    /**
3294     * If this collection has already been initialized with
3295     * an identical criteria, it returns the collection.
3296     * Otherwise if this ScarabUserImpl has previously
3297     * been saved, it will retrieve related RModuleUserAttributes from storage.
3298     * If this ScarabUserImpl is new, it will return
3299     * an empty collection or the current collection, the criteria
3300     * is ignored on a new object.
3301     *
3302     * @throws TorqueException
3303     */
3304    public List   getRModuleUserAttributes(Criteria criteria) throws TorqueException
3305    {
3306        if (collRModuleUserAttributes == null)
3307        {
3308            if (isNew())
3309            {
3310               collRModuleUserAttributes = new ArrayList  ();
3311            }
3312            else
3313            {
3314                      criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3315                      collRModuleUserAttributes = RModuleUserAttributePeer.doSelect(criteria);
3316            }
3317        }
3318        else
3319        {
3320            // criteria has no effect for a new object
3321            if (!isNew())
3322            {
3323                // the following code is to determine if a new query is
3324                // called for.  If the criteria is the same as the last
3325                // one, just return the collection.
3326                      criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3327                      if (!lastRModuleUserAttributesCriteria.equals(criteria))
3328                {
3329                    collRModuleUserAttributes = RModuleUserAttributePeer.doSelect(criteria);
3330                }
3331            }
3332        }
3333        lastRModuleUserAttributesCriteria = criteria;
3334
3335        return collRModuleUserAttributes;
3336    }
3337
3338    /**
3339     * If this collection has already been initialized, returns
3340     * the collection. Otherwise returns the results of
3341     * getRModuleUserAttributes(new Criteria(),Connection)
3342     * This method takes in the Connection also as input so that
3343     * referenced objects can also be obtained using a Connection
3344     * that is taken as input
3345     */
3346    public List   getRModuleUserAttributes(Connection   con) throws TorqueException
3347    {
3348        if (collRModuleUserAttributes == null)
3349        {
3350            collRModuleUserAttributes = getRModuleUserAttributes(new Criteria(10),con);
3351        }
3352        return collRModuleUserAttributes;
3353    }
3354
3355    /**
3356     * If this collection has already been initialized with
3357     * an identical criteria, it returns the collection.
3358     * Otherwise if this ScarabUserImpl has previously
3359     * been saved, it will retrieve related RModuleUserAttributes from storage.
3360     * If this ScarabUserImpl is new, it will return
3361     * an empty collection or the current collection, the criteria
3362     * is ignored on a new object.
3363     * This method takes in the Connection also as input so that
3364     * referenced objects can also be obtained using a Connection
3365     * that is taken as input
3366     */
3367    public List   getRModuleUserAttributes(Criteria criteria,Connection   con) throws TorqueException
3368    {
3369        if (collRModuleUserAttributes == null)
3370        {
3371            if (isNew())
3372            {
3373               collRModuleUserAttributes = new ArrayList  ();
3374            }
3375            else
3376            {
3377                       criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3378                       collRModuleUserAttributes = RModuleUserAttributePeer.doSelect(criteria,con);
3379             }
3380         }
3381         else
3382         {
3383             // criteria has no effect for a new object
3384             if (!isNew())
3385             {
3386                 // the following code is to determine if a new query is
3387                 // called for.  If the criteria is the same as the last
3388                 // one, just return the collection.
3389                     criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3390                     if (!lastRModuleUserAttributesCriteria.equals(criteria))
3391                 {
3392                     collRModuleUserAttributes = RModuleUserAttributePeer.doSelect(criteria,con);
3393                 }
3394             }
3395         }
3396         lastRModuleUserAttributesCriteria = criteria;
3397
3398         return collRModuleUserAttributes;
3399     }
3400
3401                                          
3402              
3403                    
3404                    
3405                                
3406                                                              
3407                                        
3408                    
3409                    
3410          
3411    /**
3412     * If this collection has already been initialized with
3413     * an identical criteria, it returns the collection.
3414     * Otherwise if this ScarabUserImpl is new, it will return
3415     * an empty collection; or if this ScarabUserImpl has previously
3416     * been saved, it will retrieve related RModuleUserAttributes from storage.
3417     *
3418     * This method is protected by default in order to keep the public
3419     * api reasonable.  You can provide public methods for those you
3420     * actually need in ScarabUserImpl.
3421     */
3422    protected List   getRModuleUserAttributesJoinMITList(Criteria criteria)
3423        throws TorqueException
3424    {
3425        if (collRModuleUserAttributes == null)
3426        {
3427            if (isNew())
3428            {
3429               collRModuleUserAttributes = new ArrayList  ();
3430            }
3431            else
3432            {
3433                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3434                            collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinMITList(criteria);
3435            }
3436        }
3437        else
3438        {
3439            // the following code is to determine if a new query is
3440            // called for.  If the criteria is the same as the last
3441            // one, just return the collection.
3442
3443                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3444                        if (!lastRModuleUserAttributesCriteria.equals(criteria))
3445            {
3446                collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinMITList(criteria);
3447            }
3448        }
3449        lastRModuleUserAttributesCriteria = criteria;
3450
3451        return collRModuleUserAttributes;
3452    }
3453                  
3454                    
3455                    
3456                                
3457                                                              
3458                                        
3459                    
3460                    
3461          
3462    /**
3463     * If this collection has already been initialized with
3464     * an identical criteria, it returns the collection.
3465     * Otherwise if this ScarabUserImpl is new, it will return
3466     * an empty collection; or if this ScarabUserImpl has previously
3467     * been saved, it will retrieve related RModuleUserAttributes from storage.
3468     *
3469     * This method is protected by default in order to keep the public
3470     * api reasonable.  You can provide public methods for those you
3471     * actually need in ScarabUserImpl.
3472     */
3473    protected List   getRModuleUserAttributesJoinScarabModule(Criteria criteria)
3474        throws TorqueException
3475    {
3476        if (collRModuleUserAttributes == null)
3477        {
3478            if (isNew())
3479            {
3480               collRModuleUserAttributes = new ArrayList  ();
3481            }
3482            else
3483            {
3484                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3485                            collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinScarabModule(criteria);
3486            }
3487        }
3488        else
3489        {
3490            // the following code is to determine if a new query is
3491            // called for.  If the criteria is the same as the last
3492            // one, just return the collection.
3493
3494                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3495                        if (!lastRModuleUserAttributesCriteria.equals(criteria))
3496            {
3497                collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinScarabModule(criteria);
3498            }
3499        }
3500        lastRModuleUserAttributesCriteria = criteria;
3501
3502        return collRModuleUserAttributes;
3503    }
3504                  
3505                    
3506                              
3507                                
3508                                                              
3509                                        
3510                    
3511                    
3512          
3513    /**
3514     * If this collection has already been initialized with
3515     * an identical criteria, it returns the collection.
3516     * Otherwise if this ScarabUserImpl is new, it will return
3517     * an empty collection; or if this ScarabUserImpl has previously
3518     * been saved, it will retrieve related RModuleUserAttributes from storage.
3519     *
3520     * This method is protected by default in order to keep the public
3521     * api reasonable.  You can provide public methods for those you
3522     * actually need in ScarabUserImpl.
3523     */
3524    protected List   getRModuleUserAttributesJoinScarabUserImpl(Criteria criteria)
3525        throws TorqueException
3526    {
3527        if (collRModuleUserAttributes == null)
3528        {
3529            if (isNew())
3530            {
3531               collRModuleUserAttributes = new ArrayList  ();
3532            }
3533            else
3534            {
3535                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3536                            collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinScarabUserImpl(criteria);
3537            }
3538        }
3539        else
3540        {
3541            // the following code is to determine if a new query is
3542            // called for.  If the criteria is the same as the last
3543            // one, just return the collection.
3544
3545                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3546                        if (!lastRModuleUserAttributesCriteria.equals(criteria))
3547            {
3548                collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinScarabUserImpl(criteria);
3549            }
3550        }
3551        lastRModuleUserAttributesCriteria = criteria;
3552
3553        return collRModuleUserAttributes;
3554    }
3555                  
3556                    
3557                    
3558                                
3559                                                              
3560                                        
3561                    
3562                    
3563          
3564    /**
3565     * If this collection has already been initialized with
3566     * an identical criteria, it returns the collection.
3567     * Otherwise if this ScarabUserImpl is new, it will return
3568     * an empty collection; or if this ScarabUserImpl has previously
3569     * been saved, it will retrieve related RModuleUserAttributes from storage.
3570     *
3571     * This method is protected by default in order to keep the public
3572     * api reasonable.  You can provide public methods for those you
3573     * actually need in ScarabUserImpl.
3574     */
3575    protected List   getRModuleUserAttributesJoinIssueType(Criteria criteria)
3576        throws TorqueException
3577    {
3578        if (collRModuleUserAttributes == null)
3579        {
3580            if (isNew())
3581            {
3582               collRModuleUserAttributes = new ArrayList  ();
3583            }
3584            else
3585            {
3586                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3587                            collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinIssueType(criteria);
3588            }
3589        }
3590        else
3591        {
3592            // the following code is to determine if a new query is
3593            // called for.  If the criteria is the same as the last
3594            // one, just return the collection.
3595
3596                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3597                        if (!lastRModuleUserAttributesCriteria.equals(criteria))
3598            {
3599                collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinIssueType(criteria);
3600            }
3601        }
3602        lastRModuleUserAttributesCriteria = criteria;
3603
3604        return collRModuleUserAttributes;
3605    }
3606                  
3607                    
3608                    
3609                                
3610                                                              
3611                                        
3612                    
3613                    
3614          
3615    /**
3616     * If this collection has already been initialized with
3617     * an identical criteria, it returns the collection.
3618     * Otherwise if this ScarabUserImpl is new, it will return
3619     * an empty collection; or if this ScarabUserImpl has previously
3620     * been saved, it will retrieve related RModuleUserAttributes from storage.
3621     *
3622     * This method is protected by default in order to keep the public
3623     * api reasonable.  You can provide public methods for those you
3624     * actually need in ScarabUserImpl.
3625     */
3626    protected List   getRModuleUserAttributesJoinAttribute(Criteria criteria)
3627        throws TorqueException
3628    {
3629        if (collRModuleUserAttributes == null)
3630        {
3631            if (isNew())
3632            {
3633               collRModuleUserAttributes = new ArrayList  ();
3634            }
3635            else
3636            {
3637                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3638                            collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinAttribute(criteria);
3639            }
3640        }
3641        else
3642        {
3643            // the following code is to determine if a new query is
3644            // called for.  If the criteria is the same as the last
3645            // one, just return the collection.
3646
3647                            criteria.add(RModuleUserAttributePeer.USER_ID, getUserId() );
3648                        if (!lastRModuleUserAttributesCriteria.equals(criteria))
3649            {
3650                collRModuleUserAttributes = RModuleUserAttributePeer.doSelectJoinAttribute(criteria);
3651            }
3652        }
3653        lastRModuleUserAttributesCriteria = criteria;
3654
3655        return collRModuleUserAttributes;
3656    }
3657                            
3658
3659
3660                          
3661            
3662    /**
3663     * Collection to store aggregation of collActivitySets
3664     */
3665    protected List   collActivitySets;
3666
3667    /**
3668     * Temporary storage of collActivitySets to save a possible db hit in
3669     * the event objects are add to the collection, but the
3670     * complete collection is never requested.
3671     */
3672    protected void initActivitySets()
3673    {
3674        if (collActivitySets == null)
3675        {
3676            collActivitySets = new ArrayList  ();
3677        }
3678    }
3679
3680                  
3681    /**
3682     * Method called to associate a ActivitySet object to this object
3683     * through the ActivitySet foreign key attribute
3684     *
3685     * @param l ActivitySet
3686     * @throws TorqueException
3687     */
3688    public void addActivitySet(ActivitySet l) throws TorqueException
3689    {
3690        getActivitySets().add(l);
3691        l.setScarabUser((ScarabUserImpl)this);
3692    }
3693
3694    /**
3695     * The criteria used to select the current contents of collActivitySets
3696     */
3697    private Criteria lastActivitySetsCriteria = null;
3698
3699    /**
3700     * If this collection has already been initialized, returns
3701     * the collection. Otherwise returns the results of
3702     * getActivitySets(new Criteria())
3703     *
3704     * @throws TorqueException
3705     */
3706    public List   getActivitySets() throws TorqueException
3707    {
3708        if (collActivitySets == null)
3709        {
3710            collActivitySets = getActivitySets(new Criteria(10));
3711        }
3712        return collActivitySets;
3713    }
3714
3715    /**
3716     * If this collection has already been initialized with
3717     * an identical criteria, it returns the collection.
3718     * Otherwise if this ScarabUserImpl has previously
3719     * been saved, it will retrieve related ActivitySets from storage.
3720     * If this ScarabUserImpl is new, it will return
3721     * an empty collection or the current collection, the criteria
3722     * is ignored on a new object.
3723     *
3724     * @throws TorqueException
3725     */
3726    public List   getActivitySets(Criteria criteria) throws TorqueException
3727    {
3728        if (collActivitySets == null)
3729        {
3730            if (isNew())
3731            {
3732               collActivitySets = new ArrayList  ();
3733            }
3734            else
3735            {
3736                      criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3737                      collActivitySets = ActivitySetPeer.doSelect(criteria);
3738            }
3739        }
3740        else
3741        {
3742            // criteria has no effect for a new object
3743            if (!isNew())
3744            {
3745                // the following code is to determine if a new query is
3746                // called for.  If the criteria is the same as the last
3747                // one, just return the collection.
3748                      criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3749                      if (!lastActivitySetsCriteria.equals(criteria))
3750                {
3751                    collActivitySets = ActivitySetPeer.doSelect(criteria);
3752                }
3753            }
3754        }
3755        lastActivitySetsCriteria = criteria;
3756
3757        return collActivitySets;
3758    }
3759
3760    /**
3761     * If this collection has already been initialized, returns
3762     * the collection. Otherwise returns the results of
3763     * getActivitySets(new Criteria(),Connection)
3764     * This method takes in the Connection also as input so that
3765     * referenced objects can also be obtained using a Connection
3766     * that is taken as input
3767     */
3768    public List   getActivitySets(Connection   con) throws TorqueException
3769    {
3770        if (collActivitySets == null)
3771        {
3772            collActivitySets = getActivitySets(new Criteria(10),con);
3773        }
3774        return collActivitySets;
3775    }
3776
3777    /**
3778     * If this collection has already been initialized with
3779     * an identical criteria, it returns the collection.
3780     * Otherwise if this ScarabUserImpl has previously
3781     * been saved, it will retrieve related ActivitySets from storage.
3782     * If this ScarabUserImpl is new, it will return
3783     * an empty collection or the current collection, the criteria
3784     * is ignored on a new object.
3785     * This method takes in the Connection also as input so that
3786     * referenced objects can also be obtained using a Connection
3787     * that is taken as input
3788     */
3789    public List   getActivitySets(Criteria criteria,Connection   con) throws TorqueException
3790    {
3791        if (collActivitySets == null)
3792        {
3793            if (isNew())
3794            {
3795               collActivitySets = new ArrayList  ();
3796            }
3797            else
3798            {
3799                       criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3800                       collActivitySets = ActivitySetPeer.doSelect(criteria,con);
3801             }
3802         }
3803         else
3804         {
3805             // criteria has no effect for a new object
3806             if (!isNew())
3807             {
3808                 // the following code is to determine if a new query is
3809                 // called for.  If the criteria is the same as the last
3810                 // one, just return the collection.
3811                     criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3812                     if (!lastActivitySetsCriteria.equals(criteria))
3813                 {
3814                     collActivitySets = ActivitySetPeer.doSelect(criteria,con);
3815                 }
3816             }
3817         }
3818         lastActivitySetsCriteria = criteria;
3819
3820         return collActivitySets;
3821     }
3822
3823                              
3824              
3825                    
3826                              
3827                                
3828                                                              
3829                                        
3830                    
3831                    
3832          
3833    /**
3834     * If this collection has already been initialized with
3835     * an identical criteria, it returns the collection.
3836     * Otherwise if this ScarabUserImpl is new, it will return
3837     * an empty collection; or if this ScarabUserImpl has previously
3838     * been saved, it will retrieve related ActivitySets from storage.
3839     *
3840     * This method is protected by default in order to keep the public
3841     * api reasonable.  You can provide public methods for those you
3842     * actually need in ScarabUserImpl.
3843     */
3844    protected List   getActivitySetsJoinScarabUserImpl(Criteria criteria)
3845        throws TorqueException
3846    {
3847        if (collActivitySets == null)
3848        {
3849            if (isNew())
3850            {
3851               collActivitySets = new ArrayList  ();
3852            }
3853            else
3854            {
3855                            criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3856                            collActivitySets = ActivitySetPeer.doSelectJoinScarabUserImpl(criteria);
3857            }
3858        }
3859        else
3860        {
3861            // the following code is to determine if a new query is
3862            // called for.  If the criteria is the same as the last
3863            // one, just return the collection.
3864
3865                            criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3866                        if (!lastActivitySetsCriteria.equals(criteria))
3867            {
3868                collActivitySets = ActivitySetPeer.doSelectJoinScarabUserImpl(criteria);
3869            }
3870        }
3871        lastActivitySetsCriteria = criteria;
3872
3873        return collActivitySets;
3874    }
3875                  
3876                    
3877                    
3878                                
3879                                                              
3880                                        
3881                    
3882                    
3883          
3884    /**
3885     * If this collection has already been initialized with
3886     * an identical criteria, it returns the collection.
3887     * Otherwise if this ScarabUserImpl is new, it will return
3888     * an empty collection; or if this ScarabUserImpl has previously
3889     * been saved, it will retrieve related ActivitySets from storage.
3890     *
3891     * This method is protected by default in order to keep the public
3892     * api reasonable.  You can provide public methods for those you
3893     * actually need in ScarabUserImpl.
3894     */
3895    protected List   getActivitySetsJoinActivitySetType(Criteria criteria)
3896        throws TorqueException
3897    {
3898        if (collActivitySets == null)
3899        {
3900            if (isNew())
3901            {
3902               collActivitySets = new ArrayList  ();
3903            }
3904            else
3905            {
3906                            criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3907                            collActivitySets = ActivitySetPeer.doSelectJoinActivitySetType(criteria);
3908            }
3909        }
3910        else
3911        {
3912            // the following code is to determine if a new query is
3913            // called for.  If the criteria is the same as the last
3914            // one, just return the collection.
3915
3916                            criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3917                        if (!lastActivitySetsCriteria.equals(criteria))
3918            {
3919                collActivitySets = ActivitySetPeer.doSelectJoinActivitySetType(criteria);
3920            }
3921        }
3922        lastActivitySetsCriteria = criteria;
3923
3924        return collActivitySets;
3925    }
3926                  
3927                    
3928                    
3929                                
3930                                                              
3931                                        
3932                    
3933                    
3934          
3935    /**
3936     * If this collection has already been initialized with
3937     * an identical criteria, it returns the collection.
3938     * Otherwise if this ScarabUserImpl is new, it will return
3939     * an empty collection; or if this ScarabUserImpl has previously
3940     * been saved, it will retrieve related ActivitySets from storage.
3941     *
3942     * This method is protected by default in order to keep the public
3943     * api reasonable.  You can provide public methods for those you
3944     * actually need in ScarabUserImpl.
3945     */
3946    protected List   getActivitySetsJoinAttachment(Criteria criteria)
3947        throws TorqueException
3948    {
3949        if (collActivitySets == null)
3950        {
3951            if (isNew())
3952            {
3953               collActivitySets = new ArrayList  ();
3954            }
3955            else
3956            {
3957                            criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3958                            collActivitySets = ActivitySetPeer.doSelectJoinAttachment(criteria);
3959            }
3960        }
3961        else
3962        {
3963            // the following code is to determine if a new query is
3964            // called for.  If the criteria is the same as the last
3965            // one, just return the collection.
3966
3967                            criteria.add(ActivitySetPeer.CREATED_BY, getUserId() );
3968                        if (!lastActivitySetsCriteria.equals(criteria))
3969            {
3970                collActivitySets = ActivitySetPeer.doSelectJoinAttachment(criteria);
3971            }
3972        }
3973        lastActivitySetsCriteria = criteria;
3974
3975        return collActivitySets;
3976    }
3977                            
3978
3979
3980                          
3981            
3982    /**
3983     * Collection to store aggregation of collUserPreferences
3984     */
3985    protected List   collUserPreferences;
3986
3987    /**
3988     * Temporary storage of collUserPreferences to save a possible db hit in
3989     * the event objects are add to the collection, but the
3990     * complete collection is never requested.
3991     */
3992    protected void initUserPreferences()
3993    {
3994        if (collUserPreferences == null)
3995        {
3996            collUserPreferences = new ArrayList  ();
3997        }
3998    }
3999
4000                  
4001    /**
4002     * Method called to associate a UserPreference object to this object
4003     * through the UserPreference foreign key attribute
4004     *
4005     * @param l UserPreference
4006     * @throws TorqueException
4007     */
4008    public void addUserPreference(UserPreference l) throws TorqueException
4009    {
4010        getUserPreferences().add(l);
4011        l.setScarabUser((ScarabUserImpl)this);
4012    }
4013
4014    /**
4015     * The criteria used to select the current contents of collUserPreferences
4016     */
4017    private Criteria lastUserPreferencesCriteria = null;
4018
4019    /**
4020     * If this collection has already been initialized, returns
4021     * the collection. Otherwise returns the results of
4022     * getUserPreferences(new Criteria())
4023     *
4024     * @throws TorqueException
4025     */
4026    public List   getUserPreferences() throws TorqueException
4027    {
4028        if (collUserPreferences == null)
4029        {
4030            collUserPreferences = getUserPreferences(new Criteria(10));
4031        }
4032        return collUserPreferences;
4033    }
4034
4035    /**
4036     * If this collection has already been initialized with
4037     * an identical criteria, it returns the collection.
4038     * Otherwise if this ScarabUserImpl has previously
4039     * been saved, it will retrieve related UserPreferences from storage.
4040     * If this ScarabUserImpl is new, it will return
4041     * an empty collection or the current collection, the criteria
4042     * is ignored on a new object.
4043     *
4044     * @throws TorqueException
4045     */
4046    public List   getUserPreferences(Criteria criteria) throws TorqueException
4047    {
4048        if (collUserPreferences == null)
4049        {
4050            if (isNew())
4051            {
4052               collUserPreferences = new ArrayList  ();
4053            }
4054            else
4055            {
4056                      criteria.add(UserPreferencePeer.USER_ID, getUserId() );
4057                      collUserPreferences = UserPreferencePeer.doSelect(criteria);
4058            }
4059        }
4060        else
4061        {
4062            // criteria has no effect for a new object
4063            if (!isNew())
4064            {
4065                // the following code is to determine if a new query is
4066                // called for.  If the criteria is the same as the last
4067                // one, just return the collection.
4068                      criteria.add(UserPreferencePeer.USER_ID, getUserId() );
4069                      if (!lastUserPreferencesCriteria.equals(criteria))
4070                {
4071                    collUserPreferences = UserPreferencePeer.doSelect(criteria);
4072                }
4073            }
4074        }
4075        lastUserPreferencesCriteria = criteria;
4076
4077        return collUserPreferences;
4078    }
4079
4080    /**
4081     * If this collection has already been initialized, returns
4082     * the collection. Otherwise returns the results of
4083     * getUserPreferences(new Criteria(),Connection)
4084     * This method takes in the Connection also as input so that
4085     * referenced objects can also be obtained using a Connection
4086     * that is taken as input
4087     */
4088    public List   getUserPreferences(Connection   con) throws TorqueException
4089    {
4090        if (collUserPreferences == null)
4091        {
4092            collUserPreferences = getUserPreferences(new Criteria(10),con);
4093        }
4094        return collUserPreferences;
4095    }
4096
4097    /**
4098     * If this collection has already been initialized with
4099     * an identical criteria, it returns the collection.
4100     * Otherwise if this ScarabUserImpl has previously
4101     * been saved, it will retrieve related UserPreferences from storage.
4102     * If this ScarabUserImpl is new, it will return
4103     * an empty collection or the current collection, the criteria
4104     * is ignored on a new object.
4105     * This method takes in the Connection also as input so that
4106     * referenced objects can also be obtained using a Connection
4107     * that is taken as input
4108     */
4109    public List   getUserPreferences(Criteria criteria,Connection   con) throws TorqueException
4110    {
4111        if (collUserPreferences == null)
4112        {
4113            if (isNew())
4114            {
4115               collUserPreferences = new ArrayList  ();
4116            }
4117            else
4118            {
4119                       criteria.add(UserPreferencePeer.USER_ID, getUserId() );
4120                       collUserPreferences = UserPreferencePeer.doSelect(criteria,con);
4121             }
4122         }
4123         else
4124         {
4125             // criteria has no effect for a new object
4126             if (!isNew())
4127             {
4128                 // the following code is to determine if a new query is
4129                 // called for.  If the criteria is the same as the last
4130                 // one, just return the collection.
4131                     criteria.add(UserPreferencePeer.USER_ID, getUserId() );
4132                     if (!lastUserPreferencesCriteria.equals(criteria))
4133                 {
4134                     collUserPreferences = UserPreferencePeer.doSelect(criteria,con);
4135                 }
4136             }
4137         }
4138         lastUserPreferencesCriteria = criteria;
4139
4140         return collUserPreferences;
4141     }
4142
4143                  
4144              
4145                    
4146                              
4147                                
4148                                                              
4149                                        
4150                    
4151                    
4152          
4153    /**
4154     * If this collection has already been initialized with
4155     * an identical criteria, it returns the collection.
4156     * Otherwise if this ScarabUserImpl is new, it will return
4157     * an empty collection; or if this ScarabUserImpl has previously
4158     * been saved, it will retrieve related UserPreferences from storage.
4159     *
4160     * This method is protected by default in order to keep the public
4161     * api reasonable.  You can provide public methods for those you
4162     * actually need in ScarabUserImpl.
4163     */
4164    protected List   getUserPreferencesJoinScarabUserImpl(Criteria criteria)
4165        throws TorqueException
4166    {
4167        if (collUserPreferences == null)
4168        {
4169            if (isNew())
4170            {
4171               collUserPreferences = new ArrayList  ();
4172            }
4173            else
4174            {
4175                            criteria.add(UserPreferencePeer.USER_ID, getUserId() );
4176                            collUserPreferences = UserPreferencePeer.doSelectJoinScarabUserImpl(criteria);
4177            }
4178        }
4179        else
4180        {
4181            // the following code is to determine if a new query is
4182            // called for.  If the criteria is the same as the last
4183            // one, just return the collection.
4184
4185                            criteria.add(UserPreferencePeer.USER_ID, getUserId() );
4186                        if (!lastUserPreferencesCriteria.equals(criteria))
4187            {
4188                collUserPreferences = UserPreferencePeer.doSelectJoinScarabUserImpl(criteria);
4189            }
4190        }
4191        lastUserPreferencesCriteria = criteria;
4192
4193        return collUserPreferences;
4194    }
4195                            
4196
4197
4198                          
4199            
4200    /**
4201     * Collection to store aggregation of collUserVotes
4202     */
4203    protected List   collUserVotes;
4204
4205    /**
4206     * Temporary storage of collUserVotes to save a possible db hit in
4207     * the event objects are add to the collection, but the
4208     * complete collection is never requested.
4209     */
4210    protected void initUserVotes()
4211    {
4212        if (collUserVotes == null)
4213        {
4214            collUserVotes = new ArrayList  ();
4215        }
4216    }
4217
4218                  
4219    /**
4220     * Method called to associate a UserVote object to this object
4221     * through the UserVote foreign key attribute
4222     *
4223     * @param l UserVote
4224     * @throws TorqueException
4225     */
4226    public void addUserVote(UserVote l) throws TorqueException
4227    {
4228        getUserVotes().add(l);
4229        l.setScarabUser((ScarabUserImpl)this);
4230    }
4231
4232    /**
4233     * The criteria used to select the current contents of collUserVotes
4234     */
4235    private Criteria lastUserVotesCriteria = null;
4236
4237    /**
4238     * If this collection has already been initialized, returns
4239     * the collection. Otherwise returns the results of
4240     * getUserVotes(new Criteria())
4241     *
4242     * @throws TorqueException
4243     */
4244    public List   getUserVotes() throws TorqueException
4245    {
4246        if (collUserVotes == null)
4247        {
4248            collUserVotes = getUserVotes(new Criteria(10));
4249        }
4250        return collUserVotes;
4251    }
4252
4253    /**
4254     * If this collection has already been initialized with
4255     * an identical criteria, it returns the collection.
4256     * Otherwise if this ScarabUserImpl has previously
4257     * been saved, it will retrieve related UserVotes from storage.
4258     * If this ScarabUserImpl is new, it will return
4259     * an empty collection or the current collection, the criteria
4260     * is ignored on a new object.
4261     *
4262     * @throws TorqueException
4263     */
4264    public List   getUserVotes(Criteria criteria) throws TorqueException
4265    {
4266        if (collUserVotes == null)
4267        {
4268            if (isNew())
4269            {
4270               collUserVotes = new ArrayList  ();
4271            }
4272            else
4273            {
4274                      criteria.add(UserVotePeer.USER_ID, getUserId() );
4275                      collUserVotes = UserVotePeer.doSelect(criteria);
4276            }
4277        }
4278        else
4279        {
4280            // criteria has no effect for a new object
4281            if (!isNew())
4282            {
4283                // the following code is to determine if a new query is
4284                // called for.  If the criteria is the same as the last
4285                // one, just return the collection.
4286                      criteria.add(UserVotePeer.USER_ID, getUserId() );
4287                      if (!lastUserVotesCriteria.equals(criteria))
4288                {
4289                    collUserVotes = UserVotePeer.doSelect(criteria);
4290                }
4291            }
4292        }
4293        lastUserVotesCriteria = criteria;
4294
4295        return collUserVotes;
4296    }
4297
4298    /**
4299     * If this collection has already been initialized, returns
4300     * the collection. Otherwise returns the results of
4301     * getUserVotes(new Criteria(),Connection)
4302     * This method takes in the Connection also as input so that
4303     * referenced objects can also be obtained using a Connection
4304     * that is taken as input
4305     */
4306    public List   getUserVotes(Connection   con) throws TorqueException
4307    {
4308        if (collUserVotes == null)
4309        {
4310            collUserVotes = getUserVotes(new Criteria(10),con);
4311        }
4312        return collUserVotes;
4313    }
4314
4315    /**
4316     * If this collection has already been initialized with
4317     * an identical criteria, it returns the collection.
4318     * Otherwise if this ScarabUserImpl has previously
4319     * been saved, it will retrieve related UserVotes from storage.
4320     * If this ScarabUserImpl is new, it will return
4321     * an empty collection or the current collection, the criteria
4322     * is ignored on a new object.
4323     * This method takes in the Connection also as input so that
4324     * referenced objects can also be obtained using a Connection
4325     * that is taken as input
4326     */
4327    public List   getUserVotes(Criteria criteria,Connection   con) throws TorqueException
4328    {
4329        if (collUserVotes == null)
4330        {
4331            if (isNew())
4332            {
4333               collUserVotes = new ArrayList  ();
4334            }
4335            else
4336            {
4337                       criteria.add(UserVotePeer.USER_ID, getUserId() );
4338                       collUserVotes = UserVotePeer.doSelect(criteria,con);
4339             }
4340         }
4341         else
4342         {
4343             // criteria has no effect for a new object
4344             if (!isNew())
4345             {
4346                 // the following code is to determine if a new query is
4347                 // called for.  If the criteria is the same as the last
4348                 // one, just return the collection.
4349                     criteria.add(UserVotePeer.USER_ID, getUserId() );
4350                     if (!lastUserVotesCriteria.equals(criteria))
4351                 {
4352                     collUserVotes = UserVotePeer.doSelect(criteria,con);
4353                 }
4354             }
4355         }
4356         lastUserVotesCriteria = criteria;
4357
4358         return collUserVotes;
4359     }
4360
4361                        
4362              
4363                    
4364                    
4365                                
4366                                                              
4367                                        
4368                    
4369                    
4370          
4371    /**
4372     * If this collection has already been initialized with
4373     * an identical criteria, it returns the collection.
4374     * Otherwise if this ScarabUserImpl is new, it will return
4375     * an empty collection; or if this ScarabUserImpl has previously
4376     * been saved, it will retrieve related UserVotes from storage.
4377     *
4378     * This method is protected by default in order to keep the public
4379     * api reasonable.  You can provide public methods for those you
4380     * actually need in ScarabUserImpl.
4381     */
4382    protected List   getUserVotesJoinScarabModule(Criteria criteria)
4383        throws TorqueException
4384    {
4385        if (collUserVotes == null)
4386        {
4387            if (isNew())
4388            {
4389               collUserVotes = new ArrayList  ();
4390            }
4391            else
4392            {
4393                            criteria.add(UserVotePeer.USER_ID, getUserId() );
4394                            collUserVotes = UserVotePeer.doSelectJoinScarabModule(criteria);
4395            }
4396        }
4397        else
4398        {
4399            // the following code is to determine if a new query is
4400            // called for.  If the criteria is the same as the last
4401            // one, just return the collection.
4402
4403                            criteria.add(UserVotePeer.USER_ID, getUserId() );
4404                        if (!lastUserVotesCriteria.equals(criteria))
4405            {
4406                collUserVotes = UserVotePeer.doSelectJoinScarabModule(criteria);
4407            }
4408        }
4409        lastUserVotesCriteria = criteria;
4410
4411        return collUserVotes;
4412    }
4413                  
4414                    
4415                              
4416                                
4417                                                              
4418                                        
4419                    
4420                    
4421          
4422    /**
4423     * If this collection has already been initialized with
4424     * an identical criteria, it returns the collection.
4425     * Otherwise if this ScarabUserImpl is new, it will return
4426     * an empty collection; or if this ScarabUserImpl has previously
4427     * been saved, it will retrieve related UserVotes from storage.
4428     *
4429     * This method is protected by default in order to keep the public
4430     * api reasonable.  You can provide public methods for those you
4431     * actually need in ScarabUserImpl.
4432     */
4433    protected List   getUserVotesJoinScarabUserImpl(Criteria criteria)
4434        throws TorqueException
4435    {
4436        if (collUserVotes == null)
4437        {
4438            if (isNew())
4439            {
4440               collUserVotes = new ArrayList  ();
4441            }
4442            else
4443            {
4444                            criteria.add(UserVotePeer.USER_ID, getUserId() );
4445                            collUserVotes = UserVotePeer.doSelectJoinScarabUserImpl(criteria);
4446            }
4447        }
4448        else
4449        {
4450            // the following code is to determine if a new query is
4451            // called for.  If the criteria is the same as the last
4452            // one, just return the collection.
4453
4454                            criteria.add(UserVotePeer.USER_ID, getUserId() );
4455                        if (!lastUserVotesCriteria.equals(criteria))
4456            {
4457                collUserVotes = UserVotePeer.doSelectJoinScarabUserImpl(criteria);
4458            }
4459        }
4460        lastUserVotesCriteria = criteria;
4461
4462        return collUserVotes;
4463    }
4464                            
4465
4466
4467                          
4468            
4469    /**
4470     * Collection to store aggregation of collIssueVotes
4471     */
4472    protected List   collIssueVotes;
4473
4474    /**
4475     * Temporary storage of collIssueVotes to save a possible db hit in
4476     * the event objects are add to the collection, but the
4477     * complete collection is never requested.
4478     */
4479    protected void initIssueVotes()
4480    {
4481        if (collIssueVotes == null)
4482        {
4483            collIssueVotes = new ArrayList  ();
4484        }
4485    }
4486
4487                  
4488    /**
4489     * Method called to associate a IssueVote object to this object
4490     * through the IssueVote foreign key attribute
4491     *
4492     * @param l IssueVote
4493     * @throws TorqueException
4494     */
4495    public void addIssueVote(IssueVote l) throws TorqueException
4496    {
4497        getIssueVotes().add(l);
4498        l.setScarabUser((ScarabUserImpl)this);
4499    }
4500
4501    /**
4502     * The criteria used to select the current contents of collIssueVotes
4503     */
4504    private Criteria lastIssueVotesCriteria = null;
4505
4506    /**
4507     * If this collection has already been initialized, returns
4508     * the collection. Otherwise returns the results of
4509     * getIssueVotes(new Criteria())
4510     *
4511     * @throws TorqueException
4512     */
4513    public List   getIssueVotes() throws TorqueException
4514    {
4515        if (collIssueVotes == null)
4516        {
4517            collIssueVotes = getIssueVotes(new Criteria(10));
4518        }
4519        return collIssueVotes;
4520    }
4521
4522    /**
4523     * If this collection has already been initialized with
4524     * an identical criteria, it returns the collection.
4525     * Otherwise if this ScarabUserImpl has previously
4526     * been saved, it will retrieve related IssueVotes from storage.
4527     * If this ScarabUserImpl is new, it will return
4528     * an empty collection or the current collection, the criteria
4529     * is ignored on a new object.
4530     *
4531     * @throws TorqueException
4532     */
4533    public List   getIssueVotes(Criteria criteria) throws TorqueException
4534    {
4535        if (collIssueVotes == null)
4536        {
4537            if (isNew())
4538            {
4539               collIssueVotes = new ArrayList  ();
4540            }
4541            else
4542            {
4543                      criteria.add(IssueVotePeer.USER_ID, getUserId() );
4544                      collIssueVotes = IssueVotePeer.doSelect(criteria);
4545            }
4546        }
4547        else
4548        {
4549            // criteria has no effect for a new object
4550            if (!isNew())
4551            {
4552                // the following code is to determine if a new query is
4553                // called for.  If the criteria is the same as the last
4554                // one, just return the collection.
4555                      criteria.add(IssueVotePeer.USER_ID, getUserId() );
4556                      if (!lastIssueVotesCriteria.equals(criteria))
4557                {
4558                    collIssueVotes = IssueVotePeer.doSelect(criteria);
4559                }
4560            }
4561        }
4562        lastIssueVotesCriteria = criteria;
4563
4564        return collIssueVotes;
4565    }
4566
4567    /**
4568     * If this collection has already been initialized, returns
4569     * the collection. Otherwise returns the results of
4570     * getIssueVotes(new Criteria(),Connection)
4571     * This method takes in the Connection also as input so that
4572     * referenced objects can also be obtained using a Connection
4573     * that is taken as input
4574     */
4575    public List   getIssueVotes(Connection   con) throws TorqueException
4576    {
4577        if (collIssueVotes == null)
4578        {
4579            collIssueVotes = getIssueVotes(new Criteria(10),con);
4580        }
4581        return collIssueVotes;
4582    }
4583
4584    /**
4585     * If this collection has already been initialized with
4586     * an identical criteria, it returns the collection.
4587     * Otherwise if this ScarabUserImpl has previously
4588     * been saved, it will retrieve related IssueVotes from storage.
4589     * If this ScarabUserImpl is new, it will return
4590     * an empty collection or the current collection, the criteria
4591     * is ignored on a new object.
4592     * This method takes in the Connection also as input so that
4593     * referenced objects can also be obtained using a Connection
4594     * that is taken as input
4595     */
4596    public List   getIssueVotes(Criteria criteria,Connection   con) throws TorqueException
4597    {
4598        if (collIssueVotes == null)
4599        {
4600            if (isNew())
4601            {
4602               collIssueVotes = new ArrayList  ();
4603            }
4604            else
4605            {
4606                       criteria.add(IssueVotePeer.USER_ID, getUserId() );
4607                       collIssueVotes = IssueVotePeer.doSelect(criteria,con);
4608             }
4609         }
4610         else
4611         {
4612             // criteria has no effect for a new object
4613             if (!isNew())
4614             {
4615                 // the following code is to determine if a new query is
4616                 // called for.  If the criteria is the same as the last
4617                 // one, just return the collection.
4618                     criteria.add(IssueVotePeer.USER_ID, getUserId() );
4619                     if (!lastIssueVotesCriteria.equals(criteria))
4620                 {
4621                     collIssueVotes = IssueVotePeer.doSelect(criteria,con);
4622                 }
4623             }
4624         }
4625         lastIssueVotesCriteria = criteria;
4626
4627         return collIssueVotes;
4628     }
4629
4630                        
4631              
4632                    
4633                    
4634                                
4635                                                              
4636                                        
4637                    
4638                    
4639          
4640    /**
4641     * If this collection has already been initialized with
4642     * an identical criteria, it returns the collection.
4643     * Otherwise if this ScarabUserImpl is new, it will return
4644     * an empty collection; or if this ScarabUserImpl has previously
4645     * been saved, it will retrieve related IssueVotes from storage.
4646     *
4647     * This method is protected by default in order to keep the public
4648     * api reasonable.  You can provide public methods for those you
4649     * actually need in ScarabUserImpl.
4650     */
4651    protected List   getIssueVotesJoinIssue(Criteria criteria)
4652        throws TorqueException
4653    {
4654        if (collIssueVotes == null)
4655        {
4656            if (isNew())
4657            {
4658               collIssueVotes = new ArrayList  ();
4659            }
4660            else
4661            {
4662                            criteria.add(IssueVotePeer.USER_ID, getUserId() );
4663                            collIssueVotes = IssueVotePeer.doSelectJoinIssue(criteria);
4664            }
4665        }
4666        else
4667        {
4668            // the following code is to determine if a new query is
4669            // called for.  If the criteria is the same as the last
4670            // one, just return the collection.
4671
4672                            criteria.add(IssueVotePeer.USER_ID, getUserId() );
4673                        if (!lastIssueVotesCriteria.equals(criteria))
4674            {
4675                collIssueVotes = IssueVotePeer.doSelectJoinIssue(criteria);
4676            }
4677        }
4678        lastIssueVotesCriteria = criteria;
4679
4680        return collIssueVotes;
4681    }
4682                  
4683                    
4684                              
4685                                
4686                                                              
4687                                        
4688                    
4689                    
4690          
4691    /**
4692     * If this collection has already been initialized with
4693     * an identical criteria, it returns the collection.
4694     * Otherwise if this ScarabUserImpl is new, it will return
4695     * an empty collection; or if this ScarabUserImpl has previously
4696     * been saved, it will retrieve related IssueVotes from storage.
4697     *
4698     * This method is protected by default in order to keep the public
4699     * api reasonable.  You can provide public methods for those you
4700     * actually need in ScarabUserImpl.
4701     */
4702    protected List   getIssueVotesJoinScarabUserImpl(Criteria criteria)
4703        throws TorqueException
4704    {
4705        if (collIssueVotes == null)
4706        {
4707            if (isNew())
4708            {
4709               collIssueVotes = new ArrayList  ();
4710            }
4711            else
4712            {
4713                            criteria.add(IssueVotePeer.USER_ID, getUserId() );
4714                            collIssueVotes = IssueVotePeer.doSelectJoinScarabUserImpl(criteria);
4715            }
4716        }
4717        else
4718        {
4719            // the following code is to determine if a new query is
4720            // called for.  If the criteria is the same as the last
4721            // one, just return the collection.
4722
4723                            criteria.add(IssueVotePeer.USER_ID, getUserId() );
4724                        if (!lastIssueVotesCriteria.equals(criteria))
4725            {
4726                collIssueVotes = IssueVotePeer.doSelectJoinScarabUserImpl(criteria);
4727            }
4728        }
4729        lastIssueVotesCriteria = criteria;
4730
4731        return collIssueVotes;
4732    }
4733                            
4734
4735
4736                          
4737            
4738    /**
4739     * Collection to store aggregation of collQuerys
4740     */
4741    protected List   collQuerys;
4742
4743    /**
4744     * Temporary storage of collQuerys to save a possible db hit in
4745     * the event objects are add to the collection, but the
4746     * complete collection is never requested.
4747     */
4748    protected void initQuerys()
4749    {
4750        if (collQuerys == null)
4751        {
4752            collQuerys = new ArrayList  ();
4753        }
4754    }
4755
4756                  
4757    /**
4758     * Method called to associate a Query object to this object
4759     * through the Query foreign key attribute
4760     *
4761     * @param l Query
4762     * @throws TorqueException
4763     */
4764    public void addQuery(Query l) throws TorqueException
4765    {
4766        getQuerys().add(l);
4767        l.setScarabUser((ScarabUserImpl)this);
4768    }
4769
4770    /**
4771     * The criteria used to select the current contents of collQuerys
4772     */
4773    private Criteria lastQuerysCriteria = null;
4774
4775    /**
4776     * If this collection has already been initialized, returns
4777     * the collection. Otherwise returns the results of
4778     * getQuerys(new Criteria())
4779     *
4780     * @throws TorqueException
4781     */
4782    public List   getQuerys() throws TorqueException
4783    {
4784        if (collQuerys == null)
4785        {
4786            collQuerys = getQuerys(new Criteria(10));
4787        }
4788        return collQuerys;
4789    }
4790
4791    /**
4792     * If this collection has already been initialized with
4793     * an identical criteria, it returns the collection.
4794     * Otherwise if this ScarabUserImpl has previously
4795     * been saved, it will retrieve related Querys from storage.
4796     * If this ScarabUserImpl is new, it will return
4797     * an empty collection or the current collection, the criteria
4798     * is ignored on a new object.
4799     *
4800     * @throws TorqueException
4801     */
4802    public List   getQuerys(Criteria criteria) throws TorqueException
4803    {
4804        if (collQuerys == null)
4805        {
4806            if (isNew())
4807            {
4808               collQuerys = new ArrayList  ();
4809            }
4810            else
4811            {
4812                      criteria.add(QueryPeer.USER_ID, getUserId() );
4813                      collQuerys = QueryPeer.doSelect(criteria);
4814            }
4815        }
4816        else
4817        {
4818            // criteria has no effect for a new object
4819            if (!isNew())
4820            {
4821                // the following code is to determine if a new query is
4822                // called for.  If the criteria is the same as the last
4823                // one, just return the collection.
4824                      criteria.add(QueryPeer.USER_ID, getUserId() );
4825                      if (!lastQuerysCriteria.equals(criteria))
4826                {
4827                    collQuerys = QueryPeer.doSelect(criteria);
4828                }
4829            }
4830        }
4831        lastQuerysCriteria = criteria;
4832
4833        return collQuerys;
4834    }
4835
4836    /**
4837     * If this collection has already been initialized, returns
4838     * the collection. Otherwise returns the results of
4839     * getQuerys(new Criteria(),Connection)
4840     * This method takes in the Connection also as input so that
4841     * referenced objects can also be obtained using a Connection
4842     * that is taken as input
4843     */
4844    public List   getQuerys(Connection   con) throws TorqueException
4845    {
4846        if (collQuerys == null)
4847        {
4848            collQuerys = getQuerys(new Criteria(10),con);
4849        }
4850        return collQuerys;
4851    }
4852
4853    /**
4854     * If this collection has already been initialized with
4855     * an identical criteria, it returns the collection.
4856     * Otherwise if this ScarabUserImpl has previously
4857     * been saved, it will retrieve related Querys from storage.
4858     * If this ScarabUserImpl is new, it will return
4859     * an empty collection or the current collection, the criteria
4860     * is ignored on a new object.
4861     * This method takes in the Connection also as input so that
4862     * referenced objects can also be obtained using a Connection
4863     * that is taken as input
4864     */
4865    public List   getQuerys(Criteria criteria,Connection   con) throws TorqueException
4866    {
4867        if (collQuerys == null)
4868        {
4869            if (isNew())
4870            {
4871               collQuerys = new ArrayList  ();
4872            }
4873            else
4874            {
4875                       criteria.add(QueryPeer.USER_ID, getUserId() );
4876                       collQuerys = QueryPeer.doSelect(criteria,con);
4877             }
4878         }
4879         else
4880         {
4881             // criteria has no effect for a new object
4882             if (!isNew())
4883             {
4884                 // the following code is to determine if a new query is
4885                 // called for.  If the criteria is the same as the last
4886                 // one, just return the collection.
4887                     criteria.add(QueryPeer.USER_ID, getUserId() );
4888                     if (!lastQuerysCriteria.equals(criteria))
4889                 {
4890                     collQuerys = QueryPeer.doSelect(criteria,con);
4891                 }
4892             }
4893         }
4894         lastQuerysCriteria = criteria;
4895
4896         return collQuerys;
4897     }
4898
4899                                                
4900              
4901                    
4902                              
4903                                
4904                                                              
4905                                        
4906                    
4907                    
4908          
4909    /**
4910     * If this collection has already been initialized with
4911     * an identical criteria, it returns the collection.
4912     * Otherwise if this ScarabUserImpl is new, it will return
4913     * an empty collection; or if this ScarabUserImpl has previously
4914     * been saved, it will retrieve related Querys from storage.
4915     *
4916     * This method is protected by default in order to keep the public
4917     * api reasonable.  You can provide public methods for those you
4918     * actually need in ScarabUserImpl.
4919     */
4920    protected List   getQuerysJoinScarabUserImpl(Criteria criteria)
4921        throws TorqueException
4922    {
4923        if (collQuerys == null)
4924        {
4925            if (isNew())
4926            {
4927               collQuerys = new ArrayList  ();
4928            }
4929            else
4930            {
4931                            criteria.add(QueryPeer.USER_ID, getUserId() );
4932                            collQuerys = QueryPeer.doSelectJoinScarabUserImpl(criteria);
4933            }
4934        }
4935        else
4936        {
4937            // the following code is to determine if a new query is
4938            // called for.  If the criteria is the same as the last
4939            // one, just return the collection.
4940
4941                            criteria.add(QueryPeer.USER_ID, getUserId() );
4942                        if (!lastQuerysCriteria.equals(criteria))
4943            {
4944                collQuerys = QueryPeer.doSelectJoinScarabUserImpl(criteria);
4945            }
4946        }
4947        lastQuerysCriteria = criteria;
4948
4949        return collQuerys;
4950    }
4951                  
4952                    
4953                    
4954                                
4955                                                              
4956                                        
4957                    
4958                    
4959          
4960    /**
4961     * If this collection has already been initialized with
4962     * an identical criteria, it returns the collection.
4963     * Otherwise if this ScarabUserImpl is new, it will return
4964     * an empty collection; or if this ScarabUserImpl has previously
4965     * been saved, it will retrieve related Querys from storage.
4966     *
4967     * This method is protected by default in order to keep the public
4968     * api reasonable.  You can provide public methods for those you
4969     * actually need in ScarabUserImpl.
4970     */
4971    protected List   getQuerysJoinScope(Criteria criteria)
4972        throws TorqueException
4973    {
4974        if (collQuerys == null)
4975        {
4976            if (isNew())
4977            {
4978               collQuerys = new ArrayList  ();
4979            }
4980            else
4981            {
4982                            criteria.add(QueryPeer.USER_ID, getUserId() );
4983                            collQuerys = QueryPeer.doSelectJoinScope(criteria);
4984            }
4985        }
4986        else
4987        {
4988            // the following code is to determine if a new query is
4989            // called for.  If the criteria is the same as the last
4990            // one, just return the collection.
4991
4992                            criteria.add(QueryPeer.USER_ID, getUserId() );
4993                        if (!lastQuerysCriteria.equals(criteria))
4994            {
4995                collQuerys = QueryPeer.doSelectJoinScope(criteria);
4996            }
4997        }
4998        lastQuerysCriteria = criteria;
4999
5000        return collQuerys;
5001    }
5002                  
5003                    
5004                    
5005                                
5006                                                              
5007                                        
5008                    
5009                    
5010          
5011    /**
5012     * If this collection has already been initialized with
5013     * an identical criteria, it returns the collection.
5014     * Otherwise if this ScarabUserImpl is new, it will return
5015     * an empty collection; or if this ScarabUserImpl has previously
5016     * been saved, it will retrieve related Querys from storage.
5017     *
5018     * This method is protected by default in order to keep the public
5019     * api reasonable.  You can provide public methods for those you
5020     * actually need in ScarabUserImpl.
5021     */
5022    protected List   getQuerysJoinScarabModule(Criteria criteria)
5023        throws TorqueException
5024    {
5025        if (collQuerys == null)
5026        {
5027            if (isNew())
5028            {
5029               collQuerys = new ArrayList  ();
5030            }
5031            else
5032            {
5033                            criteria.add(QueryPeer.USER_ID, getUserId() );
5034                            collQuerys = QueryPeer.doSelectJoinScarabModule(criteria);
5035            }
5036        }
5037        else
5038        {
5039            // the following code is to determine if a new query is
5040            // called for.  If the criteria is the same as the last
5041            // one, just return the collection.
5042
5043                            criteria.add(QueryPeer.USER_ID, getUserId() );
5044                        if (!lastQuerysCriteria.equals(criteria))
5045            {
5046                collQuerys = QueryPeer.doSelectJoinScarabModule(criteria);
5047            }
5048        }
5049        lastQuerysCriteria = criteria;
5050
5051        return collQuerys;
5052    }
5053                  
5054                    
5055                    
5056                                
5057                                                              
5058                                        
5059                    
5060                    
5061          
5062    /**
5063     * If this collection has already been initialized with
5064     * an identical criteria, it returns the collection.
5065     * Otherwise if this ScarabUserImpl is new, it will return
5066     * an empty collection; or if this ScarabUserImpl has previously
5067     * been saved, it will retrieve related Querys from storage.
5068     *
5069     * This method is protected by default in order to keep the public
5070     * api reasonable.  You can provide public methods for those you
5071     * actually need in ScarabUserImpl.
5072     */
5073    protected List   getQuerysJoinIssueType(Criteria criteria)
5074        throws TorqueException
5075    {
5076        if (collQuerys == null)
5077        {
5078            if (isNew())
5079            {
5080               collQuerys = new ArrayList  ();
5081            }
5082            else
5083            {
5084                            criteria.add(QueryPeer.USER_ID, getUserId() );
5085                            collQuerys = QueryPeer.doSelectJoinIssueType(criteria);
5086            }
5087        }
5088        else
5089        {
5090            // the following code is to determine if a new query is
5091            // called for.  If the criteria is the same as the last
5092            // one, just return the collection.
5093
5094                            criteria.add(QueryPeer.USER_ID, getUserId() );
5095                        if (!lastQuerysCriteria.equals(criteria))
5096            {
5097                collQuerys = QueryPeer.doSelectJoinIssueType(criteria);
5098            }
5099        }
5100        lastQuerysCriteria = criteria;
5101
5102        return collQuerys;
5103    }
5104                  
5105                    
5106                    
5107                                
5108                                                              
5109                                        
5110                    
5111                    
5112          
5113    /**
5114     * If this collection has already been initialized with
5115     * an identical criteria, it returns the collection.
5116     * Otherwise if this ScarabUserImpl is new, it will return
5117     * an empty collection; or if this ScarabUserImpl has previously
5118     * been saved, it will retrieve related Querys from storage.
5119     *
5120     * This method is protected by default in order to keep the public
5121     * api reasonable.  You can provide public methods for those you
5122     * actually need in ScarabUserImpl.
5123     */
5124    protected List   getQuerysJoinMITList(Criteria criteria)
5125        throws TorqueException
5126    {
5127        if (collQuerys == null)
5128        {
5129            if (isNew())
5130            {
5131               collQuerys = new ArrayList  ();
5132            }
5133            else
5134            {
5135                            criteria.add(QueryPeer.USER_ID, getUserId() );
5136                            collQuerys = QueryPeer.doSelectJoinMITList(criteria);
5137            }
5138        }
5139        else
5140        {
5141            // the following code is to determine if a new query is
5142            // called for.  If the criteria is the same as the last
5143            // one, just return the collection.
5144
5145                            criteria.add(QueryPeer.USER_ID, getUserId() );
5146                        if (!lastQuerysCriteria.equals(criteria))
5147            {
5148                collQuerys = QueryPeer.doSelectJoinMITList(criteria);
5149            }
5150        }
5151        lastQuerysCriteria = criteria;
5152
5153        return collQuerys;
5154    }
5155                  
5156                    
5157                    
5158                                
5159                                                              
5160                                        
5161                    
5162                    
5163          
5164    /**
5165     * If this collection has already been initialized with
5166     * an identical criteria, it returns the collection.
5167     * Otherwise if this ScarabUserImpl is new, it will return
5168     * an empty collection; or if this ScarabUserImpl has previously
5169     * been saved, it will retrieve related Querys from storage.
5170     *
5171     * This method is protected by default in order to keep the public
5172     * api reasonable.  You can provide public methods for those you
5173     * actually need in ScarabUserImpl.
5174     */
5175    protected List   getQuerysJoinFrequency(Criteria criteria)
5176        throws TorqueException
5177    {
5178        if (collQuerys == null)
5179        {
5180            if (isNew())
5181            {
5182               collQuerys = new ArrayList  ();
5183            }
5184            else
5185            {
5186                            criteria.add(QueryPeer.USER_ID, getUserId() );
5187                            collQuerys = QueryPeer.doSelectJoinFrequency(criteria);
5188            }
5189        }
5190        else
5191        {
5192            // the following code is to determine if a new query is
5193            // called for.  If the criteria is the same as the last
5194            // one, just return the collection.
5195
5196                            criteria.add(QueryPeer.USER_ID, getUserId() );
5197                        if (!lastQuerysCriteria.equals(criteria))
5198            {
5199                collQuerys = QueryPeer.doSelectJoinFrequency(criteria);
5200            }
5201        }
5202        lastQuerysCriteria = criteria;
5203
5204        return collQuerys;
5205    }
5206                            
5207
5208
5209                          
5210            
5211    /**
5212     * Collection to store aggregation of collRQueryUsers
5213     */
5214    protected List   collRQueryUsers;
5215
5216    /**
5217     * Temporary storage of collRQueryUsers to save a possible db hit in
5218     * the event objects are add to the collection, but the
5219     * complete collection is never requested.
5220     */
5221    protected void initRQueryUsers()
5222    {
5223        if (collRQueryUsers == null)
5224        {
5225            collRQueryUsers = new ArrayList  ();
5226        }
5227    }
5228
5229                  
5230    /**
5231     * Method called to associate a RQueryUser object to this object
5232     * through the RQueryUser foreign key attribute
5233     *
5234     * @param l RQueryUser
5235     * @throws TorqueException
5236     */
5237    public void addRQueryUser(RQueryUser l) throws TorqueException
5238    {
5239        getRQueryUsers().add(l);
5240        l.setScarabUser((ScarabUserImpl)this);
5241    }
5242
5243    /**
5244     * The criteria used to select the current contents of collRQueryUsers
5245     */
5246    private Criteria lastRQueryUsersCriteria = null;
5247
5248    /**
5249     * If this collection has already been initialized, returns
5250     * the collection. Otherwise returns the results of
5251     * getRQueryUsers(new Criteria())
5252     *
5253     * @throws TorqueException
5254     */
5255    public List   getRQueryUsers() throws TorqueException
5256    {
5257        if (collRQueryUsers == null)
5258        {
5259            collRQueryUsers = getRQueryUsers(new Criteria(10));
5260        }
5261        return collRQueryUsers;
5262    }
5263
5264    /**
5265     * If this collection has already been initialized with
5266     * an identical criteria, it returns the collection.
5267     * Otherwise if this ScarabUserImpl has previously
5268     * been saved, it will retrieve related RQueryUsers from storage.
5269     * If this ScarabUserImpl is new, it will return
5270     * an empty collection or the current collection, the criteria
5271     * is ignored on a new object.
5272     *
5273     * @throws TorqueException
5274     */
5275    public List   getRQueryUsers(Criteria criteria) throws TorqueException
5276    {
5277        if (collRQueryUsers == null)
5278        {
5279            if (isNew())
5280            {
5281               collRQueryUsers = new ArrayList  ();
5282            }
5283            else
5284            {
5285                      criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5286                      collRQueryUsers = RQueryUserPeer.doSelect(criteria);
5287            }
5288        }
5289        else
5290        {
5291            // criteria has no effect for a new object
5292            if (!isNew())
5293            {
5294                // the following code is to determine if a new query is
5295                // called for.  If the criteria is the same as the last
5296                // one, just return the collection.
5297                      criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5298                      if (!lastRQueryUsersCriteria.equals(criteria))
5299                {
5300                    collRQueryUsers = RQueryUserPeer.doSelect(criteria);
5301                }
5302            }
5303        }
5304        lastRQueryUsersCriteria = criteria;
5305
5306        return collRQueryUsers;
5307    }
5308
5309    /**
5310     * If this collection has already been initialized, returns
5311     * the collection. Otherwise returns the results of
5312     * getRQueryUsers(new Criteria(),Connection)
5313     * This method takes in the Connection also as input so that
5314     * referenced objects can also be obtained using a Connection
5315     * that is taken as input
5316     */
5317    public List   getRQueryUsers(Connection   con) throws TorqueException
5318    {
5319        if (collRQueryUsers == null)
5320        {
5321            collRQueryUsers = getRQueryUsers(new Criteria(10),con);
5322        }
5323        return collRQueryUsers;
5324    }
5325
5326    /**
5327     * If this collection has already been initialized with
5328     * an identical criteria, it returns the collection.
5329     * Otherwise if this ScarabUserImpl has previously
5330     * been saved, it will retrieve related RQueryUsers from storage.
5331     * If this ScarabUserImpl is new, it will return
5332     * an empty collection or the current collection, the criteria
5333     * is ignored on a new object.
5334     * This method takes in the Connection also as input so that
5335     * referenced objects can also be obtained using a Connection
5336     * that is taken as input
5337     */
5338    public List   getRQueryUsers(Criteria criteria,Connection   con) throws TorqueException
5339    {
5340        if (collRQueryUsers == null)
5341        {
5342            if (isNew())
5343            {
5344               collRQueryUsers = new ArrayList  ();
5345            }
5346            else
5347            {
5348                       criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5349                       collRQueryUsers = RQueryUserPeer.doSelect(criteria,con);
5350             }
5351         }
5352         else
5353         {
5354             // criteria has no effect for a new object
5355             if (!isNew())
5356             {
5357                 // the following code is to determine if a new query is
5358                 // called for.  If the criteria is the same as the last
5359                 // one, just return the collection.
5360                     criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5361                     if (!lastRQueryUsersCriteria.equals(criteria))
5362                 {
5363                     collRQueryUsers = RQueryUserPeer.doSelect(criteria,con);
5364                 }
5365             }
5366         }
5367         lastRQueryUsersCriteria = criteria;
5368
5369         return collRQueryUsers;
5370     }
5371
5372                              
5373              
5374                    
5375                    
5376                                
5377                                                              
5378                                        
5379                    
5380                    
5381          
5382    /**
5383     * If this collection has already been initialized with
5384     * an identical criteria, it returns the collection.
5385     * Otherwise if this ScarabUserImpl is new, it will return
5386     * an empty collection; or if this ScarabUserImpl has previously
5387     * been saved, it will retrieve related RQueryUsers from storage.
5388     *
5389     * This method is protected by default in order to keep the public
5390     * api reasonable.  You can provide public methods for those you
5391     * actually need in ScarabUserImpl.
5392     */
5393    protected List   getRQueryUsersJoinQuery(Criteria criteria)
5394        throws TorqueException
5395    {
5396        if (collRQueryUsers == null)
5397        {
5398            if (isNew())
5399            {
5400               collRQueryUsers = new ArrayList  ();
5401            }
5402            else
5403            {
5404                            criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5405                            collRQueryUsers = RQueryUserPeer.doSelectJoinQuery(criteria);
5406            }
5407        }
5408        else
5409        {
5410            // the following code is to determine if a new query is
5411            // called for.  If the criteria is the same as the last
5412            // one, just return the collection.
5413
5414                            criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5415                        if (!lastRQueryUsersCriteria.equals(criteria))
5416            {
5417                collRQueryUsers = RQueryUserPeer.doSelectJoinQuery(criteria);
5418            }
5419        }
5420        lastRQueryUsersCriteria = criteria;
5421
5422        return collRQueryUsers;
5423    }
5424                  
5425                    
5426                              
5427                                
5428                                                              
5429                                        
5430                    
5431                    
5432          
5433    /**
5434     * If this collection has already been initialized with
5435     * an identical criteria, it returns the collection.
5436     * Otherwise if this ScarabUserImpl is new, it will return
5437     * an empty collection; or if this ScarabUserImpl has previously
5438     * been saved, it will retrieve related RQueryUsers from storage.
5439     *
5440     * This method is protected by default in order to keep the public
5441     * api reasonable.  You can provide public methods for those you
5442     * actually need in ScarabUserImpl.
5443     */
5444    protected List   getRQueryUsersJoinScarabUserImpl(Criteria criteria)
5445        throws TorqueException
5446    {
5447        if (collRQueryUsers == null)
5448        {
5449            if (isNew())
5450            {
5451               collRQueryUsers = new ArrayList  ();
5452            }
5453            else
5454            {
5455                            criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5456                            collRQueryUsers = RQueryUserPeer.doSelectJoinScarabUserImpl(criteria);
5457            }
5458        }
5459        else
5460        {
5461            // the following code is to determine if a new query is
5462            // called for.  If the criteria is the same as the last
5463            // one, just return the collection.
5464
5465                            criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5466                        if (!lastRQueryUsersCriteria.equals(criteria))
5467            {
5468                collRQueryUsers = RQueryUserPeer.doSelectJoinScarabUserImpl(criteria);
5469            }
5470        }
5471        lastRQueryUsersCriteria = criteria;
5472
5473        return collRQueryUsers;
5474    }
5475                  
5476                    
5477                    
5478                                
5479                                                              
5480                                        
5481                    
5482                    
5483          
5484    /**
5485     * If this collection has already been initialized with
5486     * an identical criteria, it returns the collection.
5487     * Otherwise if this ScarabUserImpl is new, it will return
5488     * an empty collection; or if this ScarabUserImpl has previously
5489     * been saved, it will retrieve related RQueryUsers from storage.
5490     *
5491     * This method is protected by default in order to keep the public
5492     * api reasonable.  You can provide public methods for those you
5493     * actually need in ScarabUserImpl.
5494     */
5495    protected List   getRQueryUsersJoinFrequency(Criteria criteria)
5496        throws TorqueException
5497    {
5498        if (collRQueryUsers == null)
5499        {
5500            if (isNew())
5501            {
5502               collRQueryUsers = new ArrayList  ();
5503            }
5504            else
5505            {
5506                            criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5507                            collRQueryUsers = RQueryUserPeer.doSelectJoinFrequency(criteria);
5508            }
5509        }
5510        else
5511        {
5512            // the following code is to determine if a new query is
5513            // called for.  If the criteria is the same as the last
5514            // one, just return the collection.
5515
5516                            criteria.add(RQueryUserPeer.USER_ID, getUserId() );
5517                        if (!lastRQueryUsersCriteria.equals(criteria))
5518            {
5519                collRQueryUsers = RQueryUserPeer.doSelectJoinFrequency(criteria);
5520            }
5521        }
5522        lastRQueryUsersCriteria = criteria;
5523
5524        return collRQueryUsers;
5525    }
5526                            
5527
5528
5529                          
5530            
5531    /**
5532     * Collection to store aggregation of collReports
5533     */
5534    protected List   collReports;
5535
5536    /**
5537     * Temporary storage of collReports to save a possible db hit in
5538     * the event objects are add to the collection, but the
5539     * complete collection is never requested.
5540     */
5541    protected void initReports()
5542    {
5543        if (collReports == null)
5544        {
5545            collReports = new ArrayList  ();
5546        }
5547    }
5548
5549                  
5550    /**
5551     * Method called to associate a Report object to this object
5552     * through the Report foreign key attribute
5553     *
5554     * @param l Report
5555     * @throws TorqueException
5556     */
5557    public void addReport(Report l) throws TorqueException
5558    {
5559        getReports().add(l);
5560        l.setScarabUser((ScarabUserImpl)this);
5561    }
5562
5563    /**
5564     * The criteria used to select the current contents of collReports
5565     */
5566    private Criteria lastReportsCriteria = null;
5567
5568    /**
5569     * If this collection has already been initialized, returns
5570     * the collection. Otherwise returns the results of
5571     * getReports(new Criteria())
5572     *
5573     * @throws TorqueException
5574     */
5575    public List   getReports() throws TorqueException
5576    {
5577        if (collReports == null)
5578        {
5579            collReports = getReports(new Criteria(10));
5580        }
5581        return collReports;
5582    }
5583
5584    /**
5585     * If this collection has already been initialized with
5586     * an identical criteria, it returns the collection.
5587     * Otherwise if this ScarabUserImpl has previously
5588     * been saved, it will retrieve related Reports from storage.
5589     * If this ScarabUserImpl is new, it will return
5590     * an empty collection or the current collection, the criteria
5591     * is ignored on a new object.
5592     *
5593     * @throws TorqueException
5594     */
5595    public List   getReports(Criteria criteria) throws TorqueException
5596    {
5597        if (collReports == null)
5598        {
5599            if (isNew())
5600            {
5601               collReports = new ArrayList  ();
5602            }
5603            else
5604            {
5605                      criteria.add(ReportPeer.USER_ID, getUserId() );
5606                      collReports = ReportPeer.doSelect(criteria);
5607            }
5608        }
5609        else
5610        {
5611            // criteria has no effect for a new object
5612            if (!isNew())
5613            {
5614                // the following code is to determine if a new query is
5615                // called for.  If the criteria is the same as the last
5616                // one, just return the collection.
5617                      criteria.add(ReportPeer.USER_ID, getUserId() );
5618                      if (!lastReportsCriteria.equals(criteria))
5619                {
5620                    collReports = ReportPeer.doSelect(criteria);
5621                }
5622            }
5623        }
5624        lastReportsCriteria = criteria;
5625
5626        return collReports;
5627    }
5628
5629    /**
5630     * If this collection has already been initialized, returns
5631     * the collection. Otherwise returns the results of
5632     * getReports(new Criteria(),Connection)
5633     * This method takes in the Connection also as input so that
5634     * referenced objects can also be obtained using a Connection
5635     * that is taken as input
5636     */
5637    public List   getReports(Connection   con) throws TorqueException
5638    {
5639        if (collReports == null)
5640        {
5641            collReports = getReports(new Criteria(10),con);
5642        }
5643        return collReports;
5644    }
5645
5646    /**
5647     * If this collection has already been initialized with
5648     * an identical criteria, it returns the collection.
5649     * Otherwise if this ScarabUserImpl has previously
5650     * been saved, it will retrieve related Reports from storage.
5651     * If this ScarabUserImpl is new, it will return
5652     * an empty collection or the current collection, the criteria
5653     * is ignored on a new object.
5654     * This method takes in the Connection also as input so that
5655     * referenced objects can also be obtained using a Connection
5656     * that is taken as input
5657     */
5658    public List   getReports(Criteria criteria,Connection   con) throws TorqueException
5659    {
5660        if (collReports == null)
5661        {
5662            if (isNew())
5663            {
5664               collReports = new ArrayList  ();
5665            }
5666            else
5667            {
5668                       criteria.add(ReportPeer.USER_ID, getUserId() );
5669                       collReports = ReportPeer.doSelect(criteria,con);
5670             }
5671         }
5672         else
5673         {
5674             // criteria has no effect for a new object
5675             if (!isNew())
5676             {
5677                 // the following code is to determine if a new query is
5678                 // called for.  If the criteria is the same as the last
5679                 // one, just return the collection.
5680                     criteria.add(ReportPeer.USER_ID, getUserId() );
5681                     if (!lastReportsCriteria.equals(criteria))
5682                 {
5683                     collReports = ReportPeer.doSelect(criteria,con);
5684                 }
5685             }
5686         }
5687         lastReportsCriteria = criteria;
5688
5689         return collReports;
5690     }
5691
5692                                    
5693              
5694                    
5695                    
5696                                
5697                                                              
5698                                        
5699                    
5700                    
5701          
5702    /**
5703     * If this collection has already been initialized with
5704     * an identical criteria, it returns the collection.
5705     * Otherwise if this ScarabUserImpl is new, it will return
5706     * an empty collection; or if this ScarabUserImpl has previously
5707     * been saved, it will retrieve related Reports from storage.
5708     *
5709     * This method is protected by default in order to keep the public
5710     * api reasonable.  You can provide public methods for those you
5711     * actually need in ScarabUserImpl.
5712     */
5713    protected List   getReportsJoinIssueType(Criteria criteria)
5714        throws TorqueException
5715    {
5716        if (collReports == null)
5717        {
5718            if (isNew())
5719            {
5720               collReports = new ArrayList  ();
5721            }
5722            else
5723            {
5724                            criteria.add(ReportPeer.USER_ID, getUserId() );
5725                            collReports = ReportPeer.doSelectJoinIssueType(criteria);
5726            }
5727        }
5728        else
5729        {
5730            // the following code is to determine if a new query is
5731            // called for.  If the criteria is the same as the last
5732            // one, just return the collection.
5733
5734                            criteria.add(ReportPeer.USER_ID, getUserId() );
5735                        if (!lastReportsCriteria.equals(criteria))
5736            {
5737                collReports = ReportPeer.doSelectJoinIssueType(criteria);
5738            }
5739        }
5740        lastReportsCriteria = criteria;
5741
5742        return collReports;
5743    }
5744                  
5745                    
5746                              
5747                                
5748                                                              
5749                                        
5750                    
5751                    
5752          
5753    /**
5754     * If this collection has already been initialized with
5755     * an identical criteria, it returns the collection.
5756     * Otherwise if this ScarabUserImpl is new, it will return
5757     * an empty collection; or if this ScarabUserImpl has previously
5758     * been saved, it will retrieve related Reports from storage.
5759     *
5760     * This method is protected by default in order to keep the public
5761     * api reasonable.  You can provide public methods for those you
5762     * actually need in ScarabUserImpl.
5763     */
5764    protected List   getReportsJoinScarabUserImpl(Criteria criteria)
5765        throws TorqueException
5766    {
5767        if (collReports == null)
5768        {
5769            if (isNew())
5770            {
5771               collReports = new ArrayList  ();
5772            }
5773            else
5774            {
5775                            criteria.add(ReportPeer.USER_ID, getUserId() );
5776                            collReports = ReportPeer.doSelectJoinScarabUserImpl(criteria);
5777            }
5778        }
5779        else
5780        {
5781            // the following code is to determine if a new query is
5782            // called for.  If the criteria is the same as the last
5783            // one, just return the collection.
5784
5785                            criteria.add(ReportPeer.USER_ID, getUserId() );
5786                        if (!lastReportsCriteria.equals(criteria))
5787            {
5788                collReports = ReportPeer.doSelectJoinScarabUserImpl(criteria);
5789            }
5790        }
5791        lastReportsCriteria = criteria;
5792
5793        return collReports;
5794    }
5795                  
5796                    
5797                    
5798                                
5799                                                              
5800                                        
5801                    
5802                    
5803          
5804    /**
5805     * If this collection has already been initialized with
5806     * an identical criteria, it returns the collection.
5807     * Otherwise if this ScarabUserImpl is new, it will return
5808     * an empty collection; or if this ScarabUserImpl has previously
5809     * been saved, it will retrieve related Reports from storage.
5810     *
5811     * This method is protected by default in order to keep the public
5812     * api reasonable.  You can provide public methods for those you
5813     * actually need in ScarabUserImpl.
5814     */
5815    protected List   getReportsJoinScarabModule(Criteria criteria)
5816        throws TorqueException
5817    {
5818        if (collReports == null)
5819        {
5820            if (isNew())
5821            {
5822               collReports = new ArrayList  ();
5823            }
5824            else
5825            {
5826                            criteria.add(ReportPeer.USER_ID, getUserId() );
5827                            collReports = ReportPeer.doSelectJoinScarabModule(criteria);
5828            }
5829        }
5830        else
5831        {
5832            // the following code is to determine if a new query is
5833            // called for.  If the criteria is the same as the last
5834            // one, just return the collection.
5835
5836                            criteria.add(ReportPeer.USER_ID, getUserId() );
5837                        if (!lastReportsCriteria.equals(criteria))
5838            {
5839                collReports = ReportPeer.doSelectJoinScarabModule(criteria);
5840            }
5841        }
5842        lastReportsCriteria = criteria;
5843
5844        return collReports;
5845    }
5846                  
5847                    
5848                    
5849                                
5850                                                              
5851                                        
5852                    
5853                    
5854          
5855    /**
5856     * If this collection has already been initialized with
5857     * an identical criteria, it returns the collection.
5858     * Otherwise if this ScarabUserImpl is new, it will return
5859     * an empty collection; or if this ScarabUserImpl has previously
5860     * been saved, it will retrieve related Reports from storage.
5861     *
5862     * This method is protected by default in order to keep the public
5863     * api reasonable.  You can provide public methods for those you
5864     * actually need in ScarabUserImpl.
5865     */
5866    protected List   getReportsJoinScope(Criteria criteria)
5867        throws TorqueException
5868    {
5869        if (collReports == null)
5870        {
5871            if (isNew())
5872            {
5873               collReports = new ArrayList  ();
5874            }
5875            else
5876            {
5877                            criteria.add(ReportPeer.USER_ID, getUserId() );
5878                            collReports = ReportPeer.doSelectJoinScope(criteria);
5879            }
5880        }
5881        else
5882        {
5883            // the following code is to determine if a new query is
5884            // called for.  If the criteria is the same as the last
5885            // one, just return the collection.
5886
5887                            criteria.add(ReportPeer.USER_ID, getUserId() );
5888                        if (!lastReportsCriteria.equals(criteria))
5889            {
5890                collReports = ReportPeer.doSelectJoinScope(criteria);
5891            }
5892        }
5893        lastReportsCriteria = criteria;
5894
5895        return collReports;
5896    }
5897                            
5898
5899
5900                          
5901            
5902    /**
5903     * Collection to store aggregation of collPendingGroupUserRoles
5904     */
5905    protected List   collPendingGroupUserRoles;
5906
5907    /**
5908     * Temporary storage of collPendingGroupUserRoles to save a possible db hit in
5909     * the event objects are add to the collection, but the
5910     * complete collection is never requested.
5911     */
5912    protected void initPendingGroupUserRoles()
5913    {
5914        if (collPendingGroupUserRoles == null)
5915        {
5916            collPendingGroupUserRoles = new ArrayList  ();
5917        }
5918    }
5919
5920                  
5921    /**
5922     * Method called to associate a PendingGroupUserRole object to this object
5923     * through the PendingGroupUserRole foreign key attribute
5924     *
5925     * @param l PendingGroupUserRole
5926     * @throws TorqueException
5927     */
5928    public void addPendingGroupUserRole(PendingGroupUserRole l) throws TorqueException
5929    {
5930        getPendingGroupUserRoles().add(l);
5931        l.setScarabUser((ScarabUserImpl)this);
5932    }
5933
5934    /**
5935     * The criteria used to select the current contents of collPendingGroupUserRoles
5936     */
5937    private Criteria lastPendingGroupUserRolesCriteria = null;
5938
5939    /**
5940     * If this collection has already been initialized, returns
5941     * the collection. Otherwise returns the results of
5942     * getPendingGroupUserRoles(new Criteria())
5943     *
5944     * @throws TorqueException
5945     */
5946    public List   getPendingGroupUserRoles() throws TorqueException
5947    {
5948        if (collPendingGroupUserRoles == null)
5949        {
5950            collPendingGroupUserRoles = getPendingGroupUserRoles(new Criteria(10));
5951        }
5952        return collPendingGroupUserRoles;
5953    }
5954
5955    /**
5956     * If this collection has already been initialized with
5957     * an identical criteria, it returns the collection.
5958     * Otherwise if this ScarabUserImpl has previously
5959     * been saved, it will retrieve related PendingGroupUserRoles from storage.
5960     * If this ScarabUserImpl is new, it will return
5961     * an empty collection or the current collection, the criteria
5962     * is ignored on a new object.
5963     *
5964     * @throws TorqueException
5965     */
5966    public List   getPendingGroupUserRoles(Criteria criteria) throws TorqueException
5967    {
5968        if (collPendingGroupUserRoles == null)
5969        {
5970            if (isNew())
5971            {
5972               collPendingGroupUserRoles = new ArrayList  ();
5973            }
5974            else
5975            {
5976                      criteria.add(PendingGroupUserRolePeer.USER_ID, getUserId() );
5977                      collPendingGroupUserRoles = PendingGroupUserRolePeer.doSelect(criteria);
5978            }
5979        }
5980        else
5981        {
5982            // criteria has no effect for a new object
5983            if (!isNew())
5984            {
5985                // the following code is to determine if a new query is
5986                // called for.  If the criteria is the same as the last
5987                // one, just return the collection.
5988                      criteria.add(PendingGroupUserRolePeer.USER_ID, getUserId() );
5989                      if (!lastPendingGroupUserRolesCriteria.equals(criteria))
5990                {
5991                    collPendingGroupUserRoles = PendingGroupUserRolePeer.doSelect(criteria);
5992                }
5993            }
5994        }
5995        lastPendingGroupUserRolesCriteria = criteria;
5996
5997        return collPendingGroupUserRoles;
5998    }
5999
6000    /**
6001     * If this collection has already been initialized, returns
6002     * the collection. Otherwise returns the results of
6003     * getPendingGroupUserRoles(new Criteria(),Connection)
6004     * This method takes in the Connection also as input so that
6005     * referenced objects can also be obtained using a Connection
6006     * that is taken as input
6007     */
6008    public List   getPendingGroupUserRoles(Connection   con) throws TorqueException
6009    {
6010        if (collPendingGroupUserRoles == null)
6011        {
6012            collPendingGroupUserRoles = getPendingGroupUserRoles(new Criteria(10),con);
6013        }
6014        return collPendingGroupUserRoles;
6015    }
6016
6017    /**
6018     * If this collection has already been initialized with
6019     * an identical criteria, it returns the collection.
6020     * Otherwise if this ScarabUserImpl has previously
6021     * been saved, it will retrieve related PendingGroupUserRoles from storage.
6022     * If this ScarabUserImpl is new, it will return
6023     * an empty collection or the current collection, the criteria
6024     * is ignored on a new object.
6025     * This method takes in the Connection also as input so that
6026     * referenced objects can also be obtained using a Connection
6027     * that is taken as input
6028     */
6029    public List   getPendingGroupUserRoles(Criteria criteria,Connection   con) throws TorqueException
6030    {
6031        if (collPendingGroupUserRoles == null)
6032        {
6033            if (isNew())
6034            {
6035               collPendingGroupUserRoles = new ArrayList  ();
6036            }
6037            else
6038            {
6039                       criteria.add(PendingGroupUserRolePeer.USER_ID, getUserId() );
6040                       collPendingGroupUserRoles = PendingGroupUserRolePeer.doSelect(criteria,con);
6041             }
6042         }
6043         else
6044         {
6045             // criteria has no effect for a new object
6046             if (!isNew())
6047             {
6048                 // the following code is to determine if a new query is
6049                 // called for.  If the criteria is the same as the last
6050                 // one, just return the collection.
6051                     criteria.add(PendingGroupUserRolePeer.USER_ID, getUserId() );
6052                     if (!lastPendingGroupUserRolesCriteria.equals(criteria))
6053                 {
6054                     collPendingGroupUserRoles = PendingGroupUserRolePeer.doSelect(criteria,con);
6055                 }
6056             }
6057         }
6058         lastPendingGroupUserRolesCriteria = criteria;
6059
6060         return collPendingGroupUserRoles;
6061     }
6062
6063                        
6064              
6065                    
6066                              
6067                                
6068                                                              
6069                                        
6070                    
6071                    
6072          
6073    /**
6074     * If this collection has already been initialized with
6075     * an identical criteria, it returns the collection.
6076     * Otherwise if this ScarabUserImpl is new, it will return
6077     * an empty collection; or if this ScarabUserImpl has previously
6078     * been saved, it will retrieve related PendingGroupUserRoles from storage.
6079     *
6080     * This method is protected by default in order to keep the public
6081     * api reasonable.  You can provide public methods for those you
6082     * actually need in ScarabUserImpl.
6083     */
6084    protected List   getPendingGroupUserRolesJoinScarabUserImpl(Criteria criteria)
6085        throws TorqueException
6086    {
6087        if (collPendingGroupUserRoles == null)
6088        {
6089            if (isNew())
6090            {
6091               collPendingGroupUserRoles = new ArrayList  ();
6092            }
6093            else
6094            {
6095                            criteria.add(PendingGroupUserRolePeer.USER_ID, getUserId() );
6096                            collPendingGroupUserRoles = PendingGroupUserRolePeer.doSelectJoinScarabUserImpl(criteria);
6097            }
6098        }
6099        else
6100        {
6101            // the following code is to determine if a new query is
6102            // called for.  If the criteria is the same as the last
6103            // one, just return the collection.
6104
6105                            criteria.add(PendingGroupUserRolePeer.USER_ID, getUserId() );
6106                        if (!lastPendingGroupUserRolesCriteria.equals(criteria))
6107            {
6108                collPendingGroupUserRoles = PendingGroupUserRolePeer.doSelectJoinScarabUserImpl(criteria);
6109            }
6110        }
6111        lastPendingGroupUserRolesCriteria = criteria;
6112
6113        return collPendingGroupUserRoles;
6114    }
6115                  
6116                    
6117                    
6118                                
6119                                                              
6120                                        
6121                    
6122                    
6123          
6124    /**
6125     * If this collection has already been initialized with
6126     * an identical criteria, it returns the collection.
6127     * Otherwise if this ScarabUserImpl is new, it will return
6128     * an empty collection; or if this ScarabUserImpl has previously
6129     * been saved, it will retrieve related PendingGroupUserRoles from storage.
6130     *
6131     * This method is protected by default in order to keep the public
6132     * api reasonable.  You can provide public methods for those you
6133     * actually need in ScarabUserImpl.
6134     */
6135    protected List   getPendingGroupUserRolesJoinScarabModule(Criteria criteria)
6136        throws TorqueException
6137    {
6138        if (collPendingGroupUserRoles == null)
6139        {
6140            if (isNew())
6141            {
6142               collPendingGroupUserRoles = new ArrayList  ();
6143            }
6144            else
6145            {
6146                            criteria.add(PendingGroupUserRolePeer.USER_ID, getUserId() );
6147                            collPendingGroupUserRoles = PendingGroupUserRolePeer.doSelectJoinScarabModule(criteria);
6148            }
6149        }
6150        else
6151        {
6152            // the following code is to determine if a new query is
6153            // called for.  If the criteria is the same as the last
6154            // one, just return the collection.
6155
6156                            criteria.add(PendingGroupUserRolePeer.USER_ID, getUserId() );
6157                        if (!lastPendingGroupUserRolesCriteria.equals(criteria))
6158            {
6159                collPendingGroupUserRoles = PendingGroupUserRolePeer.doSelectJoinScarabModule(criteria);
6160            }
6161        }
6162        lastPendingGroupUserRolesCriteria = criteria;
6163
6164        return collPendingGroupUserRoles;
6165    }
6166                            
6167
6168
6169          
6170     
6171
6172    /**
6173     * Specify whether to cache the object after saving to the db.
6174     * This method returns false
6175     */
6176    protected boolean isCacheOnSave()
6177    {
6178        return true;
6179    }
6180
6181 
6182    /**
6183     * get an id that differentiates this object from others
6184     * of its class.
6185     */
6186    public String   getQueryKey()
6187    {
6188        if (getPrimaryKey() == null)
6189        {
6190            return "";
6191        }
6192        else
6193        {
6194            return getPrimaryKey().toString();
6195        }
6196    }
6197
6198    /**
6199     * set an id that differentiates this object from others
6200     * of its class.
6201     */
6202    public void setQueryKey(String   key)
6203        throws TorqueException
6204    {
6205        setPrimaryKey(key);
6206    }
6207
6208
6209
6210    public String   toString()
6211    {
6212        StringBuffer   str = new StringBuffer  ();
6213        str.append("ScarabUserImpl:\n");
6214        str.append("UserId = ")
6215               .append(getUserId())
6216             .append("\n");
6217        return(str.toString());
6218    }
6219}
6220
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags