001 package org.apache.turbine.services.security.torque.om; 002 003 004 import java.math.BigDecimal; 005 import java.sql.Connection; 006 import java.util.ArrayList; 007 import java.util.Collections; 008 import java.util.Date; 009 import java.util.List; 010 011 import org.apache.commons.lang.ObjectUtils; 012 import org.apache.torque.TorqueException; 013 import org.apache.torque.map.TableMap; 014 import org.apache.torque.om.BaseObject; 015 import org.apache.torque.om.ComboKey; 016 import org.apache.torque.om.DateKey; 017 import org.apache.torque.om.NumberKey; 018 import org.apache.torque.om.ObjectKey; 019 import org.apache.torque.om.SimpleKey; 020 import org.apache.torque.om.StringKey; 021 import org.apache.torque.om.Persistent; 022 import org.apache.torque.util.Criteria; 023 import org.apache.torque.util.Transaction; 024 025 026 027 028 029 /** 030 * This class was autogenerated by Torque on: 031 * 032 * [Thu Jun 23 17:25:46 CEST 2011] 033 * 034 * You should not use this class directly. It should not even be 035 * extended all references should be to TurbineRole 036 */ 037 public abstract class BaseTurbineRole extends BaseObject 038 { 039 /** Serial version */ 040 private static final long serialVersionUID = 1308842746584L; 041 042 /** The Peer class */ 043 private static final TurbineRolePeer peer = 044 new TurbineRolePeer(); 045 046 047 /** The value for the roleId field */ 048 private int roleId; 049 050 /** The value for the name field */ 051 private String name; 052 053 054 /** 055 * Get the RoleId 056 * 057 * @return int 058 */ 059 public int getRoleId() 060 { 061 return roleId; 062 } 063 064 065 /** 066 * Set the value of RoleId 067 * 068 * @param v new value 069 */ 070 public void setRoleId(int v) throws TorqueException 071 { 072 073 if (this.roleId != v) 074 { 075 this.roleId = v; 076 setModified(true); 077 } 078 079 080 081 // update associated TurbineRolePermission 082 if (collTurbineRolePermissions != null) 083 { 084 for (int i = 0; i < collTurbineRolePermissions.size(); i++) 085 { 086 ((TurbineRolePermission) collTurbineRolePermissions.get(i)) 087 .setRoleId(v); 088 } 089 } 090 091 // update associated TurbineUserGroupRole 092 if (collTurbineUserGroupRoles != null) 093 { 094 for (int i = 0; i < collTurbineUserGroupRoles.size(); i++) 095 { 096 ((TurbineUserGroupRole) collTurbineUserGroupRoles.get(i)) 097 .setRoleId(v); 098 } 099 } 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 }