Coverage Report - org.apache.turbine.services.security.torque.om.BaseTurbineRole
 
Classes in this File Line Coverage Branch Coverage Complexity
BaseTurbineRole
0%
0/266
0%
0/154
2,979
 
 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  0
 public abstract class BaseTurbineRole extends BaseObject
 38  
 {
 39  
     /** Serial version */
 40  
     private static final long serialVersionUID = 1308842746584L;
 41  
 
 42  
     /** The Peer class */
 43  0
     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  0
         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  0
         if (this.roleId != v)
 74  
         {
 75  0
             this.roleId = v;
 76  0
             setModified(true);
 77  
         }
 78  
 
 79  
 
 80  
 
 81  
         // update associated TurbineRolePermission
 82  0
         if (collTurbineRolePermissions != null)
 83  
         {
 84  0
             for (int i = 0; i < collTurbineRolePermissions.size(); i++)
 85  
             {
 86  0
                 ((TurbineRolePermission) collTurbineRolePermissions.get(i))
 87  
                         .setRoleId(v);
 88  
             }
 89  
         }
 90  
 
 91  
         // update associated TurbineUserGroupRole
 92  0
         if (collTurbineUserGroupRoles != null)
 93  
         {
 94  0
             for (int i = 0; i < collTurbineUserGroupRoles.size(); i++)
 95  
             {
 96  0
                 ((TurbineUserGroupRole) collTurbineUserGroupRoles.get(i))
 97  
                         .setRoleId(v);
 98  
             }
 99  
         }
 100  0
     }
 101  
 
 102  
     /**
 103  
      * Get the Name
 104  
      *
 105  
      * @return String
 106  
      */
 107  
     public String getName()
 108  
     {
 109  0
         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  0
         if (!ObjectUtils.equals(this.name, v))
 122  
         {
 123  0
             this.name = v;
 124  0
             setModified(true);
 125  
         }
 126  
 
 127  
 
 128  0
     }
 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  0
         if (collTurbineRolePermissions == null)
 146  
         {
 147  0
             collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
 148  
         }
 149  0
     }
 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  0
         getTurbineRolePermissions().add(l);
 162  0
         l.setTurbineRole((TurbineRole) this);
 163  0
     }
 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  0
         getTurbineRolePermissions(con).add(l);
 175  0
         l.setTurbineRole((TurbineRole) this);
 176  0
     }
 177  
 
 178  
     /**
 179  
      * The criteria used to select the current contents of collTurbineRolePermissions
 180  
      */
 181  0
     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  0
         if (collTurbineRolePermissions == null)
 195  
         {
 196  0
             collTurbineRolePermissions = getTurbineRolePermissions(new Criteria(10));
 197  
         }
 198  0
         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  0
         if (collTurbineRolePermissions == null)
 215  
         {
 216  0
             if (isNew())
 217  
             {
 218  0
                collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
 219  
             }
 220  
             else
 221  
             {
 222  0
                 criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId() );
 223  0
                 collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria);
 224  
             }
 225  
         }
 226  
         else
 227  
         {
 228  
             // criteria has no effect for a new object
 229  0
             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  0
                 criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
 235  0
                 if (!lastTurbineRolePermissionsCriteria.equals(criteria))
 236  
                 {
 237  0
                     collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria);
 238  
                 }
 239  
             }
 240  
         }
 241  0
         lastTurbineRolePermissionsCriteria = criteria;
 242  
 
 243  0
         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  0
         if (collTurbineRolePermissions == null)
 257  
         {
 258  0
             collTurbineRolePermissions = getTurbineRolePermissions(new Criteria(10), con);
 259  
         }
 260  0
         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  0
         if (collTurbineRolePermissions == null)
 279  
         {
 280  0
             if (isNew())
 281  
             {
 282  0
                collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
 283  
             }
 284  
             else
 285  
             {
 286  0
                  criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
 287  0
                  collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria, con);
 288  
              }
 289  
          }
 290  
          else
 291  
          {
 292  
              // criteria has no effect for a new object
 293  0
              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  0
                  criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
 299  0
                  if (!lastTurbineRolePermissionsCriteria.equals(criteria))
 300  
                  {
 301  0
                      collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria, con);
 302  
                  }
 303  
              }
 304  
          }
 305  0
          lastTurbineRolePermissionsCriteria = criteria;
 306  
 
 307  0
          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  0
         if (collTurbineRolePermissions == null)
 335  
         {
 336  0
             if (isNew())
 337  
             {
 338  0
                collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
 339  
             }
 340  
             else
 341  
             {
 342  0
                 criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
 343  0
                 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  0
             criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
 352  0
             if (!lastTurbineRolePermissionsCriteria.equals(criteria))
 353  
             {
 354  0
                 collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbineRole(criteria);
 355  
             }
 356  
         }
 357  0
         lastTurbineRolePermissionsCriteria = criteria;
 358  
 
 359  0
         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  0
         if (collTurbineRolePermissions == null)
 385  
         {
 386  0
             if (isNew())
 387  
             {
 388  0
                collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
 389  
             }
 390  
             else
 391  
             {
 392  0
                 criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
 393  0
                 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  0
             criteria.add(TurbineRolePermissionPeer.ROLE_ID, getRoleId());
 402  0
             if (!lastTurbineRolePermissionsCriteria.equals(criteria))
 403  
             {
 404  0
                 collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbinePermission(criteria);
 405  
             }
 406  
         }
 407  0
         lastTurbineRolePermissionsCriteria = criteria;
 408  
 
 409  0
         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  0
         if (collTurbineUserGroupRoles == null)
 429  
         {
 430  0
             collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
 431  
         }
 432  0
     }
 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  0
         getTurbineUserGroupRoles().add(l);
 445  0
         l.setTurbineRole((TurbineRole) this);
 446  0
     }
 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  0
         getTurbineUserGroupRoles(con).add(l);
 458  0
         l.setTurbineRole((TurbineRole) this);
 459  0
     }
 460  
 
 461  
     /**
 462  
      * The criteria used to select the current contents of collTurbineUserGroupRoles
 463  
      */
 464  0
     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  0
         if (collTurbineUserGroupRoles == null)
 478  
         {
 479  0
             collTurbineUserGroupRoles = getTurbineUserGroupRoles(new Criteria(10));
 480  
         }
 481  0
         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  0
         if (collTurbineUserGroupRoles == null)
 498  
         {
 499  0
             if (isNew())
 500  
             {
 501  0
                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
 502  
             }
 503  
             else
 504  
             {
 505  0
                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId() );
 506  0
                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria);
 507  
             }
 508  
         }
 509  
         else
 510  
         {
 511  
             // criteria has no effect for a new object
 512  0
             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  0
                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
 518  0
                 if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
 519  
                 {
 520  0
                     collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria);
 521  
                 }
 522  
             }
 523  
         }
 524  0
         lastTurbineUserGroupRolesCriteria = criteria;
 525  
 
 526  0
         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  0
         if (collTurbineUserGroupRoles == null)
 540  
         {
 541  0
             collTurbineUserGroupRoles = getTurbineUserGroupRoles(new Criteria(10), con);
 542  
         }
 543  0
         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  0
         if (collTurbineUserGroupRoles == null)
 562  
         {
 563  0
             if (isNew())
 564  
             {
 565  0
                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
 566  
             }
 567  
             else
 568  
             {
 569  0
                  criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
 570  0
                  collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria, con);
 571  
              }
 572  
          }
 573  
          else
 574  
          {
 575  
              // criteria has no effect for a new object
 576  0
              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  0
                  criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
 582  0
                  if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
 583  
                  {
 584  0
                      collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria, con);
 585  
                  }
 586  
              }
 587  
          }
 588  0
          lastTurbineUserGroupRolesCriteria = criteria;
 589  
 
 590  0
          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  0
         if (collTurbineUserGroupRoles == null)
 618  
         {
 619  0
             if (isNew())
 620  
             {
 621  0
                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
 622  
             }
 623  
             else
 624  
             {
 625  0
                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
 626  0
                 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  0
             criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
 635  0
             if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
 636  
             {
 637  0
                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineUser(criteria);
 638  
             }
 639  
         }
 640  0
         lastTurbineUserGroupRolesCriteria = criteria;
 641  
 
 642  0
         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  0
         if (collTurbineUserGroupRoles == null)
 668  
         {
 669  0
             if (isNew())
 670  
             {
 671  0
                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
 672  
             }
 673  
             else
 674  
             {
 675  0
                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
 676  0
                 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  0
             criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
 685  0
             if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
 686  
             {
 687  0
                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineGroup(criteria);
 688  
             }
 689  
         }
 690  0
         lastTurbineUserGroupRolesCriteria = criteria;
 691  
 
 692  0
         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  0
         if (collTurbineUserGroupRoles == null)
 718  
         {
 719  0
             if (isNew())
 720  
             {
 721  0
                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
 722  
             }
 723  
             else
 724  
             {
 725  0
                 criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
 726  0
                 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  0
             criteria.add(TurbineUserGroupRolePeer.ROLE_ID, getRoleId());
 735  0
             if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
 736  
             {
 737  0
                 collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineRole(criteria);
 738  
             }
 739  
         }
 740  0
         lastTurbineUserGroupRolesCriteria = criteria;
 741  
 
 742  0
         return collTurbineUserGroupRoles;
 743  
     }
 744  
 
 745  
 
 746  
 
 747  
         
 748  0
     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  0
         if (fieldNames == null)
 758  
         {
 759  0
             fieldNames = new ArrayList<String>();
 760  0
             fieldNames.add("RoleId");
 761  0
             fieldNames.add("Name");
 762  0
             fieldNames = Collections.unmodifiableList(fieldNames);
 763  
         }
 764  0
         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  0
         if (name.equals("RoleId"))
 776  
         {
 777  0
             return new Integer(getRoleId());
 778  
         }
 779  0
         if (name.equals("Name"))
 780  
         {
 781  0
             return getName();
 782  
         }
 783  0
         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  0
         if (name.equals("RoleId"))
 799  
         {
 800  0
             if (value == null || ! (Integer.class.isInstance(value)))
 801  
             {
 802  0
                 throw new IllegalArgumentException("setByName: value parameter was null or not an Integer object.");
 803  
             }
 804  0
             setRoleId(((Integer) value).intValue());
 805  0
             return true;
 806  
         }
 807  0
         if (name.equals("Name"))
 808  
         {
 809  
             // Object fields can be null
 810  0
             if (value != null && ! String.class.isInstance(value))
 811  
             {
 812  0
                 throw new IllegalArgumentException("Invalid type of object specified for value in setByName");
 813  
             }
 814  0
             setName((String) value);
 815  0
             return true;
 816  
         }
 817  0
         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  0
         if (name.equals(TurbineRolePeer.ROLE_ID))
 831  
         {
 832  0
             return new Integer(getRoleId());
 833  
         }
 834  0
         if (name.equals(TurbineRolePeer.ROLE_NAME))
 835  
         {
 836  0
             return getName();
 837  
         }
 838  0
         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  0
       if (TurbineRolePeer.ROLE_ID.equals(name))
 854  
         {
 855  0
             return setByName("RoleId", value);
 856  
         }
 857  0
       if (TurbineRolePeer.ROLE_NAME.equals(name))
 858  
         {
 859  0
             return setByName("Name", value);
 860  
         }
 861  0
         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  0
         if (pos == 0)
 874  
         {
 875  0
             return new Integer(getRoleId());
 876  
         }
 877  0
         if (pos == 1)
 878  
         {
 879  0
             return getName();
 880  
         }
 881  0
         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  0
     if (position == 0)
 897  
         {
 898  0
             return setByName("RoleId", value);
 899  
         }
 900  0
     if (position == 1)
 901  
         {
 902  0
             return setByName("Name", value);
 903  
         }
 904  0
         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  0
         save(TurbineRolePeer.DATABASE_NAME);
 916  0
     }
 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  0
         Connection con = null;
 931  
         try
 932  
         {
 933  0
             con = Transaction.begin(dbName);
 934  0
             save(con);
 935  0
             Transaction.commit(con);
 936  
         }
 937  0
         catch(TorqueException e)
 938  
         {
 939  0
             Transaction.safeRollback(con);
 940  0
             throw e;
 941  0
         }
 942  0
     }
 943  
 
 944  
     /** flag to prevent endless save loop, if this object is referenced
 945  
         by another object which falls in this transaction. */
 946  0
     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  0
         if (!alreadyInSave)
 960  
         {
 961  0
             alreadyInSave = true;
 962  
 
 963  
 
 964  
 
 965  
             // If this object has been modified, then save it to the database.
 966  0
             if (isModified())
 967  
             {
 968  0
                 if (isNew())
 969  
                 {
 970  0
                     TurbineRolePeer.doInsert((TurbineRole) this, con);
 971  0
                     setNew(false);
 972  
                 }
 973  
                 else
 974  
                 {
 975  0
                     TurbineRolePeer.doUpdate((TurbineRole) this, con);
 976  
                 }
 977  
             }
 978  
 
 979  
 
 980  0
             if (collTurbineRolePermissions != null)
 981  
             {
 982  0
                 for (int i = 0; i < collTurbineRolePermissions.size(); i++)
 983  
                 {
 984  0
                     ((TurbineRolePermission) collTurbineRolePermissions.get(i)).save(con);
 985  
                 }
 986  
             }
 987  
 
 988  0
             if (collTurbineUserGroupRoles != null)
 989  
             {
 990  0
                 for (int i = 0; i < collTurbineUserGroupRoles.size(); i++)
 991  
                 {
 992  0
                     ((TurbineUserGroupRole) collTurbineUserGroupRoles.get(i)).save(con);
 993  
                 }
 994  
             }
 995  0
             alreadyInSave = false;
 996  
         }
 997  0
     }
 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  0
         setRoleId(((NumberKey) key).intValue());
 1009  0
     }
 1010  
 
 1011  
     /**
 1012  
      * Set the PrimaryKey using a String.
 1013  
      *
 1014  
      * @param key
 1015  
      */
 1016  
     public void setPrimaryKey(String key) throws TorqueException
 1017  
     {
 1018  0
         setRoleId(Integer.parseInt(key));
 1019  0
     }
 1020  
 
 1021  
 
 1022  
     /**
 1023  
      * returns an id that differentiates this object from others
 1024  
      * of its class.
 1025  
      */
 1026  
     public ObjectKey getPrimaryKey()
 1027  
     {
 1028  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         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  0
         copyObj.setRoleId(roleId);
 1120  0
         copyObj.setName(name);
 1121  
 
 1122  0
         copyObj.setRoleId( 0);
 1123  
 
 1124  0
         if (deepcopy)
 1125  
         {
 1126  
 
 1127  
 
 1128  0
         List<TurbineRolePermission> vTurbineRolePermissions = getTurbineRolePermissions();
 1129  0
         if (vTurbineRolePermissions != null)
 1130  
         {
 1131  0
             for (int i = 0; i < vTurbineRolePermissions.size(); i++)
 1132  
             {
 1133  0
                 TurbineRolePermission obj =  vTurbineRolePermissions.get(i);
 1134  0
                 copyObj.addTurbineRolePermission(obj.copy());
 1135  
             }
 1136  
         }
 1137  
         else
 1138  
         {
 1139  0
             copyObj.collTurbineRolePermissions = null;
 1140  
         }
 1141  
 
 1142  
 
 1143  0
         List<TurbineUserGroupRole> vTurbineUserGroupRoles = getTurbineUserGroupRoles();
 1144  0
         if (vTurbineUserGroupRoles != null)
 1145  
         {
 1146  0
             for (int i = 0; i < vTurbineUserGroupRoles.size(); i++)
 1147  
             {
 1148  0
                 TurbineUserGroupRole obj =  vTurbineUserGroupRoles.get(i);
 1149  0
                 copyObj.addTurbineUserGroupRole(obj.copy());
 1150  
             }
 1151  
         }
 1152  
         else
 1153  
         {
 1154  0
             copyObj.collTurbineUserGroupRoles = null;
 1155  
         }
 1156  
         }
 1157  0
         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  0
         copyObj.setRoleId(roleId);
 1173  0
         copyObj.setName(name);
 1174  
 
 1175  0
         copyObj.setRoleId( 0);
 1176  
 
 1177  0
         if (deepcopy)
 1178  
         {
 1179  
 
 1180  
 
 1181  0
         List<TurbineRolePermission> vTurbineRolePermissions = getTurbineRolePermissions(con);
 1182  0
         if (vTurbineRolePermissions != null)
 1183  
         {
 1184  0
             for (int i = 0; i < vTurbineRolePermissions.size(); i++)
 1185  
             {
 1186  0
                 TurbineRolePermission obj =  vTurbineRolePermissions.get(i);
 1187  0
                 copyObj.addTurbineRolePermission(obj.copy(con), con);
 1188  
             }
 1189  
         }
 1190  
         else
 1191  
         {
 1192  0
             copyObj.collTurbineRolePermissions = null;
 1193  
         }
 1194  
 
 1195  
 
 1196  0
         List<TurbineUserGroupRole> vTurbineUserGroupRoles = getTurbineUserGroupRoles(con);
 1197  0
         if (vTurbineUserGroupRoles != null)
 1198  
         {
 1199  0
             for (int i = 0; i < vTurbineUserGroupRoles.size(); i++)
 1200  
             {
 1201  0
                 TurbineUserGroupRole obj =  vTurbineUserGroupRoles.get(i);
 1202  0
                 copyObj.addTurbineUserGroupRole(obj.copy(con), con);
 1203  
             }
 1204  
         }
 1205  
         else
 1206  
         {
 1207  0
             copyObj.collTurbineUserGroupRoles = null;
 1208  
         }
 1209  
         }
 1210  0
         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  0
         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  0
         return TurbineRolePeer.getTableMap();
 1235  
     }
 1236  
 
 1237  
 
 1238  
     public String toString()
 1239  
     {
 1240  0
         StringBuffer str = new StringBuffer();
 1241  0
         str.append("TurbineRole:\n");
 1242  0
         str.append("RoleId = ")
 1243  
            .append(getRoleId())
 1244  
            .append("\n");
 1245  0
         str.append("Name = ")
 1246  
            .append(getName())
 1247  
            .append("\n");
 1248  0
         return(str.toString());
 1249  
     }
 1250  
 }