    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 TurbinePermission
    036     */
    037    public abstract class BaseTurbinePermission extends BaseObject
    038    {
    039        /** Serial version */
    040        private static final long serialVersionUID = 1308842746584L;
    041
    042        /** The Peer class */
    043        private static final TurbinePermissionPeer peer =
    044            new TurbinePermissionPeer();
    045
    046
    047        /** The value for the permissionId field */
    048        private int permissionId;
    049
    050        /** The value for the name field */
    051        private String name;
    052
    053
    054        /**
    055         * Get the PermissionId
    056         *
    057         * @return int
    058         */
    059        public int getPermissionId()
    060        {
    061            return permissionId;
    062        }
    063
    064
    065        /**
    066         * Set the value of PermissionId
    067         *
    068         * @param v new value
    069         */
    070        public void setPermissionId(int v) throws TorqueException
    071        {
    072
    073            if (this.permissionId != v)
    074            {
    075                this.permissionId = 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                            .setPermissionId(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 collTurbineRolePermissions
    125         */
    126        protected List<TurbineRolePermission> collTurbineRolePermissions;
    127
    128        /**
    129         * Temporary storage of collTurbineRolePermissions 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 initTurbineRolePermissions()
    134        {
    135            if (collTurbineRolePermissions == null)
    136            {
    137                collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    138            }
    139        }
    140
    141
    142        /**
    143         * Method called to associate a TurbineRolePermission object to this object
    144         * through the TurbineRolePermission foreign key attribute
    145         *
    146         * @param l TurbineRolePermission
    147         * @throws TorqueException
    148         */
    149        public void addTurbineRolePermission(TurbineRolePermission l) throws TorqueException
    150        {
    151            getTurbineRolePermissions().add(l);
    152            l.setTurbinePermission((TurbinePermission) this);
    153        }
    154
    155        /**
    156         * Method called to associate a TurbineRolePermission object to this object
    157         * through the TurbineRolePermission foreign key attribute using connection.
    158         *
    159         * @param l TurbineRolePermission
    160         * @throws TorqueException
    161         */
    162        public void addTurbineRolePermission(TurbineRolePermission l, Connection con) throws TorqueException
    163        {
    164            getTurbineRolePermissions(con).add(l);
    165            l.setTurbinePermission((TurbinePermission) this);
    166        }
    167
    168        /**
    169         * The criteria used to select the current contents of collTurbineRolePermissions
    170         */
    171        private Criteria lastTurbineRolePermissionsCriteria = null;
    172
    173        /**
    174         * If this collection has already been initialized, returns
    175         * the collection. Otherwise returns the results of
    176         * getTurbineRolePermissions(new Criteria())
    177         *
    178         * @return the collection of associated objects
    179         * @throws TorqueException
    180         */
    181        public List<TurbineRolePermission> getTurbineRolePermissions()
    182            throws TorqueException
    183        {
    184            if (collTurbineRolePermissions == null)
    185            {
    186                collTurbineRolePermissions = getTurbineRolePermissions(new Criteria(10));
    187            }
    188            return collTurbineRolePermissions;
    189        }
    190
    191        /**
    192         * If this collection has already been initialized with
    193         * an identical criteria, it returns the collection.
    194         * Otherwise if this TurbinePermission has previously
    195         * been saved, it will retrieve related TurbineRolePermissions from storage.
    196         * If this TurbinePermission 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<TurbineRolePermission> getTurbineRolePermissions(Criteria criteria) throws TorqueException
    203        {
    204            if (collTurbineRolePermissions == null)
    205            {
    206                if (isNew())
    207                {
    208                   collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    209                }
    210                else
    211                {
    212                    criteria.add(TurbineRolePermissionPeer.PERMISSION_ID, getPermissionId() );
    213                    collTurbineRolePermissions = TurbineRolePermissionPeer.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(TurbineRolePermissionPeer.PERMISSION_ID, getPermissionId());
    225                    if (!lastTurbineRolePermissionsCriteria.equals(criteria))
    226                    {
    227                        collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria);
    228                    }
    229                }
    230            }
    231            lastTurbineRolePermissionsCriteria = criteria;
    232
    233            return collTurbineRolePermissions;
    234        }
    235
    236        /**
    237         * If this collection has already been initialized, returns
    238         * the collection. Otherwise returns the results of
    239         * getTurbineRolePermissions(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<TurbineRolePermission> getTurbineRolePermissions(Connection con) throws TorqueException
    245        {
    246            if (collTurbineRolePermissions == null)
    247            {
    248                collTurbineRolePermissions = getTurbineRolePermissions(new Criteria(10), con);
    249            }
    250            return collTurbineRolePermissions;
    251        }
    252
    253        /**
    254         * If this collection has already been initialized with
    255         * an identical criteria, it returns the collection.
    256         * Otherwise if this TurbinePermission has previously
    257         * been saved, it will retrieve related TurbineRolePermissions from storage.
    258         * If this TurbinePermission 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<TurbineRolePermission> getTurbineRolePermissions(Criteria criteria, Connection con)
    266                throws TorqueException
    267        {
    268            if (collTurbineRolePermissions == null)
    269            {
    270                if (isNew())
    271                {
    272                   collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    273                }
    274                else
    275                {
    276                     criteria.add(TurbineRolePermissionPeer.PERMISSION_ID, getPermissionId());
    277                     collTurbineRolePermissions = TurbineRolePermissionPeer.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(TurbineRolePermissionPeer.PERMISSION_ID, getPermissionId());
    289                     if (!lastTurbineRolePermissionsCriteria.equals(criteria))
    290                     {
    291                         collTurbineRolePermissions = TurbineRolePermissionPeer.doSelect(criteria, con);
    292                     }
    293                 }
    294             }
    295             lastTurbineRolePermissionsCriteria = criteria;
    296
    297             return collTurbineRolePermissions;
    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 TurbinePermission is new, it will return
    314         * an empty collection; or if this TurbinePermission has previously
    315         * been saved, it will retrieve related TurbineRolePermissions 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 TurbinePermission.
    320         */
    321        protected List<TurbineRolePermission> getTurbineRolePermissionsJoinTurbineRole(Criteria criteria)
    322            throws TorqueException
    323        {
    324            if (collTurbineRolePermissions == null)
    325            {
    326                if (isNew())
    327                {
    328                   collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    329                }
    330                else
    331                {
    332                    criteria.add(TurbineRolePermissionPeer.PERMISSION_ID, getPermissionId());
    333                    collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbineRole(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(TurbineRolePermissionPeer.PERMISSION_ID, getPermissionId());
    342                if (!lastTurbineRolePermissionsCriteria.equals(criteria))
    343                {
    344                    collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbineRole(criteria);
    345                }
    346            }
    347            lastTurbineRolePermissionsCriteria = criteria;
    348
    349            return collTurbineRolePermissions;
    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 TurbinePermission is new, it will return
    364         * an empty collection; or if this TurbinePermission has previously
    365         * been saved, it will retrieve related TurbineRolePermissions 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 TurbinePermission.
    370         */
    371        protected List<TurbineRolePermission> getTurbineRolePermissionsJoinTurbinePermission(Criteria criteria)
    372            throws TorqueException
    373        {
    374            if (collTurbineRolePermissions == null)
    375            {
    376                if (isNew())
    377                {
    378                   collTurbineRolePermissions = new ArrayList<TurbineRolePermission>();
    379                }
    380                else
    381                {
    382                    criteria.add(TurbineRolePermissionPeer.PERMISSION_ID, getPermissionId());
    383                    collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbinePermission(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(TurbineRolePermissionPeer.PERMISSION_ID, getPermissionId());
    392                if (!lastTurbineRolePermissionsCriteria.equals(criteria))
    393                {
    394                    collTurbineRolePermissions = TurbineRolePermissionPeer.doSelectJoinTurbinePermission(criteria);
    395                }
    396            }
    397            lastTurbineRolePermissionsCriteria = criteria;
    398
    399            return collTurbineRolePermissions;
    400        }
    401
    402
    403
    404
    405        private static List<String> fieldNames = null;
    406
    407        /**
    408         * Generate a list of field names.
    409         *
    410         * @return a list of field names
    411         */
    412        public static synchronized List<String> getFieldNames()
    413        {
    414            if (fieldNames == null)
    415            {
    416                fieldNames = new ArrayList<String>();
    417                fieldNames.add("PermissionId");
    418                fieldNames.add("Name");
    419                fieldNames = Collections.unmodifiableList(fieldNames);
    420            }
    421            return fieldNames;
    422        }
    423
    424        /**
    425         * Retrieves a field from the object by field (Java) name passed in as a String.
    426         *
    427         * @param name field name
    428         * @return value
    429         */
    430        public Object getByName(String name)
    431        {
    432            if (name.equals("PermissionId"))
    433            {
    434                return new Integer(getPermissionId());
    435            }
    436            if (name.equals("Name"))
    437            {
    438                return getName();
    439            }
    440            return null;
    441        }
    442
    443        /**
    444         * Set a field in the object by field (Java) name.
    445         *
    446         * @param name field name
    447         * @param value field value
    448         * @return True if value was set, false if not (invalid name / protected field).
    449         * @throws IllegalArgumentException if object type of value does not match field object type.
    450         * @throws TorqueException If a problem occurs with the set[Field] method.
    451         */
    452        public boolean setByName(String name, Object value )
    453            throws TorqueException, IllegalArgumentException
    454        {
    455            if (name.equals("PermissionId"))
    456            {
    457                if (value == null || ! (Integer.class.isInstance(value)))
    458                {
    459                    throw new IllegalArgumentException("setByName: value parameter was null or not an Integer object.");
    460                }
    461                setPermissionId(((Integer) value).intValue());
    462                return true;
    463            }
    464            if (name.equals("Name"))
    465            {
    466                // Object fields can be null
    467                if (value != null && ! String.class.isInstance(value))
    468                {
    469                    throw new IllegalArgumentException("Invalid type of object specified for value in setByName");
    470                }
    471                setName((String) value);
    472                return true;
    473            }
    474            return false;
    475        }
    476
    477        /**
    478         * Retrieves a field from the object by name passed in
    479         * as a String.  The String must be one of the static
    480         * Strings defined in this Class' Peer.
    481         *
    482         * @param name peer name
    483         * @return value
    484         */
    485        public Object getByPeerName(String name)
    486        {
    487            if (name.equals(TurbinePermissionPeer.PERMISSION_ID))
    488            {
    489                return new Integer(getPermissionId());
    490            }
    491            if (name.equals(TurbinePermissionPeer.PERMISSION_NAME))
    492            {
    493                return getName();
    494            }
    495            return null;
    496        }
    497
    498        /**
    499         * Set field values by Peer Field Name
    500         *
    501         * @param name field name
    502         * @param value field value
    503         * @return True if value was set, false if not (invalid name / protected field).
    504         * @throws IllegalArgumentException if object type of value does not match field object type.
    505         * @throws TorqueException If a problem occurs with the set[Field] method.
    506         */
    507        public boolean setByPeerName(String name, Object value)
    508            throws TorqueException, IllegalArgumentException
    509        {
    510          if (TurbinePermissionPeer.PERMISSION_ID.equals(name))
    511            {
    512                return setByName("PermissionId", value);
    513            }
    514          if (TurbinePermissionPeer.PERMISSION_NAME.equals(name))
    515            {
    516                return setByName("Name", value);
    517            }
    518            return false;
    519        }
    520
    521        /**
    522         * Retrieves a field from the object by Position as specified
    523         * in the xml schema.  Zero-based.
    524         *
    525         * @param pos position in xml schema
    526         * @return value
    527         */
    528        public Object getByPosition(int pos)
    529        {
    530            if (pos == 0)
    531            {
    532                return new Integer(getPermissionId());
    533            }
    534            if (pos == 1)
    535            {
    536                return getName();
    537            }
    538            return null;
    539        }
    540
    541        /**
    542         * Set field values by its position (zero based) in the XML schema.
    543         *
    544         * @param position The field position
    545         * @param value field value
    546         * @return True if value was set, false if not (invalid position / protected field).
    547         * @throws IllegalArgumentException if object type of value does not match field object type.
    548         * @throws TorqueException If a problem occurs with the set[Field] method.
    549         */
    550        public boolean setByPosition(int position, Object value)
    551            throws TorqueException, IllegalArgumentException
    552        {
    553        if (position == 0)
    554            {
    555                return setByName("PermissionId", value);
    556            }
    557        if (position == 1)
    558            {
    559                return setByName("Name", value);
    560            }
    561            return false;
    562        }
    563
    564        /**
    565         * Stores the object in the database.  If the object is new,
    566         * it inserts it; otherwise an update is performed.
    567         *
    568         * @throws Exception
    569         */
    570        public void save() throws Exception
    571        {
    572            save(TurbinePermissionPeer.DATABASE_NAME);
    573        }
    574
    575        /**
    576         * Stores the object in the database.  If the object is new,
    577         * it inserts it; otherwise an update is performed.
    578         * Note: this code is here because the method body is
    579         * auto-generated conditionally and therefore needs to be
    580         * in this file instead of in the super class, BaseObject.
    581         *
    582         * @param dbName
    583         * @throws TorqueException
    584         */
    585        public void save(String dbName) throws TorqueException
    586        {
    587            Connection con = null;
    588            try
    589            {
    590                con = Transaction.begin(dbName);
    591                save(con);
    592                Transaction.commit(con);
    593            }
    594            catch(TorqueException e)
    595            {
    596                Transaction.safeRollback(con);
    597                throw e;
    598            }
    599        }
    600
    601        /** flag to prevent endless save loop, if this object is referenced
    602            by another object which falls in this transaction. */
    603        private boolean alreadyInSave = false;
    604        /**
    605         * Stores the object in the database.  If the object is new,
    606         * it inserts it; otherwise an update is performed.  This method
    607         * is meant to be used as part of a transaction, otherwise use
    608         * the save() method and the connection details will be handled
    609         * internally
    610         *
    611         * @param con
    612         * @throws TorqueException
    613         */
    614        public void save(Connection con) throws TorqueException
    615        {
    616            if (!alreadyInSave)
    617            {
    618                alreadyInSave = true;
    619
    620
    621
    622                // If this object has been modified, then save it to the database.
    623                if (isModified())
    624                {
    625                    if (isNew())
    626                    {
    627                        TurbinePermissionPeer.doInsert((TurbinePermission) this, con);
    628                        setNew(false);
    629                    }
    630                    else
    631                    {
    632                        TurbinePermissionPeer.doUpdate((TurbinePermission) this, con);
    633                    }
    634                }
    635
    636
    637                if (collTurbineRolePermissions != null)
    638                {
    639                    for (int i = 0; i < collTurbineRolePermissions.size(); i++)
    640                    {
    641                        ((TurbineRolePermission) collTurbineRolePermissions.get(i)).save(con);
    642                    }
    643                }
    644                alreadyInSave = false;
    645            }
    646        }
    647
    648
    649        /**
    650         * Set the PrimaryKey using ObjectKey.
    651         *
    652         * @param key permissionId ObjectKey
    653         */
    654        public void setPrimaryKey(ObjectKey key)
    655            throws TorqueException
    656        {
    657            setPermissionId(((NumberKey) key).intValue());
    658        }
    659
    660        /**
    661         * Set the PrimaryKey using a String.
    662         *
    663         * @param key
    664         */
    665        public void setPrimaryKey(String key) throws TorqueException
    666        {
    667            setPermissionId(Integer.parseInt(key));
    668        }
    669
    670
    671        /**
    672         * returns an id that differentiates this object from others
    673         * of its class.
    674         */
    675        public ObjectKey getPrimaryKey()
    676        {
    677            return SimpleKey.keyFor(getPermissionId());
    678        }
    679
    680
    681        /**
    682         * Makes a copy of this object.
    683         * It creates a new object filling in the simple attributes.
    684         * It then fills all the association collections and sets the
    685         * related objects to isNew=true.
    686         */
    687        public TurbinePermission copy() throws TorqueException
    688        {
    689            return copy(true);
    690        }
    691
    692        /**
    693         * Makes a copy of this object using connection.
    694         * It creates a new object filling in the simple attributes.
    695         * It then fills all the association collections and sets the
    696         * related objects to isNew=true.
    697         *
    698         * @param con the database connection to read associated objects.
    699         */
    700        public TurbinePermission copy(Connection con) throws TorqueException
    701        {
    702            return copy(true, con);
    703        }
    704
    705        /**
    706         * Makes a copy of this object.
    707         * It creates a new object filling in the simple attributes.
    708         * If the parameter deepcopy is true, it then fills all the
    709         * association collections and sets the related objects to
    710         * isNew=true.
    711         *
    712         * @param deepcopy whether to copy the associated objects.
    713         */
    714        public TurbinePermission copy(boolean deepcopy) throws TorqueException
    715        {
    716            return copyInto(new TurbinePermission(), deepcopy);
    717        }
    718
    719        /**
    720         * Makes a copy of this object using connection.
    721         * It creates a new object filling in the simple attributes.
    722         * If the parameter deepcopy is true, it then fills all the
    723         * association collections and sets the related objects to
    724         * isNew=true.
    725         *
    726         * @param deepcopy whether to copy the associated objects.
    727         * @param con the database connection to read associated objects.
    728         */
    729        public TurbinePermission copy(boolean deepcopy, Connection con) throws TorqueException
    730        {
    731            return copyInto(new TurbinePermission(), deepcopy, con);
    732        }
    733
    734        /**
    735         * Fills the copyObj with the contents of this object.
    736         * The associated objects are also copied and treated as new objects.
    737         *
    738         * @param copyObj the object to fill.
    739         */
    740        protected TurbinePermission copyInto(TurbinePermission copyObj) throws TorqueException
    741        {
    742            return copyInto(copyObj, true);
    743        }
    744
    745
    746        /**
    747         * Fills the copyObj with the contents of this object using connection.
    748         * The associated objects are also copied and treated as new objects.
    749         *
    750         * @param copyObj the object to fill.
    751         * @param con the database connection to read associated objects.
    752         */
    753        protected TurbinePermission copyInto(TurbinePermission copyObj, Connection con) throws TorqueException
    754        {
    755            return copyInto(copyObj, true, con);
    756        }
    757
    758        /**
    759         * Fills the copyObj with the contents of this object.
    760         * If deepcopy is true, The associated objects are also copied
    761         * and treated as new objects.
    762         *
    763         * @param copyObj the object to fill.
    764         * @param deepcopy whether the associated objects should be copied.
    765         */
    766        protected TurbinePermission copyInto(TurbinePermission copyObj, boolean deepcopy) throws TorqueException
    767        {
    768            copyObj.setPermissionId(permissionId);
    769            copyObj.setName(name);
    770
    771            copyObj.setPermissionId( 0);
    772
    773            if (deepcopy)
    774            {
    775
    776
    777            List<TurbineRolePermission> vTurbineRolePermissions = getTurbineRolePermissions();
    778            if (vTurbineRolePermissions != null)
    779            {
    780                for (int i = 0; i < vTurbineRolePermissions.size(); i++)
    781                {
    782                    TurbineRolePermission obj =  vTurbineRolePermissions.get(i);
    783                    copyObj.addTurbineRolePermission(obj.copy());
    784                }
    785            }
    786            else
    787            {
    788                copyObj.collTurbineRolePermissions = null;
    789            }
    790            }
    791            return copyObj;
    792        }
    793
    794
    795        /**
    796         * Fills the copyObj with the contents of this object using connection.
    797         * If deepcopy is true, The associated objects are also copied
    798         * and treated as new objects.
    799         *
    800         * @param copyObj the object to fill.
    801         * @param deepcopy whether the associated objects should be copied.
    802         * @param con the database connection to read associated objects.
    803         */
    804        protected TurbinePermission copyInto(TurbinePermission copyObj, boolean deepcopy, Connection con) throws TorqueException
    805        {
    806            copyObj.setPermissionId(permissionId);
    807            copyObj.setName(name);
    808
    809            copyObj.setPermissionId( 0);
    810
    811            if (deepcopy)
    812            {
    813
    814
    815            List<TurbineRolePermission> vTurbineRolePermissions = getTurbineRolePermissions(con);
    816            if (vTurbineRolePermissions != null)
    817            {
    818                for (int i = 0; i < vTurbineRolePermissions.size(); i++)
    819                {
    820                    TurbineRolePermission obj =  vTurbineRolePermissions.get(i);
    821                    copyObj.addTurbineRolePermission(obj.copy(con), con);
    822                }
    823            }
    824            else
    825            {
    826                copyObj.collTurbineRolePermissions = null;
    827            }
    828            }
    829            return copyObj;
    830        }
    831
    832
    833
    834        /**
    835         * returns a peer instance associated with this om.  Since Peer classes
    836         * are not to have any instance attributes, this method returns the
    837         * same instance for all member of this class. The method could therefore
    838         * be static, but this would prevent one from overriding the behavior.
    839         */
    840        public TurbinePermissionPeer getPeer()
    841        {
    842            return peer;
    843        }
    844
    845        /**
    846         * Retrieves the TableMap object related to this Table data without
    847         * compiler warnings of using getPeer().getTableMap().
    848         *
    849         * @return The associated TableMap object.
    850         */
    851        public TableMap getTableMap() throws TorqueException
    852        {
    853            return TurbinePermissionPeer.getTableMap();
    854        }
    855
    856
    857        public String toString()
    858        {
    859            StringBuffer str = new StringBuffer();
    860            str.append("TurbinePermission:\n");
    861            str.append("PermissionId = ")
    862               .append(getPermissionId())
    863               .append("\n");
    864            str.append("Name = ")
    865               .append(getName())
    866               .append("\n");
    867            return(str.toString());
    868        }
    869    }