View Javadoc

    1   package org.apache.turbine.services.security.torque.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.torque.TorqueException;
    13  import org.apache.torque.map.TableMap;
    14  import org.apache.torque.om.BaseObject;
    15  import org.apache.torque.om.ComboKey;
    16  import org.apache.torque.om.DateKey;
    17  import org.apache.torque.om.NumberKey;
    18  import org.apache.torque.om.ObjectKey;
    19  import org.apache.torque.om.SimpleKey;
    20  import org.apache.torque.om.StringKey;
    21  import org.apache.torque.om.Persistent;
    22  import org.apache.torque.util.Criteria;
    23  import org.apache.torque.util.Transaction;
    24
    25
    26
    27
    28
    29  /**
    30   * This class was autogenerated by Torque on:
    31   *
    32   * [Thu Jun 23 17:25:46 CEST 2011]
    33   *
    34   * You should not use this class directly.  It should not even be
    35   * extended all references should be to TurbineRole
    36   */
    37  public abstract class BaseTurbineRole extends BaseObject
    38  {
    39      /** Serial version */
    40      private static final long serialVersionUID = 1308842746584L;
    41
    42      /** The Peer class */
    43      private static final TurbineRolePeer peer =
    44          new TurbineRolePeer();
    45
    46
    47      /** The value for the roleId field */
    48      private int roleId;
    49
    50      /** The value for the name field */
    51      private String name;
    52
    53
    54      /**
    55       * Get the RoleId
    56       *
    57       * @return int
    58       */
    59      public int getRoleId()
    60      {
    61          return roleId;
    62      }
    63
    64
    65      /**
    66       * Set the value of RoleId
    67       *
    68       * @param v new value
    69       */
    70      public void setRoleId(int v) throws TorqueException
    71      {
    72
    73          if (this.roleId != v)
    74          {
    75              this.roleId = v;
    76              setModified(true);
    77          }
    78
    79
    80
    81          // update associated TurbineRolePermission
    82          if (collTurbineRolePermissions != null)
    83          {
    84              for (int i = 0; i < collTurbineRolePermissions.size(); i++)
    85              {
    86                  ((TurbineRolePermission) collTurbineRolePermissions.get(i))
    87                          .setRoleId(v);
    88              }
    89          }
    90
    91          // update associated TurbineUserGroupRole
    92          if (collTurbineUserGroupRoles != null)
    93          {
    94              for (int i = 0; i < collTurbineUserGroupRoles.size(); i++)
    95              {
    96                  ((TurbineUserGroupRole) collTurbineUserGroupRoles.get(i))
    97                          .setRoleId(v);
    98              }
    99          }
    100     }
    101
    102     /**
    103      * Get the Name
    104      *
    105      * @return String
    106      */
    107     public String getName()
    108     {
    109         return name;
    110     }
    111
    112
    113     /**
    114      * Set the value of Name
    115      *
    116      * @param v new value
    117      */
    118     public void setName(String v)
    119     {
    120
    121         if (!ObjectUtils.equals(this.name, v))
    122         {
    123             this.name = v;
    124             setModified(true);
    125         }
    126
    127
    128     }
    129
    130
    131
    132
    133     /**
    134      * Collection to store aggregation of collTurbineRolePermissions
    135      */
    136     protected List<TurbineRolePermission> collTurbineRolePermissions;
    137
    138     /**
    139      * Temporary storage of collTurbineRolePermissions to save a possible db hit in
    140      * the event objects are add to the collection, but the
    141      * complete collection is never requested.
    142      */
    143     protected void initTurbineRolePermissions()
    144     {
    145         if (collTurbineRolePermissions == null)
    146         {
    147             collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    148         }
    149     }
    150
    151
    152     /**
    153      * Method called to associate a TurbineRolePermission object to this object
    154      * through the TurbineRolePermission foreign key attribute
    155      *
    156      * @param l TurbineRolePermission
    157      * @throws TorqueException
    158      */
    159     public void addTurbineRolePermission(TurbineRolePermission l) throws TorqueException
    160     {
    161         getTurbineRolePermissions().add(l);
    162         l.setTurbineRole((TurbineRole) this);
    163     }
    164
    165     /**
    166      * Method called to associate a TurbineRolePermission object to this object
    167      * through the TurbineRolePermission foreign key attribute using connection.
    168      *
    169      * @param l TurbineRolePermission
    170      * @throws TorqueException
    171      */
    172     public void addTurbineRolePermission(TurbineRolePermission l, Connection con) throws TorqueException
    173     {
    174         getTurbineRolePermissions(con).add(l);
    175         l.setTurbineRole((TurbineRole) this);
    176     }
    177
    178     /**
    179      * The criteria used to select the current contents of collTurbineRolePermissions
    180      */
    181     private Criteria lastTurbineRolePermissionsCriteria = null;
    182
    183     /**
    184      * If this collection has already been initialized, returns
    185      * the collection. Otherwise returns the results of
    186      * getTurbineRolePermissions(new Criteria())
    187      *
    188      * @return the collection of associated objects
    189      * @throws TorqueException
    190      */
    191     public List<TurbineRolePermission> getTurbineRolePermissions()
    192         throws TorqueException
    193     {
    194         if (collTurbineRolePermissions == null)
    195         {
    196             collTurbineRolePermissions = getTurbineRolePermissions(new Criteria(10));
    197         }
    198         return collTurbineRolePermissions;
    199     }
    200
    201     /**
    202      * If this collection has already been initialized with
    203      * an identical criteria, it returns the collection.
    204      * Otherwise if this TurbineRole has previously
    205      * been saved, it will retrieve related TurbineRolePermissions from storage.
    206      * If this TurbineRole is new, it will return
    207      * an empty collection or the current collection, the criteria
    208      * is ignored on a new object.
    209      *
    210      * @throws TorqueException
    211      */
    212     public List<TurbineRolePermission> getTurbineRolePermissions(Criteria criteria) throws TorqueException
    213     {
    214         if (collTurbineRolePermissions == null)
    215         {
    216             if (isNew())
    217             {
    218                collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    219             }
    220             else
    221             {
    222                 criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId() );
    223                 collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria);
    224             }
    225         }
    226         else
    227         {
    228             // criteria has no effect for a new object
    229             if (!isNew())
    230             {
    231                 // the following code is to determine if a new query is
    232                 // called for.  If the criteria is the same as the last
    233                 // one, just return the collection.
    234                 criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
    235                 if (!lastTurbineRolePermissionsCriteria.equals(criteria))
    236                 {
    237                     collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria);
    238                 }
    239             }
    240         }
    241         lastTurbineRolePermissionsCriteria = criteria;
    242
    243         return collTurbineRolePermissions;
    244     }
    245
    246     /**
    247      * If this collection has already been initialized, returns
    248      * the collection. Otherwise returns the results of
    249      * getTurbineRolePermissions(new Criteria(),Connection)
    250      * This method takes in the Connection also as input so that
    251      * referenced objects can also be obtained using a Connection
    252      * that is taken as input
    253      */
    254     public List<TurbineRolePermission> getTurbineRolePermissions(Connection con) throws TorqueException
    255     {
    256         if (collTurbineRolePermissions == null)
    257         {
    258             collTurbineRolePermissions = getTurbineRolePermissions(new Criteria(10), con);
    259         }
    260         return collTurbineRolePermissions;
    261     }
    262
    263     /**
    264      * If this collection has already been initialized with
    265      * an identical criteria, it returns the collection.
    266      * Otherwise if this TurbineRole has previously
    267      * been saved, it will retrieve related TurbineRolePermissions from storage.
    268      * If this TurbineRole is new, it will return
    269      * an empty collection or the current collection, the criteria
    270      * is ignored on a new object.
    271      * This method takes in the Connection also as input so that
    272      * referenced objects can also be obtained using a Connection
    273      * that is taken as input
    274      */
    275     public List<TurbineRolePermission> getTurbineRolePermissions(Criteria criteria, Connection con)
    276             throws TorqueException
    277     {
    278         if (collTurbineRolePermissions == null)
    279         {
    280             if (isNew())
    281             {
    282                collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    283             }
    284             else
    285             {
    286                  criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
    287                  collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria, con);
    288              }
    289          }
    290          else
    291          {
    292              // criteria has no effect for a new object
    293              if (!isNew())
    294              {
    295                  // the following code is to determine if a new query is
    296                  // called for.  If the criteria is the same as the last
    297                  // one, just return the collection.
    298                  criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
    299                  if (!lastTurbineRolePermissionsCriteria.equals(criteria))
    300                  {
    301                      collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria, con);
    302                  }
    303              }
    304          }
    305          lastTurbineRolePermissionsCriteria = criteria;
    306
    307          return collTurbineRolePermissions;
    308      }
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320     /**
    321      * If this collection has already been initialized with
    322      * an identical criteria, it returns the collection.
    323      * Otherwise if this TurbineRole is new, it will return
    324      * an empty collection; or if this TurbineRole has previously
    325      * been saved, it will retrieve related TurbineRolePermissions from storage.
    326      *
    327      * This method is protected by default in order to keep the public
    328      * api reasonable.  You can provide public methods for those you
    329      * actually need in TurbineRole.
    330      */
    331     protected List<TurbineRolePermission> getTurbineRolePermissionsJoinTurbineRole(Criteria criteria)
    332         throws TorqueException
    333     {
    334         if (collTurbineRolePermissions == null)
    335         {
    336             if (isNew())
    337             {
    338                collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    339             }
    340             else
    341             {
    342                 criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
    343                 collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbineRole(criteria);
    344             }
    345         }
    346         else
    347         {
    348             // the following code is to determine if a new query is
    349             // called for.  If the criteria is the same as the last
    350             // one, just return the collection.
    351             criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
    352             if (!lastTurbineRolePermissionsCriteria.equals(criteria))
    353             {
    354                 collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbineRole(criteria);
    355             }
    356         }
    357         lastTurbineRolePermissionsCriteria = criteria;
    358
    359         return collTurbineRolePermissions;
    360     }
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370     /**
    371      * If this collection has already been initialized with
    372      * an identical criteria, it returns the collection.
    373      * Otherwise if this TurbineRole is new, it will return
    374      * an empty collection; or if this TurbineRole has previously
    375      * been saved, it will retrieve related TurbineRolePermissions from storage.
    376      *
    377      * This method is protected by default in order to keep the public
    378      * api reasonable.  You can provide public methods for those you
    379      * actually need in TurbineRole.
    380      */
    381     protected List<TurbineRolePermission> getTurbineRolePermissionsJoinTurbinePermission(Criteria criteria)
    382         throws TorqueException
    383     {
    384         if (collTurbineRolePermissions == null)
    385         {
    386             if (isNew())
    387             {
    388                collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    389             }
    390             else
    391             {
    392                 criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
    393                 collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbinePermission(criteria);
    394             }
    395         }
    396         else
    397         {
    398             // the following code is to determine if a new query is
    399             // called for.  If the criteria is the same as the last
    400             // one, just return the collection.
    401             criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
    402             if (!lastTurbineRolePermissionsCriteria.equals(criteria))
    403             {
    404                 collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbinePermission(criteria);
    405             }
    406         }
    407         lastTurbineRolePermissionsCriteria = criteria;
    408
    409         return collTurbineRolePermissions;
    410     }
    411
    412
    413
    414
    415
    416     /**
    417      * Collection to store aggregation of collTurbineUserGroupRoles
    418      */
    419     protected List<TurbineUserGroupRole> collTurbineUserGroupRoles;
    420
    421     /**
    422      * Temporary storage of collTurbineUserGroupRoles to save a possible db hit in
    423      * the event objects are add to the collection, but the
    424      * complete collection is never requested.
    425      */
    426     protected void initTurbineUserGroupRoles()
    427     {
    428         if (collTurbineUserGroupRoles == null)
    429         {
    430             collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    431         }
    432     }
    433
    434
    435     /**
    436      * Method called to associate a TurbineUserGroupRole object to this object
    437      * through the TurbineUserGroupRole foreign key attribute
    438      *
    439      * @param l TurbineUserGroupRole
    440      * @throws TorqueException
    441      */
    442     public void addTurbineUserGroupRole(TurbineUserGroupRole l) throws TorqueException
    443     {
    444         getTurbineUserGroupRoles().add(l);
    445         l.setTurbineRole((TurbineRole) this);
    446     }
    447
    448     /**
    449      * Method called to associate a TurbineUserGroupRole object to this object
    450      * through the TurbineUserGroupRole foreign key attribute using connection.
    451      *
    452      * @param l TurbineUserGroupRole
    453      * @throws TorqueException
    454      */
    455     public void addTurbineUserGroupRole(TurbineUserGroupRole l, Connection con) throws TorqueException
    456     {
    457         getTurbineUserGroupRoles(con).add(l);
    458         l.setTurbineRole((TurbineRole) this);
    459     }
    460
    461     /**
    462      * The criteria used to select the current contents of collTurbineUserGroupRoles
    463      */
    464     private Criteria lastTurbineUserGroupRolesCriteria = null;
    465
    466     /**
    467      * If this collection has already been initialized, returns
    468      * the collection. Otherwise returns the results of
    469      * getTurbineUserGroupRoles(new Criteria())
    470      *
    471      * @return the collection of associated objects
    472      * @throws TorqueException
    473      */
    474     public List<TurbineUserGroupRole> getTurbineUserGroupRoles()
    475         throws TorqueException
    476     {
    477         if (collTurbineUserGroupRoles == null)
    478         {
    479             collTurbineUserGroupRoles = getTurbineUserGroupRoles(new Criteria(10));
    480         }
    481         return collTurbineUserGroupRoles;
    482     }
    483
    484     /**
    485      * If this collection has already been initialized with
    486      * an identical criteria, it returns the collection.
    487      * Otherwise if this TurbineRole has previously
    488      * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    489      * If this TurbineRole is new, it will return
    490      * an empty collection or the current collection, the criteria
    491      * is ignored on a new object.
    492      *
    493      * @throws TorqueException
    494      */
    495     public List<TurbineUserGroupRole> getTurbineUserGroupRoles(Criteria criteria) throws TorqueException
    496     {
    497         if (collTurbineUserGroupRoles == null)
    498         {
    499             if (isNew())
    500             {
    501                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    502             }
    503             else
    504             {
    505                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId() );
    506                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria);
    507             }
    508         }
    509         else
    510         {
    511             // criteria has no effect for a new object
    512             if (!isNew())
    513             {
    514                 // the following code is to determine if a new query is
    515                 // called for.  If the criteria is the same as the last
    516                 // one, just return the collection.
    517                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
    518                 if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    519                 {
    520                     collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria);
    521                 }
    522             }
    523         }
    524         lastTurbineUserGroupRolesCriteria = criteria;
    525
    526         return collTurbineUserGroupRoles;
    527     }
    528
    529     /**
    530      * If this collection has already been initialized, returns
    531      * the collection. Otherwise returns the results of
    532      * getTurbineUserGroupRoles(new Criteria(),Connection)
    533      * This method takes in the Connection also as input so that
    534      * referenced objects can also be obtained using a Connection
    535      * that is taken as input
    536      */
    537     public List<TurbineUserGroupRole> getTurbineUserGroupRoles(Connection con) throws TorqueException
    538     {
    539         if (collTurbineUserGroupRoles == null)
    540         {
    541             collTurbineUserGroupRoles = getTurbineUserGroupRoles(new Criteria(10), con);
    542         }
    543         return collTurbineUserGroupRoles;
    544     }
    545
    546     /**
    547      * If this collection has already been initialized with
    548      * an identical criteria, it returns the collection.
    549      * Otherwise if this TurbineRole has previously
    550      * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    551      * If this TurbineRole is new, it will return
    552      * an empty collection or the current collection, the criteria
    553      * is ignored on a new object.
    554      * This method takes in the Connection also as input so that
    555      * referenced objects can also be obtained using a Connection
    556      * that is taken as input
    557      */
    558     public List<TurbineUserGroupRole> getTurbineUserGroupRoles(Criteria criteria, Connection con)
    559             throws TorqueException
    560     {
    561         if (collTurbineUserGroupRoles == null)
    562         {
    563             if (isNew())
    564             {
    565                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    566             }
    567             else
    568             {
    569                  criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
    570                  collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria, con);
    571              }
    572          }
    573          else
    574          {
    575              // criteria has no effect for a new object
    576              if (!isNew())
    577              {
    578                  // the following code is to determine if a new query is
    579                  // called for.  If the criteria is the same as the last
    580                  // one, just return the collection.
    581                  criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
    582                  if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    583                  {
    584                      collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria, con);
    585                  }
    586              }
    587          }
    588          lastTurbineUserGroupRolesCriteria = criteria;
    589
    590          return collTurbineUserGroupRoles;
    591      }
    592
    593
    594
    595
    596
    597
    598
    599
    600
    601
    602
    603     /**
    604      * If this collection has already been initialized with
    605      * an identical criteria, it returns the collection.
    606      * Otherwise if this TurbineRole is new, it will return
    607      * an empty collection; or if this TurbineRole has previously
    608      * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    609      *
    610      * This method is protected by default in order to keep the public
    611      * api reasonable.  You can provide public methods for those you
    612      * actually need in TurbineRole.
    613      */
    614     protected List<TurbineUserGroupRole> getTurbineUserGroupRolesJoinTurbineUser(Criteria criteria)
    615         throws TorqueException
    616     {
    617         if (collTurbineUserGroupRoles == null)
    618         {
    619             if (isNew())
    620             {
    621                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    622             }
    623             else
    624             {
    625                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
    626                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineUser(criteria);
    627             }
    628         }
    629         else
    630         {
    631             // the following code is to determine if a new query is
    632             // called for.  If the criteria is the same as the last
    633             // one, just return the collection.
    634             criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
    635             if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    636             {
    637                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineUser(criteria);
    638             }
    639         }
    640         lastTurbineUserGroupRolesCriteria = criteria;
    641
    642         return collTurbineUserGroupRoles;
    643     }
    644
    645
    646
    647
    648
    649
    650
    651
    652
    653     /**
    654      * If this collection has already been initialized with
    655      * an identical criteria, it returns the collection.
    656      * Otherwise if this TurbineRole is new, it will return
    657      * an empty collection; or if this TurbineRole has previously
    658      * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    659      *
    660      * This method is protected by default in order to keep the public
    661      * api reasonable.  You can provide public methods for those you
    662      * actually need in TurbineRole.
    663      */
    664     protected List<TurbineUserGroupRole> getTurbineUserGroupRolesJoinTurbineGroup(Criteria criteria)
    665         throws TorqueException
    666     {
    667         if (collTurbineUserGroupRoles == null)
    668         {
    669             if (isNew())
    670             {
    671                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    672             }
    673             else
    674             {
    675                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
    676                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineGroup(criteria);
    677             }
    678         }
    679         else
    680         {
    681             // the following code is to determine if a new query is
    682             // called for.  If the criteria is the same as the last
    683             // one, just return the collection.
    684             criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
    685             if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    686             {
    687                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineGroup(criteria);
    688             }
    689         }
    690         lastTurbineUserGroupRolesCriteria = criteria;
    691
    692         return collTurbineUserGroupRoles;
    693     }
    694
    695
    696
    697
    698
    699
    700
    701
    702
    703     /**
    704      * If this collection has already been initialized with
    705      * an identical criteria, it returns the collection.
    706      * Otherwise if this TurbineRole is new, it will return
    707      * an empty collection; or if this TurbineRole has previously
    708      * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    709      *
    710      * This method is protected by default in order to keep the public
    711      * api reasonable.  You can provide public methods for those you
    712      * actually need in TurbineRole.
    713      */
    714     protected List<TurbineUserGroupRole> getTurbineUserGroupRolesJoinTurbineRole(Criteria criteria)
    715         throws TorqueException
    716     {
    717         if (collTurbineUserGroupRoles == null)
    718         {
    719             if (isNew())
    720             {
    721                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    722             }
    723             else
    724             {
    725                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
    726                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineRole(criteria);
    727             }
    728         }
    729         else
    730         {
    731             // the following code is to determine if a new query is
    732             // called for.  If the criteria is the same as the last
    733             // one, just return the collection.
    734             criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
    735             if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    736             {
    737                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineRole(criteria);
    738             }
    739         }
    740         lastTurbineUserGroupRolesCriteria = criteria;
    741
    742         return collTurbineUserGroupRoles;
    743     }
    744
    745
    746
    747
    748     private static List<String> fieldNames = null;
    749
    750     /**
    751      * Generate a list of field names.
    752      *
    753      * @return a list of field names
    754      */
    755     public static synchronized List<String> getFieldNames()
    756     {
    757         if (fieldNames == null)
    758         {
    759             fieldNames = new ArrayList<String>();
    760             fieldNames.add("RoleId");
    761             fieldNames.add("Name");
    762             fieldNames = Collections.unmodifiableList(fieldNames);
    763         }
    764         return fieldNames;
    765     }
    766
    767     /**
    768      * Retrieves a field from the object by field (Java) name passed in as a String.
    769      *
    770      * @param name field name
    771      * @return value
    772      */
    773     public Object getByName(String name)
    774     {
    775         if (name.equals("RoleId"))
    776         {
    777             return new Integer(getRoleId());
    778         }
    779         if (name.equals("Name"))
    780         {
    781             return getName();
    782         }
    783         return null;
    784     }
    785
    786     /**
    787      * Set a field in the object by field (Java) name.
    788      *
    789      * @param name field name
    790      * @param value field value
    791      * @return True if value was set, false if not (invalid name / protected field).
    792      * @throws IllegalArgumentException if object type of value does not match field object type.
    793      * @throws TorqueException If a problem occurs with the set[Field] method.
    794      */
    795     public boolean setByName(String name, Object value )
    796         throws TorqueException, IllegalArgumentException
    797     {
    798         if (name.equals("RoleId"))
    799         {
    800             if (value == null || ! (Integer.class.isInstance(value)))
    801             {
    802                 throw new IllegalArgumentException("setByName: value parameter was null or not an Integer object.");
    803             }
    804             setRoleId(((Integer) value).intValue());
    805             return true;
    806         }
    807         if (name.equals("Name"))
    808         {
    809             // Object fields can be null
    810             if (value != null && ! String.class.isInstance(value))
    811             {
    812                 throw new IllegalArgumentException("Invalid type of object specified for value in setByName");
    813             }
    814             setName((String) value);
    815             return true;
    816         }
    817         return false;
    818     }
    819
    820     /**
    821      * Retrieves a field from the object by name passed in
    822      * as a String.  The String must be one of the static
    823      * Strings defined in this Class' Peer.
    824      *
    825      * @param name peer name
    826      * @return value
    827      */
    828     public Object getByPeerName(String name)
    829     {
    830         if (name.equals(TurbineRolePeer.ROLE_ID))
    831         {
    832             return new Integer(getRoleId());
    833         }
    834         if (name.equals(TurbineRolePeer.ROLE_NAME))
    835         {
    836             return getName();
    837         }
    838         return null;
    839     }
    840
    841     /**
    842      * Set field values by Peer Field Name
    843      *
    844      * @param name field name
    845      * @param value field value
    846      * @return True if value was set, false if not (invalid name / protected field).
    847      * @throws IllegalArgumentException if object type of value does not match field object type.
    848      * @throws TorqueException If a problem occurs with the set[Field] method.
    849      */
    850     public boolean setByPeerName(String name, Object value)
    851         throws TorqueException, IllegalArgumentException
    852     {
    853       if (TurbineRolePeer.ROLE_ID.equals(name))
    854         {
    855             return setByName("RoleId", value);
    856         }
    857       if (TurbineRolePeer.ROLE_NAME.equals(name))
    858         {
    859             return setByName("Name", value);
    860         }
    861         return false;
    862     }
    863
    864     /**
    865      * Retrieves a field from the object by Position as specified
    866      * in the xml schema.  Zero-based.
    867      *
    868      * @param pos position in xml schema
    869      * @return value
    870      */
    871     public Object getByPosition(int pos)
    872     {
    873         if (pos == 0)
    874         {
    875             return new Integer(getRoleId());
    876         }
    877         if (pos == 1)
    878         {
    879             return getName();
    880         }
    881         return null;
    882     }
    883
    884     /**
    885      * Set field values by its position (zero based) in the XML schema.
    886      *
    887      * @param position The field position
    888      * @param value field value
    889      * @return True if value was set, false if not (invalid position / protected field).
    890      * @throws IllegalArgumentException if object type of value does not match field object type.
    891      * @throws TorqueException If a problem occurs with the set[Field] method.
    892      */
    893     public boolean setByPosition(int position, Object value)
    894         throws TorqueException, IllegalArgumentException
    895     {
    896     if (position == 0)
    897         {
    898             return setByName("RoleId", value);
    899         }
    900     if (position == 1)
    901         {
    902             return setByName("Name", value);
    903         }
    904         return false;
    905     }
    906
    907     /**
    908      * Stores the object in the database.  If the object is new,
    909      * it inserts it; otherwise an update is performed.
    910      *
    911      * @throws Exception
    912      */
    913     public void save() throws Exception
    914     {
    915         save(TurbineRolePeer.DATABASE_NAME);
    916     }
    917
    918     /**
    919      * Stores the object in the database.  If the object is new,
    920      * it inserts it; otherwise an update is performed.
    921      * Note: this code is here because the method body is
    922      * auto-generated conditionally and therefore needs to be
    923      * in this file instead of in the super class, BaseObject.
    924      *
    925      * @param dbName
    926      * @throws TorqueException
    927      */
    928     public void save(String dbName) throws TorqueException
    929     {
    930         Connection con = null;
    931         try
    932         {
    933             con = Transaction.begin(dbName);
    934             save(con);
    935             Transaction.commit(con);
    936         }
    937         catch(TorqueException e)
    938         {
    939             Transaction.safeRollback(con);
    940             throw e;
    941         }
    942     }
    943
    944     /** flag to prevent endless save loop, if this object is referenced
    945         by another object which falls in this transaction. */
    946     private boolean alreadyInSave = false;
    947     /**
    948      * Stores the object in the database.  If the object is new,
    949      * it inserts it; otherwise an update is performed.  This method
    950      * is meant to be used as part of a transaction, otherwise use
    951      * the save() method and the connection details will be handled
    952      * internally
    953      *
    954      * @param con
    955      * @throws TorqueException
    956      */
    957     public void save(Connection con) throws TorqueException
    958     {
    959         if (!alreadyInSave)
    960         {
    961             alreadyInSave = true;
    962
    963
    964
    965             // If this object has been modified, then save it to the database.
    966             if (isModified())
    967             {
    968                 if (isNew())
    969                 {
    970                     TurbineRolePeer.doInsert((TurbineRole) this, con);
    971                     setNew(false);
    972                 }
    973                 else
    974                 {
    975                     TurbineRolePeer.doUpdate((TurbineRole) this, con);
    976                 }
    977             }
    978
    979
    980             if (collTurbineRolePermissions != null)
    981             {
    982                 for (int i = 0; i < collTurbineRolePermissions.size(); i++)
    983                 {
    984                     ((TurbineRolePermission) collTurbineRolePermissions.get(i)).save(con);
    985                 }
    986             }
    987
    988             if (collTurbineUserGroupRoles != null)
    989             {
    990                 for (int i = 0; i < collTurbineUserGroupRoles.size(); i++)
    991                 {
    992                     ((TurbineUserGroupRole) collTurbineUserGroupRoles.get(i)).save(con);
    993                 }
    994             }
    995             alreadyInSave = false;
    996         }
    997     }
    998
    999
    1000     /**
    1001      * Set the PrimaryKey using ObjectKey.
    1002      *
    1003      * @param key roleId ObjectKey
    1004      */
    1005     public void setPrimaryKey(ObjectKey key)
    1006         throws TorqueException
    1007     {
    1008         setRoleId(((NumberKey) key).intValue());
    1009     }
    1010
    1011     /**
    1012      * Set the PrimaryKey using a String.
    1013      *
    1014      * @param key
    1015      */
    1016     public void setPrimaryKey(String key) throws TorqueException
    1017     {
    1018         setRoleId(Integer.parseInt(key));
    1019     }
    1020
    1021
    1022     /**
    1023      * returns an id that differentiates this object from others
    1024      * of its class.
    1025      */
    1026     public ObjectKey getPrimaryKey()
    1027     {
    1028         return SimpleKey.keyFor(getRoleId());
    1029     }
    1030
    1031
    1032     /**
    1033      * Makes a copy of this object.
    1034      * It creates a new object filling in the simple attributes.
    1035      * It then fills all the association collections and sets the
    1036      * related objects to isNew=true.
    1037      */
    1038     public TurbineRole copy() throws TorqueException
    1039     {
    1040         return copy(true);
    1041     }
    1042
    1043     /**
    1044      * Makes a copy of this object using connection.
    1045      * It creates a new object filling in the simple attributes.
    1046      * It then fills all the association collections and sets the
    1047      * related objects to isNew=true.
    1048      *
    1049      * @param con the database connection to read associated objects.
    1050      */
    1051     public TurbineRole copy(Connection con) throws TorqueException
    1052     {
    1053         return copy(true, con);
    1054     }
    1055
    1056     /**
    1057      * Makes a copy of this object.
    1058      * It creates a new object filling in the simple attributes.
    1059      * If the parameter deepcopy is true, it then fills all the
    1060      * association collections and sets the related objects to
    1061      * isNew=true.
    1062      *
    1063      * @param deepcopy whether to copy the associated objects.
    1064      */
    1065     public TurbineRole copy(boolean deepcopy) throws TorqueException
    1066     {
    1067         return copyInto(new TurbineRole(), deepcopy);
    1068     }
    1069
    1070     /**
    1071      * Makes a copy of this object using connection.
    1072      * It creates a new object filling in the simple attributes.
    1073      * If the parameter deepcopy is true, it then fills all the
    1074      * association collections and sets the related objects to
    1075      * isNew=true.
    1076      *
    1077      * @param deepcopy whether to copy the associated objects.
    1078      * @param con the database connection to read associated objects.
    1079      */
    1080     public TurbineRole copy(boolean deepcopy, Connection con) throws TorqueException
    1081     {
    1082         return copyInto(new TurbineRole(), deepcopy, con);
    1083     }
    1084
    1085     /**
    1086      * Fills the copyObj with the contents of this object.
    1087      * The associated objects are also copied and treated as new objects.
    1088      *
    1089      * @param copyObj the object to fill.
    1090      */
    1091     protected TurbineRole copyInto(TurbineRole copyObj) throws TorqueException
    1092     {
    1093         return copyInto(copyObj, true);
    1094     }
    1095
    1096
    1097     /**
    1098      * Fills the copyObj with the contents of this object using connection.
    1099      * The associated objects are also copied and treated as new objects.
    1100      *
    1101      * @param copyObj the object to fill.
    1102      * @param con the database connection to read associated objects.
    1103      */
    1104     protected TurbineRole copyInto(TurbineRole copyObj, Connection con) throws TorqueException
    1105     {
    1106         return copyInto(copyObj, true, con);
    1107     }
    1108
    1109     /**
    1110      * Fills the copyObj with the contents of this object.
    1111      * If deepcopy is true, The associated objects are also copied
    1112      * and treated as new objects.
    1113      *
    1114      * @param copyObj the object to fill.
    1115      * @param deepcopy whether the associated objects should be copied.
    1116      */
    1117     protected TurbineRole copyInto(TurbineRole copyObj, boolean deepcopy) throws TorqueException
    1118     {
    1119         copyObj.setRoleId(roleId);
    1120         copyObj.setName(name);
    1121
    1122         copyObj.setRoleId( 0);
    1123
    1124         if (deepcopy)
    1125         {
    1126
    1127
    1128         List<TurbineRolePermission> vTurbineRolePermissions = getTurbineRolePermissions();
    1129         if (vTurbineRolePermissions != null)
    1130         {
    1131             for (int i = 0; i < vTurbineRolePermissions.size(); i++)
    1132             {
    1133                 TurbineRolePermission obj =  vTurbineRolePermissions.get(i);
    1134                 copyObj.addTurbineRolePermission(obj.copy());
    1135             }
    1136         }
    1137         else
    1138         {
    1139             copyObj.collTurbineRolePermissions = null;
    1140         }
    1141
    1142
    1143         List<TurbineUserGroupRole> vTurbineUserGroupRoles = getTurbineUserGroupRoles();
    1144         if (vTurbineUserGroupRoles != null)
    1145         {
    1146             for (int i = 0; i < vTurbineUserGroupRoles.size(); i++)
    1147             {
    1148                 TurbineUserGroupRole obj =  vTurbineUserGroupRoles.get(i);
    1149                 copyObj.addTurbineUserGroupRole(obj.copy());
    1150             }
    1151         }
    1152         else
    1153         {
    1154             copyObj.collTurbineUserGroupRoles = null;
    1155         }
    1156         }
    1157         return copyObj;
    1158     }
    1159
    1160
    1161     /**
    1162      * Fills the copyObj with the contents of this object using connection.
    1163      * If deepcopy is true, The associated objects are also copied
    1164      * and treated as new objects.
    1165      *
    1166      * @param copyObj the object to fill.
    1167      * @param deepcopy whether the associated objects should be copied.
    1168      * @param con the database connection to read associated objects.
    1169      */
    1170     protected TurbineRole copyInto(TurbineRole copyObj, boolean deepcopy, Connection con) throws TorqueException
    1171     {
    1172         copyObj.setRoleId(roleId);
    1173         copyObj.setName(name);
    1174
    1175         copyObj.setRoleId( 0);
    1176
    1177         if (deepcopy)
    1178         {
    1179
    1180
    1181         List<TurbineRolePermission> vTurbineRolePermissions = getTurbineRolePermissions(con);
    1182         if (vTurbineRolePermissions != null)
    1183         {
    1184             for (int i = 0; i < vTurbineRolePermissions.size(); i++)
    1185             {
    1186                 TurbineRolePermission obj =  vTurbineRolePermissions.get(i);
    1187                 copyObj.addTurbineRolePermission(obj.copy(con), con);
    1188             }
    1189         }
    1190         else
    1191         {
    1192             copyObj.collTurbineRolePermissions = null;
    1193         }
    1194
    1195
    1196         List<TurbineUserGroupRole> vTurbineUserGroupRoles = getTurbineUserGroupRoles(con);
    1197         if (vTurbineUserGroupRoles != null)
    1198         {
    1199             for (int i = 0; i < vTurbineUserGroupRoles.size(); i++)
    1200             {
    1201                 TurbineUserGroupRole obj =  vTurbineUserGroupRoles.get(i);
    1202                 copyObj.addTurbineUserGroupRole(obj.copy(con), con);
    1203             }
    1204         }
    1205         else
    1206         {
    1207             copyObj.collTurbineUserGroupRoles = null;
    1208         }
    1209         }
    1210         return copyObj;
    1211     }
    1212
    1213
    1214
    1215     /**
    1216      * returns a peer instance associated with this om.  Since Peer classes
    1217      * are not to have any instance attributes, this method returns the
    1218      * same instance for all member of this class. The method could therefore
    1219      * be static, but this would prevent one from overriding the behavior.
    1220      */
    1221     public TurbineRolePeer getPeer()
    1222     {
    1223         return peer;
    1224     }
    1225
    1226     /**
    1227      * Retrieves the TableMap object related to this Table data without
    1228      * compiler warnings of using getPeer().getTableMap().
    1229      *
    1230      * @return The associated TableMap object.
    1231      */
    1232     public TableMap getTableMap() throws TorqueException
    1233     {
    1234         return TurbineRolePeer.getTableMap();
    1235     }
    1236
    1237
    1238     public String toString()
    1239     {
    1240         StringBuffer str = new StringBuffer();
    1241         str.append("TurbineRole:\n");
    1242         str.append("RoleId = ")
    1243            .append(getRoleId())
    1244            .append("\n");
    1245         str.append("Name = ")
    1246            .append(getName())
    1247            .append("\n");
    1248         return(str.toString());
    1249     }
    1250 }