    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 TurbineGroup
    036     */
    037    public abstract class BaseTurbineGroup extends BaseObject
    038    {
    039        /** Serial version */
    040        private static final long serialVersionUID = 1308842746584L;
    041
    042        /** The Peer class */
    043        private static final TurbineGroupPeer peer =
    044            new TurbineGroupPeer();
    045
    046
    047        /** The value for the groupId field */
    048        private int groupId;
    049
    050        /** The value for the name field */
    051        private String name;
    052
    053
    054        /**
    055         * Get the GroupId
    056         *
    057         * @return int
    058         */
    059        public int getGroupId()
    060        {
    061            return groupId;
    062        }
    063
    064
    065        /**
    066         * Set the value of GroupId
    067         *
    068         * @param v new value
    069         */
    070        public void setGroupId(int v) throws TorqueException
    071        {
    072
    073            if (this.groupId != v)
    074            {
    075                this.groupId = v;
    076                setModified(true);
    077            }
    078
    079
    080
    081            // update associated TurbineUserGroupRole
    082            if (collTurbineUserGroupRoles != null)
    083            {
    084                for (int i = 0; i < collTurbineUserGroupRoles.size(); i++)
    085                {
    086                    ((TurbineUserGroupRole) collTurbineUserGroupRoles.get(i))
    087                            .setGroupId(v);
    088                }
    089            }
    090        }
    091
    092        /**
    093         * Get the Name
    094         *
    095         * @return String
    096         */
    097        public String getName()
    098        {
    099            return name;
    100        }
    101
    102
    103        /**
    104         * Set the value of Name
    105         *
    106         * @param v new value
    107         */
    108        public void setName(String v)
    109        {
    110
    111            if (!ObjectUtils.equals(this.name, v))
    112            {
    113                this.name = v;
    114                setModified(true);
    115            }
    116
    117
    118        }
    119
    120
    121
    122
    123        /**
    124         * Collection to store aggregation of collTurbineUserGroupRoles
    125         */
    126        protected List<TurbineUserGroupRole> collTurbineUserGroupRoles;
    127
    128        /**
    129         * Temporary storage of collTurbineUserGroupRoles to save a possible db hit in
    130         * the event objects are add to the collection, but the
    131         * complete collection is never requested.
    132         */
    133        protected void initTurbineUserGroupRoles()
    134        {
    135            if (collTurbineUserGroupRoles == null)
    136            {
    137                collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    138            }
    139        }
    140
    141
    142        /**
    143         * Method called to associate a TurbineUserGroupRole object to this object
    144         * through the TurbineUserGroupRole foreign key attribute
    145         *
    146         * @param l TurbineUserGroupRole
    147         * @throws TorqueException
    148         */
    149        public void addTurbineUserGroupRole(TurbineUserGroupRole l) throws TorqueException
    150        {
    151            getTurbineUserGroupRoles().add(l);
    152            l.setTurbineGroup((TurbineGroup) this);
    153        }
    154
    155        /**
    156         * Method called to associate a TurbineUserGroupRole object to this object
    157         * through the TurbineUserGroupRole foreign key attribute using connection.
    158         *
    159         * @param l TurbineUserGroupRole
    160         * @throws TorqueException
    161         */
    162        public void addTurbineUserGroupRole(TurbineUserGroupRole l, Connection con) throws TorqueException
    163        {
    164            getTurbineUserGroupRoles(con).add(l);
    165            l.setTurbineGroup((TurbineGroup) this);
    166        }
    167
    168        /**
    169         * The criteria used to select the current contents of collTurbineUserGroupRoles
    170         */
    171        private Criteria lastTurbineUserGroupRolesCriteria = null;
    172
    173        /**
    174         * If this collection has already been initialized, returns
    175         * the collection. Otherwise returns the results of
    176         * getTurbineUserGroupRoles(new Criteria())
    177         *
    178         * @return the collection of associated objects
    179         * @throws TorqueException
    180         */
    181        public List<TurbineUserGroupRole> getTurbineUserGroupRoles()
    182            throws TorqueException
    183        {
    184            if (collTurbineUserGroupRoles == null)
    185            {
    186                collTurbineUserGroupRoles = getTurbineUserGroupRoles(new Criteria(10));
    187            }
    188            return collTurbineUserGroupRoles;
    189        }
    190
    191        /**
    192         * If this collection has already been initialized with
    193         * an identical criteria, it returns the collection.
    194         * Otherwise if this TurbineGroup has previously
    195         * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    196         * If this TurbineGroup is new, it will return
    197         * an empty collection or the current collection, the criteria
    198         * is ignored on a new object.
    199         *
    200         * @throws TorqueException
    201         */
    202        public List<TurbineUserGroupRole> getTurbineUserGroupRoles(Criteria criteria) throws TorqueException
    203        {
    204            if (collTurbineUserGroupRoles == null)
    205            {
    206                if (isNew())
    207                {
    208                   collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    209                }
    210                else
    211                {
    212                    criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId() );
    213                    collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria);
    214                }
    215            }
    216            else
    217            {
    218                // criteria has no effect for a new object
    219                if (!isNew())
    220                {
    221                    // the following code is to determine if a new query is
    222                    // called for.  If the criteria is the same as the last
    223                    // one, just return the collection.
    224                    criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId());
    225                    if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    226                    {
    227                        collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria);
    228                    }
    229                }
    230            }
    231            lastTurbineUserGroupRolesCriteria = criteria;
    232
    233            return collTurbineUserGroupRoles;
    234        }
    235
    236        /**
    237         * If this collection has already been initialized, returns
    238         * the collection. Otherwise returns the results of
    239         * getTurbineUserGroupRoles(new Criteria(),Connection)
    240         * This method takes in the Connection also as input so that
    241         * referenced objects can also be obtained using a Connection
    242         * that is taken as input
    243         */
    244        public List<TurbineUserGroupRole> getTurbineUserGroupRoles(Connection con) throws TorqueException
    245        {
    246            if (collTurbineUserGroupRoles == null)
    247            {
    248                collTurbineUserGroupRoles = getTurbineUserGroupRoles(new Criteria(10), con);
    249            }
    250            return collTurbineUserGroupRoles;
    251        }
    252
    253        /**
    254         * If this collection has already been initialized with
    255         * an identical criteria, it returns the collection.
    256         * Otherwise if this TurbineGroup has previously
    257         * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    258         * If this TurbineGroup is new, it will return
    259         * an empty collection or the current collection, the criteria
    260         * is ignored on a new object.
    261         * This method takes in the Connection also as input so that
    262         * referenced objects can also be obtained using a Connection
    263         * that is taken as input
    264         */
    265        public List<TurbineUserGroupRole> getTurbineUserGroupRoles(Criteria criteria, Connection con)
    266                throws TorqueException
    267        {
    268            if (collTurbineUserGroupRoles == null)
    269            {
    270                if (isNew())
    271                {
    272                   collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    273                }
    274                else
    275                {
    276                     criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId());
    277                     collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria, con);
    278                 }
    279             }
    280             else
    281             {
    282                 // criteria has no effect for a new object
    283                 if (!isNew())
    284                 {
    285                     // the following code is to determine if a new query is
    286                     // called for.  If the criteria is the same as the last
    287                     // one, just return the collection.
    288                     criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId());
    289                     if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    290                     {
    291                         collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelect(criteria, con);
    292                     }
    293                 }
    294             }
    295             lastTurbineUserGroupRolesCriteria = criteria;
    296
    297             return collTurbineUserGroupRoles;
    298         }
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310        /**
    311         * If this collection has already been initialized with
    312         * an identical criteria, it returns the collection.
    313         * Otherwise if this TurbineGroup is new, it will return
    314         * an empty collection; or if this TurbineGroup has previously
    315         * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    316         *
    317         * This method is protected by default in order to keep the public
    318         * api reasonable.  You can provide public methods for those you
    319         * actually need in TurbineGroup.
    320         */
    321        protected List<TurbineUserGroupRole> getTurbineUserGroupRolesJoinTurbineUser(Criteria criteria)
    322            throws TorqueException
    323        {
    324            if (collTurbineUserGroupRoles == null)
    325            {
    326                if (isNew())
    327                {
    328                   collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    329                }
    330                else
    331                {
    332                    criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId());
    333                    collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineUser(criteria);
    334                }
    335            }
    336            else
    337            {
    338                // the following code is to determine if a new query is
    339                // called for.  If the criteria is the same as the last
    340                // one, just return the collection.
    341                criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId());
    342                if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    343                {
    344                    collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineUser(criteria);
    345                }
    346            }
    347            lastTurbineUserGroupRolesCriteria = criteria;
    348
    349            return collTurbineUserGroupRoles;
    350        }
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360        /**
    361         * If this collection has already been initialized with
    362         * an identical criteria, it returns the collection.
    363         * Otherwise if this TurbineGroup is new, it will return
    364         * an empty collection; or if this TurbineGroup has previously
    365         * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    366         *
    367         * This method is protected by default in order to keep the public
    368         * api reasonable.  You can provide public methods for those you
    369         * actually need in TurbineGroup.
    370         */
    371        protected List<TurbineUserGroupRole> getTurbineUserGroupRolesJoinTurbineGroup(Criteria criteria)
    372            throws TorqueException
    373        {
    374            if (collTurbineUserGroupRoles == null)
    375            {
    376                if (isNew())
    377                {
    378                   collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    379                }
    380                else
    381                {
    382                    criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId());
    383                    collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineGroup(criteria);
    384                }
    385            }
    386            else
    387            {
    388                // the following code is to determine if a new query is
    389                // called for.  If the criteria is the same as the last
    390                // one, just return the collection.
    391                criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId());
    392                if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    393                {
    394                    collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineGroup(criteria);
    395                }
    396            }
    397            lastTurbineUserGroupRolesCriteria = criteria;
    398
    399            return collTurbineUserGroupRoles;
    400        }
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410        /**
    411         * If this collection has already been initialized with
    412         * an identical criteria, it returns the collection.
    413         * Otherwise if this TurbineGroup is new, it will return
    414         * an empty collection; or if this TurbineGroup has previously
    415         * been saved, it will retrieve related TurbineUserGroupRoles from storage.
    416         *
    417         * This method is protected by default in order to keep the public
    418         * api reasonable.  You can provide public methods for those you
    419         * actually need in TurbineGroup.
    420         */
    421        protected List<TurbineUserGroupRole> getTurbineUserGroupRolesJoinTurbineRole(Criteria criteria)
    422            throws TorqueException
    423        {
    424            if (collTurbineUserGroupRoles == null)
    425            {
    426                if (isNew())
    427                {
    428                   collTurbineUserGroupRoles = new ArrayList<TurbineUserGroupRole>();
    429                }
    430                else
    431                {
    432                    criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId());
    433                    collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineRole(criteria);
    434                }
    435            }
    436            else
    437            {
    438                // the following code is to determine if a new query is
    439                // called for.  If the criteria is the same as the last
    440                // one, just return the collection.
    441                criteria.add(TurbineUserGroupRolePeer.GROUP_ID, getGroupId());
    442                if (!lastTurbineUserGroupRolesCriteria.equals(criteria))
    443                {
    444                    collTurbineUserGroupRoles = TurbineUserGroupRolePeer.doSelectJoinTurbineRole(criteria);
    445                }
    446            }
    447            lastTurbineUserGroupRolesCriteria = criteria;
    448
    449            return collTurbineUserGroupRoles;
    450        }
    451
    452
    453
    454
    455        private static List<String> fieldNames = null;
    456
    457        /**
    458         * Generate a list of field names.
    459         *
    460         * @return a list of field names
    461         */
    462        public static synchronized List<String> getFieldNames()
    463        {
    464            if (fieldNames == null)
    465            {
    466                fieldNames = new ArrayList<String>();
    467                fieldNames.add("GroupId");
    468                fieldNames.add("Name");
    469                fieldNames = Collections.unmodifiableList(fieldNames);
    470            }
    471            return fieldNames;
    472        }
    473
    474        /**
    475         * Retrieves a field from the object by field (Java) name passed in as a String.
    476         *
    477         * @param name field name
    478         * @return value
    479         */
    480        public Object getByName(String name)
    481        {
    482            if (name.equals("GroupId"))
    483            {
    484                return new Integer(getGroupId());
    485            }
    486            if (name.equals("Name"))
    487            {
    488                return getName();
    489            }
    490            return null;
    491        }
    492
    493        /**
    494         * Set a field in the object by field (Java) name.
    495         *
    496         * @param name field name
    497         * @param value field value
    498         * @return True if value was set, false if not (invalid name / protected field).
    499         * @throws IllegalArgumentException if object type of value does not match field object type.
    500         * @throws TorqueException If a problem occurs with the set[Field] method.
    501         */
    502        public boolean setByName(String name, Object value )
    503            throws TorqueException, IllegalArgumentException
    504        {
    505            if (name.equals("GroupId"))
    506            {
    507                if (value == null || ! (Integer.class.isInstance(value)))
    508                {
    509                    throw new IllegalArgumentException("setByName: value parameter was null or not an Integer object.");
    510                }
    511                setGroupId(((Integer) value).intValue());
    512                return true;
    513            }
    514            if (name.equals("Name"))
    515            {
    516                // Object fields can be null
    517                if (value != null && ! String.class.isInstance(value))
    518                {
    519                    throw new IllegalArgumentException("Invalid type of object specified for value in setByName");
    520                }
    521                setName((String) value);
    522                return true;
    523            }
    524            return false;
    525        }
    526
    527        /**
    528         * Retrieves a field from the object by name passed in
    529         * as a String.  The String must be one of the static
    530         * Strings defined in this Class' Peer.
    531         *
    532         * @param name peer name
    533         * @return value
    534         */
    535        public Object getByPeerName(String name)
    536        {
    537            if (name.equals(TurbineGroupPeer.GROUP_ID))
    538            {
    539                return new Integer(getGroupId());
    540            }
    541            if (name.equals(TurbineGroupPeer.GROUP_NAME))
    542            {
    543                return getName();
    544            }
    545            return null;
    546        }
    547
    548        /**
    549         * Set field values by Peer Field Name
    550         *
    551         * @param name field name
    552         * @param value field value
    553         * @return True if value was set, false if not (invalid name / protected field).
    554         * @throws IllegalArgumentException if object type of value does not match field object type.
    555         * @throws TorqueException If a problem occurs with the set[Field] method.
    556         */
    557        public boolean setByPeerName(String name, Object value)
    558            throws TorqueException, IllegalArgumentException
    559        {
    560          if (TurbineGroupPeer.GROUP_ID.equals(name))
    561            {
    562                return setByName("GroupId", value);
    563            }
    564          if (TurbineGroupPeer.GROUP_NAME.equals(name))
    565            {
    566                return setByName("Name", value);
    567            }
    568            return false;
    569        }
    570
    571        /**
    572         * Retrieves a field from the object by Position as specified
    573         * in the xml schema.  Zero-based.
    574         *
    575         * @param pos position in xml schema
    576         * @return value
    577         */
    578        public Object getByPosition(int pos)
    579        {
    580            if (pos == 0)
    581            {
    582                return new Integer(getGroupId());
    583            }
    584            if (pos == 1)
    585            {
    586                return getName();
    587            }
    588            return null;
    589        }
    590
    591        /**
    592         * Set field values by its position (zero based) in the XML schema.
    593         *
    594         * @param position The field position
    595         * @param value field value
    596         * @return True if value was set, false if not (invalid position / protected field).
    597         * @throws IllegalArgumentException if object type of value does not match field object type.
    598         * @throws TorqueException If a problem occurs with the set[Field] method.
    599         */
    600        public boolean setByPosition(int position, Object value)
    601            throws TorqueException, IllegalArgumentException
    602        {
    603        if (position == 0)
    604            {
    605                return setByName("GroupId", value);
    606            }
    607        if (position == 1)
    608            {
    609                return setByName("Name", value);
    610            }
    611            return false;
    612        }
    613
    614        /**
    615         * Stores the object in the database.  If the object is new,
    616         * it inserts it; otherwise an update is performed.
    617         *
    618         * @throws Exception
    619         */
    620        public void save() throws Exception
    621        {
    622            save(TurbineGroupPeer.DATABASE_NAME);
    623        }
    624
    625        /**
    626         * Stores the object in the database.  If the object is new,
    627         * it inserts it; otherwise an update is performed.
    628         * Note: this code is here because the method body is
    629         * auto-generated conditionally and therefore needs to be
    630         * in this file instead of in the super class, BaseObject.
    631         *
    632         * @param dbName
    633         * @throws TorqueException
    634         */
    635        public void save(String dbName) throws TorqueException
    636        {
    637            Connection con = null;
    638            try
    639            {
    640                con = Transaction.begin(dbName);
    641                save(con);
    642                Transaction.commit(con);
    643            }
    644            catch(TorqueException e)
    645            {
    646                Transaction.safeRollback(con);
    647                throw e;
    648            }
    649        }
    650
    651        /** flag to prevent endless save loop, if this object is referenced
    652            by another object which falls in this transaction. */
    653        private boolean alreadyInSave = false;
    654        /**
    655         * Stores the object in the database.  If the object is new,
    656         * it inserts it; otherwise an update is performed.  This method
    657         * is meant to be used as part of a transaction, otherwise use
    658         * the save() method and the connection details will be handled
    659         * internally
    660         *
    661         * @param con
    662         * @throws TorqueException
    663         */
    664        public void save(Connection con) throws TorqueException
    665        {
    666            if (!alreadyInSave)
    667            {
    668                alreadyInSave = true;
    669
    670
    671
    672                // If this object has been modified, then save it to the database.
    673                if (isModified())
    674                {
    675                    if (isNew())
    676                    {
    677                        TurbineGroupPeer.doInsert((TurbineGroup) this, con);
    678                        setNew(false);
    679                    }
    680                    else
    681                    {
    682                        TurbineGroupPeer.doUpdate((TurbineGroup) this, con);
    683                    }
    684                }
    685
    686
    687                if (collTurbineUserGroupRoles != null)
    688                {
    689                    for (int i = 0; i < collTurbineUserGroupRoles.size(); i++)
    690                    {
    691                        ((TurbineUserGroupRole) collTurbineUserGroupRoles.get(i)).save(con);
    692                    }
    693                }
    694                alreadyInSave = false;
    695            }
    696        }
    697
    698
    699        /**
    700         * Set the PrimaryKey using ObjectKey.
    701         *
    702         * @param key groupId ObjectKey
    703         */
    704        public void setPrimaryKey(ObjectKey key)
    705            throws TorqueException
    706        {
    707            setGroupId(((NumberKey) key).intValue());
    708        }
    709
    710        /**
    711         * Set the PrimaryKey using a String.
    712         *
    713         * @param key
    714         */
    715        public void setPrimaryKey(String key) throws TorqueException
    716        {
    717            setGroupId(Integer.parseInt(key));
    718        }
    719
    720
    721        /**
    722         * returns an id that differentiates this object from others
    723         * of its class.
    724         */
    725        public ObjectKey getPrimaryKey()
    726        {
    727            return SimpleKey.keyFor(getGroupId());
    728        }
    729
    730
    731        /**
    732         * Makes a copy of this object.
    733         * It creates a new object filling in the simple attributes.
    734         * It then fills all the association collections and sets the
    735         * related objects to isNew=true.
    736         */
    737        public TurbineGroup copy() throws TorqueException
    738        {
    739            return copy(true);
    740        }
    741
    742        /**
    743         * Makes a copy of this object using connection.
    744         * It creates a new object filling in the simple attributes.
    745         * It then fills all the association collections and sets the
    746         * related objects to isNew=true.
    747         *
    748         * @param con the database connection to read associated objects.
    749         */
    750        public TurbineGroup copy(Connection con) throws TorqueException
    751        {
    752            return copy(true, con);
    753        }
    754
    755        /**
    756         * Makes a copy of this object.
    757         * It creates a new object filling in the simple attributes.
    758         * If the parameter deepcopy is true, it then fills all the
    759         * association collections and sets the related objects to
    760         * isNew=true.
    761         *
    762         * @param deepcopy whether to copy the associated objects.
    763         */
    764        public TurbineGroup copy(boolean deepcopy) throws TorqueException
    765        {
    766            return copyInto(new TurbineGroup(), deepcopy);
    767        }
    768
    769        /**
    770         * Makes a copy of this object using connection.
    771         * It creates a new object filling in the simple attributes.
    772         * If the parameter deepcopy is true, it then fills all the
    773         * association collections and sets the related objects to
    774         * isNew=true.
    775         *
    776         * @param deepcopy whether to copy the associated objects.
    777         * @param con the database connection to read associated objects.
    778         */
    779        public TurbineGroup copy(boolean deepcopy, Connection con) throws TorqueException
    780        {
    781            return copyInto(new TurbineGroup(), deepcopy, con);
    782        }
    783
    784        /**
    785         * Fills the copyObj with the contents of this object.
    786         * The associated objects are also copied and treated as new objects.
    787         *
    788         * @param copyObj the object to fill.
    789         */
    790        protected TurbineGroup copyInto(TurbineGroup copyObj) throws TorqueException
    791        {
    792            return copyInto(copyObj, true);
    793        }
    794
    795
    796        /**
    797         * Fills the copyObj with the contents of this object using connection.
    798         * The associated objects are also copied and treated as new objects.
    799         *
    800         * @param copyObj the object to fill.
    801         * @param con the database connection to read associated objects.
    802         */
    803        protected TurbineGroup copyInto(TurbineGroup copyObj, Connection con) throws TorqueException
    804        {
    805            return copyInto(copyObj, true, con);
    806        }
    807
    808        /**
    809         * Fills the copyObj with the contents of this object.
    810         * If deepcopy is true, The associated objects are also copied
    811         * and treated as new objects.
    812         *
    813         * @param copyObj the object to fill.
    814         * @param deepcopy whether the associated objects should be copied.
    815         */
    816        protected TurbineGroup copyInto(TurbineGroup copyObj, boolean deepcopy) throws TorqueException
    817        {
    818            copyObj.setGroupId(groupId);
    819            copyObj.setName(name);
    820
    821            copyObj.setGroupId( 0);
    822
    823            if (deepcopy)
    824            {
    825
    826
    827            List<TurbineUserGroupRole> vTurbineUserGroupRoles = getTurbineUserGroupRoles();
    828            if (vTurbineUserGroupRoles != null)
    829            {
    830                for (int i = 0; i < vTurbineUserGroupRoles.size(); i++)
    831                {
    832                    TurbineUserGroupRole obj =  vTurbineUserGroupRoles.get(i);
    833                    copyObj.addTurbineUserGroupRole(obj.copy());
    834                }
    835            }
    836            else
    837            {
    838                copyObj.collTurbineUserGroupRoles = null;
    839            }
    840            }
    841            return copyObj;
    842        }
    843
    844
    845        /**
    846         * Fills the copyObj with the contents of this object using connection.
    847         * If deepcopy is true, The associated objects are also copied
    848         * and treated as new objects.
    849         *
    850         * @param copyObj the object to fill.
    851         * @param deepcopy whether the associated objects should be copied.
    852         * @param con the database connection to read associated objects.
    853         */
    854        protected TurbineGroup copyInto(TurbineGroup copyObj, boolean deepcopy, Connection con) throws TorqueException
    855        {
    856            copyObj.setGroupId(groupId);
    857            copyObj.setName(name);
    858
    859            copyObj.setGroupId( 0);
    860
    861            if (deepcopy)
    862            {
    863
    864
    865            List<TurbineUserGroupRole> vTurbineUserGroupRoles = getTurbineUserGroupRoles(con);
    866            if (vTurbineUserGroupRoles != null)
    867            {
    868                for (int i = 0; i < vTurbineUserGroupRoles.size(); i++)
    869                {
    870                    TurbineUserGroupRole obj =  vTurbineUserGroupRoles.get(i);
    871                    copyObj.addTurbineUserGroupRole(obj.copy(con), con);
    872                }
    873            }
    874            else
    875            {
    876                copyObj.collTurbineUserGroupRoles = null;
    877            }
    878            }
    879            return copyObj;
    880        }
    881
    882
    883
    884        /**
    885         * returns a peer instance associated with this om.  Since Peer classes
    886         * are not to have any instance attributes, this method returns the
    887         * same instance for all member of this class. The method could therefore
    888         * be static, but this would prevent one from overriding the behavior.
    889         */
    890        public TurbineGroupPeer getPeer()
    891        {
    892            return peer;
    893        }
    894
    895        /**
    896         * Retrieves the TableMap object related to this Table data without
    897         * compiler warnings of using getPeer().getTableMap().
    898         *
    899         * @return The associated TableMap object.
    900         */
    901        public TableMap getTableMap() throws TorqueException
    902        {
    903            return TurbineGroupPeer.getTableMap();
    904        }
    905
    906
    907        public String toString()
    908        {
    909            StringBuffer str = new StringBuffer();
    910            str.append("TurbineGroup:\n");
    911            str.append("GroupId = ")
    912               .append(getGroupId())
    913               .append("\n");
    914            str.append("Name = ")
    915               .append(getName())
    916               .append("\n");
    917            return(str.toString());
    918        }
    919    }